partforge 0.58.0 → 0.59.0

package/src/framework/geometry/kernel.js

@@ -6,7 +6,9 @@
 // options-object form first (the canonical calling convention — normalizers and
 // exact valid-key lists live in op-options.js, wired in at kernel-front.js
 // (finishKernel) and solid-sugar.js (addSugar); legacy positional forms stay
-// silently accepted until contract v2). The prose half of the contract —
+// silently accepted until a future breaking contract version removes them —
+// contract v2 (partforge 0.59) did NOT remove them, it only changed `offset`
+// semantics; see KERNEL-CONTRACT.md's Versioning section). The prose half of the contract —
 // conventions, value semantics, conformance classes, versioning policy — is
 // docs/KERNEL-CONTRACT.md; change either side and you must update the other.
 // (2-D polygon helpers live in ./polygon.js.)
@@ -14,7 +16,7 @@
 // The prose half's version: docs/KERNEL-CONTRACT.md's "Contract version" header
 // must match this number (asserted in kernel-contract.test.js). Bump only on a
 // breaking contract change — see the doc's Versioning section.
-export const CONTRACT_VERSION = 1;
+export const CONTRACT_VERSION = 2;
 
 // Ops every backend kernel must implement.
 export const KERNEL_OPS = [
@@ -45,8 +47,9 @@ 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.
+// the curve-native contour IR, so every op including `offset` is backend-identical
+// by construction (offset runs the native contour-offset engine, not a backend's
+// own 2-D engine).
 export const SHAPE2D_OPS = [
   "union", "cut", "cutAll", "intersect", "offset", "area", "boundingBox", "toRegions", "simple", "regions", "clone",
   "extrude", "revolve",
@@ -84,18 +87,18 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  *           `normals`/`edges` are authoritative shading intent from both backends — see docs/KERNEL-CONTRACT.md "Shading intent"; quality is advisory — the Manifold kernel bakes it at creation
  * @property {(opts?: {quality?: "preview"|"print"}) => Promise<ArrayBuffer>} toSTL
  * @property {() => {positions:Float32Array, indices:Uint32Array}} toIndexedMesh   indexed mesh, for 3MF
- * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges (OCCT only); fillet(3) or fillet({r,edges}); legacy (r,selector) accepted until v2
- * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges (OCCT only); chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted until v2
- * @property {(o:{t:number,open:object}) => Solid} shell   hollow inward (OCCT only); legacy (thickness,openFaces) accepted until v2
+ * @property {(r:number|{r:number,edges?:object}) => Solid} fillet    round edges (OCCT only); fillet(3) or fillet({r,edges}); legacy (r,selector) accepted for now (see file header)
+ * @property {(d:number|{d:number,edges?:object}) => Solid} chamfer  bevel edges (OCCT only); chamfer(1) or chamfer({d,edges}); legacy (d,selector) accepted for now (see file header)
+ * @property {(o:{t:number,open:object}) => Solid} shell   hollow inward (OCCT only); legacy (thickness,openFaces) accepted for now (see file header)
  * @property {() => number} [genus]     through-hole count (Manifold only)
  * @property {() => boolean} [isEmpty]  no geometry at all (Manifold only)
  *
- * @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.
+ * @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 by construction, `offset` included. `_`-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 {(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; empty in → empty out
+ * @property {(delta:number, opts?:{corners?:"round"|"chamfer"|"sharp",segs?:number}) => Shape2D} offset   grow (+) / shrink (−) by delta; backend-identical by construction like every other Shape2D op (native contour-offset engine, not a backend 2-D engine); `segs` accepted and ignored — throws when the shape collapses; empty in → empty out
  * @property {() => boolean} isEmpty   true when the shape has no regions (a cut/intersect removed everything); guard before extrude/revolve, which throw on an empty profile
  * @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)
@@ -117,18 +120,18 @@ export const OCCT_ONLY_OPS = ["fillet", "chamfer", "shell"];
  * @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
+ * @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 for now (see file header)
  * @property {(o:{od:number,h:number,bore:number}) => Solid} boredCylinder   compound: bored-through cylinder (one cache node)
  * @property {(o:{r?:number,d?:number}) => Solid} sphere   sphere centred at the origin; {r|d}; bare sphere(r) stays valid
  * @property {(o:{r?:number,d?:number,h:number,center?:boolean,round:number|{top?:number,bottom?:number}}) => Solid} roundedCylinder   rim round-overs via one lathe revolve; options-only; round ≤ r, top+bottom ≤ h
  * @property {(o:{rMajor:number,rMinor:number}) => Solid} torus   centered at origin, tube centerline in the z=0 plane; 0 < rMinor < rMajor; options-only
  * @property {(o:{size:number[],center?:boolean,round:number|{side?:number,top?:number,bottom?:number}}) => Solid} roundedBox   selective edge rounding (side = vertical edges, top/bottom = rims); 0 < side < rim clamps rims down to side with a console.warn; options-only
- * @property {(o:{size?:number[],center?:boolean,min?:number[],max?:number[]}) => Solid} box   {size} = centered X/Y, base z=0 ({center:true} centers Z too) or {min,max}; legacy (min,max) accepted until v2
- * @property {(o:{points:number[][],h:number,twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0; legacy (points,h,opts) accepted until v2
- * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   polygon-with-holes region from z=0; bevel = 45° rim bevel (any profile form incl. Shape2D, materialized to point rings; no twist/scaleTop); legacy (profile,h,opts) accepted until v2
- * @property {(o:{rings:{polygon?:number[][],sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[],ruled?:boolean,closed?:boolean,shading?:"smooth"|"faceted"}) => Solid} loft   stack polygon cross-sections; shading overrides facet-vs-smooth shading inference; legacy (rings,opts) accepted until v2
- * @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 until v2
- * @property {(o:{profile:number[][],degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted until v2
+ * @property {(o:{size?:number[],center?:boolean,min?:number[],max?:number[]}) => Solid} box   {size} = centered X/Y, base z=0 ({center:true} centers Z too) or {min,max}; legacy (min,max) accepted for now (see file header)
+ * @property {(o:{points:number[][],h:number,twist?:number,scaleTop?:number}) => Solid} prism   extrude polygon from z=0; legacy (points,h,opts) accepted for now (see file header)
+ * @property {(o:{profile:number[][]|{outer:number[][],holes?:number[][][]},h:number,twist?:number,scaleTop?:number,bevel?:number|{bottom?:number,top?:number}}) => Solid} extrude   polygon-with-holes region from z=0; bevel = 45° rim bevel (any profile form incl. Shape2D, materialized to point rings; no twist/scaleTop); legacy (profile,h,opts) accepted for now (see file header)
+ * @property {(o:{rings:{polygon?:number[][],sides?:number,radius?:number,z:number,rotate?:number,scale?:number|number[]}[],ruled?:boolean,closed?:boolean,shading?:"smooth"|"faceted"}) => Solid} loft   stack polygon cross-sections; shading overrides facet-vs-smooth shading inference; legacy (rings,opts) accepted for now (see file header)
+ * @property {(o:{profile:number[][],path:number[][],closed?:boolean,cornerRadius?:number,ruled?:boolean,smooth?:boolean}) => Solid} sweep   sweep a 2-D profile along a 3-D polyline; legacy (profile,path,opts) accepted for now (see file header)
+ * @property {(o:{profile:number[][],degrees?:number}) => Solid} revolve   revolve a lathe profile [[r,z],…] around Z; legacy (points,opts) accepted for now (see file header)
  * @property {(o:{pathR:number,profileR:number,pitch:number,turns:number,z0:number,lefthand:boolean}) => Solid} helixSweptTube
  * @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

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

@@ -2,12 +2,12 @@ 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, pointsToContour } from "./profile.js";
+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 { makeShape2dFactory } from "./shape2d.js";
-import { assembleRegions } from "./shape2d-regions.js";
+import { offsetRegions } from "./contour-offset.js";
 import { finishKernel } from "./kernel-front.js";
 import { meshToStl } from "./mesh-stl.js";
 import { creasedNormals } from "./creased-normals.js";
@@ -53,58 +53,17 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     return { value: wrap(m, hash), pin: m, dispose: () => m.delete?.() };
   });
 
-  // 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.
+  // contour IR and every op — including `offset`, now the shared native engine — 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),
   });
@@ -326,8 +285,10 @@ 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.
+    // Backend-internal region adapter: the shared native engine (contour-offset.js)
+    // that Shape2D.offset itself runs on — published here for callers that want the
+    // region-in/region-out form directly. `_`-prefixed — not part of the public kernel
+    // surface.
     _offsetRegions: offsetRegions,
     beginSubPart: (name) => cache.begin(name),
     endSubPart: () => cache.end(),

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

@@ -19,14 +19,14 @@ import { toEdgeFinder } from "./edge-selector.js";
 import { toFaceFinder } from "./face-selector.js";
 import { addSugar } from "./solid-sugar.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, tessellateContour, reverseContour } from "./profile.js";
+import { normalizeProfile } from "./profile.js";
 import { roundedRectContour } from "./rounded-solids.js";
+import { offsetRegions } from "./contour-offset.js";
 import { h } from "./solid-hash.js";
 import { createSolidCache } from "./solid-cache.js";
 import { composePose, transformPositions, rotateNormals } from "./pose.js";
@@ -332,105 +332,21 @@ export function createOcctKernel(replicad) {
   };
   // 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.
+  // drawingFromProfile above. Used by extrude/revolve (via drawingFor below) 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.
-  //
-  // 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
-      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)) }));
-  };
-
-  // 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;
-  };
-  // 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.
+  // backend's. Storage is the curve-native contour IR and every op — including
+  // `offset`, now the shared native engine — runs on it in pure JS; 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),
   });
@@ -552,8 +468,10 @@ 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.
+    // Backend-internal region adapter: the shared native engine (contour-offset.js)
+    // that Shape2D.offset itself runs on — published here for callers that want the
+    // region-in/region-out form directly. `_`-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),

package/src/framework/geometry/paper-bridge.js

@@ -221,4 +221,33 @@ export function booleanRegions(aRegions, bRegions, op) {
   }
 }
 
+// Self-resolve one region list: per-region self-unite resolves self-intersections and
+// winding-inverted loops inside each region; pairwise unite fold merges overlaps BETWEEN
+// regions. This two-stage approach avoids the cancellation issue of whole-list evenodd
+// self-unite (which cancelled overlapping children). Same readback and winding normalization
+// as booleanRegions. Empty result → []. NB paper has no arc primitive, so arcs return as
+// cubic approximations (arcToCubicSegments) — identical to what every boolean already does.
+export function resolveSelfRegions(regions) {
+  if (regions.length === 0) return [];
+  const scope = paperScope();
+  try {
+    let acc = null;
+    for (const rg of regions) {
+      const R = regionsToCompound(scope, [rg]);
+      const netInverted = R.area < -1e-9;
+      const r = R.unite(R, { insert: false });
+      if (netInverted && r.area > 1e-9) continue;   // collapsed/inverted region cancels
+      if (Math.abs(r.area) <= 1e-9) continue;
+      acc = acc ? acc.unite(r, { insert: false }) : r;
+    }
+    if (!acc) return [];
+    const paths = (acc.className === "CompoundPath" ? acc.children : [acc])
+      .filter((p) => p.segments && p.segments.length >= 2 && Math.abs(p.area) > 1e-9);
+    if (!paths.length) return [];
+    return groupPaperPathsOriented(paths);
+  } finally {
+    scope.project.clear();
+  }
+}
+
 export { paperScope, toContour, toOpenContour, groupPaperPaths };

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

@@ -2,7 +2,8 @@
 // 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.
+// sampleBezier / sampleArc so an OCCT-materialized curve facets like Manifold —
+// it is TEST-ONLY now that no backend has an SVG readback route (see its comment).
 import { sampleBezier } from "./profile.js";
 
 // Signed shoelace area of a ring (CCW positive). Exported (in addition to its use
@@ -97,66 +98,18 @@ function sampleSvgArc(from, rx, ry, rotDeg, largeArc, sweep, to, segs) {
   return out;
 }
 
-// Split an SVG elliptical-arc segment (endpoint parameterization, same center-form
-// math as sampleSvgArc above) into ≤90° cubic Bézier pieces via the standard
-// k = (4/3)tan(dθ/4) control-point formula in the ellipse's own rotated/scaled
-// frame, then mapped back through the rotation+translation into model space.
-// Returns segments as { to, c1, c2 } (no `from` — the caller already holds it).
-function svgArcToCubics(from, rx, ry, rotDeg, largeArc, sweep, to) {
-  const [x1, y1] = from, [x2, y2] = to;
-  if (rx === 0 || ry === 0) return [{ to: [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;
-  // point on the ellipse (model space) + its tangent direction, at parameter t
-  const pointAt = (t) => {
-    const ex = RX * Math.cos(t), ey = RY * Math.sin(t);
-    return [cx + cosP * ex - sinP * ey, cy + sinP * ex + cosP * ey];
-  };
-  const tangentAt = (t) => {
-    const ex = -RX * Math.sin(t), ey = RY * Math.cos(t);
-    return [cosP * ex - sinP * ey, sinP * ex + cosP * ey];
-  };
-  const pieces = Math.max(1, Math.ceil(Math.abs(dTheta) / (Math.PI / 2)));
-  const dSeg = dTheta / pieces;
-  const kFac = (4 / 3) * Math.tan(dSeg / 4);
-  const out = [];
-  for (let i = 0; i < pieces; i++) {
-    const tA = theta1 + dSeg * i, tB = theta1 + dSeg * (i + 1);
-    const pA = i === 0 ? [x1, y1] : pointAt(tA);
-    const pB = i === pieces - 1 ? [x2, y2] : pointAt(tB);
-    const tanA = tangentAt(tA), tanB = tangentAt(tB);
-    const c1 = [pA[0] + kFac * tanA[0], pA[1] + kFac * tanA[1]];
-    const c2 = [pB[0] - kFac * tanB[0], pB[1] - kFac * tanB[1]];
-    out.push({ to: pB, c1, c2 });
-  }
-  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) →
+// TEST-ONLY. 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.
+//
+// This existed for the OCCT backend's SVG readback of a replicad Drawing. That route is
+// gone (both backends run the native contour-offset engine), so nothing in src/ calls
+// this any more — its one remaining consumer is test/offset-oracle-occt.test.js, which
+// reconstructs the deleted route to cross-check the native engine against BRepOffsetAPI.
+// Kept, exported and tested for that; do NOT reintroduce it into a runtime path without
+// reconsidering whether an SVG round-trip is the right seam. (Its curve-preserving twin
+// svgPathToContours was deleted outright in the same cleanup — it had no callers at all.)
 export function svgPathToRings(d, segs) {
   const toks = d.match(/[a-zA-Z]|-?\d*\.?\d+(?:e[-+]?\d+)?/g) ?? [];
   const rings = [];
@@ -188,47 +141,3 @@ export function svgPathToRings(d, segs) {
   pushRing();
   return rings;
 }
-
-// SVG-path tokenizer that emits contour IR ({ start, segments: [{to}|{to,c1,c2}] },
-// the path-contour shape from profile.js) instead of tessellated point rings — the
-// curve-preserving twin of svgPathToRings above, same command set (M L C Q A Z) and
-// the same tokenizer/error-message conventions. C stays a cubic segment as-is; Q
-// degree-elevates to a cubic with the identical control-point math svgPathToRings
-// uses (just not sampled into points); A splits into ≤90° cubic pieces via
-// svgArcToCubics. Z closes the subpath with a straight segment back to its start
-// (mirroring pointsToContour's implicit closing edge) when not already there.
-export function svgPathToContours(d) {
-  const toks = d.match(/[a-zA-Z]|-?\d*\.?\d+(?:e[-+]?\d+)?/g) ?? [];
-  const contours = [];
-  let start = null, segments = null, cur = [0, 0], cmd = null, i = 0;
-  const num = () => Number(toks[i++]);
-  const pt = () => [num(), num()];
-  const pushContour = () => { if (start && segments && segments.length >= 1) contours.push({ start, segments }); start = null; segments = null; };
-  while (i < toks.length) {
-    if (/^[a-zA-Z]$/.test(toks[i])) {
-      cmd = toks[i++];
-      if (!"MLCQAZ".includes(cmd)) throw new Error(`svgPathToContours: unsupported SVG command "${cmd}"`);
-    }
-    if (cmd === "M") { pushContour(); cur = pt(); start = cur.slice(); segments = []; cmd = "L"; }
-    else if (cmd === "L") { cur = pt(); segments.push({ to: cur.slice() }); }
-    else if (cmd === "C") { const c1 = pt(), c2 = pt(), end = pt(); segments.push({ to: end, c1, c2 }); 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])];
-      segments.push({ to: end, c1, c2 }); cur = end;
-    }
-    else if (cmd === "A") {
-      const rx = num(), ry = num(), rot = num(), large = num(), sweep = num(), end = pt();
-      for (const seg of svgArcToCubics(cur, rx, ry, rot, large, sweep, end)) segments.push(seg);
-      cur = end;
-    }
-    else if (cmd === "Z") {
-      if (cur[0] !== start[0] || cur[1] !== start[1]) segments.push({ to: start.slice() });
-      pushContour(); cmd = null;
-    }
-    else throw new Error("svgPathToContours: coordinate before or after a command");
-  }
-  pushContour();
-  return contours;
-}

package/src/framework/geometry/shape2d.js

@@ -4,13 +4,16 @@
 // involved). `toRegions()`/`simple()` are the only points where a shape gets tessellated
 // down to point rings, for handoff to a kernel op (extrude/revolve) or export.
 //
-// `deps.offsetRegions`/`deps.extrude`/`deps.revolve` are the two backends' own hooks
-// (Task 13 wires Manifold/OCCT versions); everything else here is pure curve math shared
-// by both. Each op returns a NEW Shape2D — value semantics, no operand is ever mutated.
+// `deps.extrude`/`deps.revolve` are the two backends' own hooks (Task 13 wires
+// Manifold/OCCT versions); everything else here is pure curve math shared by both,
+// including offset, which now runs the native contour-offset engine directly rather
+// than through a backend hook. Each op returns a NEW Shape2D — value semantics, no
+// operand is ever mutated.
 import { addShape2dSugar } from "./shape2d-sugar.js";
 import { assembleRegions } from "./shape2d-regions.js";
 import { tessellateContour } from "./profile.js";
 import { booleanRegions } from "./paper-bridge.js";
+import { offsetRegions } from "./contour-offset.js";
 import { h } from "./solid-hash.js";
 import { closeContourGap } from "./profile.js";
 import {
@@ -42,7 +45,7 @@ const checkProfile = (x) => {
   }
 };
 
-export function makeShape2dFactory({ segs, offsetRegions, extrude, revolve }) {
+export function makeShape2dFactory({ segs, extrude, revolve }) {
   // Lift any accepted profile form into stored regions: a live Shape2D is deep-copied out
   // via its own toContours() (value semantics — never alias another shape's storage);
   // anything else goes through liftProfile + per-ring winding normalization.
@@ -61,14 +64,15 @@ export function makeShape2dFactory({ segs, offsetRegions, extrude, revolve }) {
       cut:       (o) => make(booleanRegions(regions, liftRegions(o), "subtract")),
       cutAll:    (os) => make(os.reduce((acc, o) => booleanRegions(acc, liftRegions(o), "subtract"), regions)),
       intersect: (o) => make(booleanRegions(regions, liftRegions(o), "intersect")),
-      // offsetRegions is the one backend hook feeding straight into make() — it doesn't route
-      // through liftRegions, so unlike every other op here nothing already guaranteed its
-      // rings are explicitly closed. Both backends' readbacks close explicitly today, so this
-      // is a no-op in practice; it's here so the storage invariant (every stored ring
-      // explicitly closed — see closeContourGap's own comment) holds unconditionally.
-      // Empty in → empty out without calling the hook: the 2-D ops stay total on the
-      // empty shape on both backends (the OCCT hook would otherwise choke on a null
-      // Drawing); only 3-D materialization (extrude/revolve) rejects it.
+      // offset now runs the shared native engine directly, like the booleans above — no
+      // backend hook. Its result feeds straight into make() without routing through
+      // liftRegions, so unlike every other op here nothing already guaranteed its rings
+      // are explicitly closed; offsetRegions' own readback closes explicitly today, so
+      // this is a no-op in practice. It's here so the storage invariant (every stored
+      // ring explicitly closed — see closeContourGap's own comment) holds unconditionally.
+      // Empty in → empty out without entering the engine: the 2-D ops stay total on the
+      // empty shape, and the engine would otherwise read an empty result as a collapse
+      // and throw. Only 3-D materialization (extrude/revolve) rejects the empty shape.
       offset:    (delta, opts = {}) => regions.length === 0 ? make([]) : make(offsetRegions(regions, delta, opts)
         .map((rg) => ({ outer: closeContourGap(rg.outer), holes: rg.holes.map(closeContourGap) }))),
       isEmpty:   () => regions.length === 0,

package/src/framework/mount.js

@@ -346,6 +346,14 @@ export function mount(part, { createWorker, elements = {}, onBuild, onPick, onDo
     if (onPick) {
       picker = attachPicker(viewer, {
         part, getContext,
+        // Measure mode claims canvas clicks for pinning dimensions, so while it
+        // is on a click must not ALSO select-and-flash (hosts turn picks into
+        // chat chips — one click was doing both). Same idea as the hover
+        // suppression above, but pull-based: checked per click, nothing to
+        // resync on mode changes. The ?pick/?pickserver harnesses below are
+        // deliberately not guarded — one is armed by an explicit dev toggle,
+        // the other per agent request.
+        suppressed: () => measureMode.isEnabled(),
         onPick: (selection) => onPick({
           selection,
           label: selection.feature?.label ?? part.parts[selection.subPart]?.label ?? selection.subPart,

package/src/framework/selection/pick.js

@@ -6,13 +6,19 @@ import { createDragTracker } from "./drag-tracker.js";
 
 export { worldToSubPartLocal };
 
-export function attachPicker(viewer, { part, getContext, onPick }) {
+// `suppressed` is an optional pull-based guard checked per click, for a caller
+// whose suppression condition lives elsewhere (mount passes measure mode's
+// isEnabled): while it returns true a click neither raycasts, flashes, nor
+// picks — no resync bookkeeping the way an event-driven setActive would need.
+export function attachPicker(viewer, { part, getContext, onPick, suppressed }) {
   let active = false;
   const drag = createDragTracker();
 
   function onClick(ev) {
+    // consumeClick() first, unconditionally — the drag tracker is stateful and
+    // a suppressed click must still clear its just-dragged flag.
     const wasDragged = drag.consumeClick();
-    if (!active || wasDragged) return;
+    if (!active || wasDragged || suppressed?.()) return;
     const hit = raycastViewer(viewer, ev.clientX, ev.clientY);
     if (!hit) return;
     const selection = resolveSelection(part, getContext(), hit);