partforge 0.55.0 → 0.56.0

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

@@ -0,0 +1,224 @@
+// 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.
+import paper from "paper/dist/paper-core.js";
+import { tessellateContour, reverseContour, closeContourGap } from "./profile.js";
+
+const ORIENT_SEGS = 8;   // points/segment for the local orientation sampler below
+
+let _scope = null;
+function paperScope() {
+  if (!_scope) { _scope = new paper.PaperScope(); _scope.setup(new _scope.Size(1, 1)); }
+  return _scope;
+}
+
+// Circumcircle center + signed sweep for the arc through (p0, via, to) — the sweep is the
+// one passing through `via` (sign-free, winding-free), same recovery as profile.js's
+// sampleArc. Returns null for a collinear (degenerate) triple. Shared by arcToCubicSegments
+// below and contour-ops.js's jointTangents (arc tangents are ⊥ radius, oriented by dA's sign).
+export function arcCenterAndSweep(p0, via, to) {
+  const [ax, ay] = p0, [bx, by] = via, [cx, cy] = to;
+  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d) < 1e-12) return null;
+  const sa = ax*ax + ay*ay, sb = bx*bx + by*by, sc = cx*cx + cy*cy;
+  const ux = (sa * (by - cy) + sb * (cy - ay) + sc * (ay - by)) / d;
+  const uy = (sa * (cx - bx) + sb * (ax - cx) + sc * (bx - ax)) / d;
+  const r = Math.hypot(ax - ux, ay - uy);
+  const a0 = Math.atan2(ay - uy, ax - ux);
+  const av = Math.atan2(by - uy, bx - ux);
+  const a1 = Math.atan2(cy - uy, cx - ux);
+  const twoPi = 2 * Math.PI;
+  const ccw = (x) => { let v = x % twoPi; if (v < 0) v += twoPi; return v; };
+  const dCCW = ccw(a1 - a0), vCCW = ccw(av - a0);
+  const dA = vCCW <= dCCW ? dCCW : dCCW - twoPi;
+  return { center: [ux, uy], r, dA };
+}
+
+// Circular arc through (p0, via, to) → cubic Bézier segments, ≤90° each, endpoints
+// exact. Each piece uses the standard k = (4/3)·tan(θ/4) control-point offset.
+// Collinear triple → straight segment.
+export function arcToCubicSegments(p0, via, to) {
+  const cx = to[0], cy = to[1];
+  const c = arcCenterAndSweep(p0, via, to);
+  if (!c) return [{ to: [cx, cy] }];
+  const { center: [ux, uy], r, dA } = c;
+  const a0 = Math.atan2(p0[1] - uy, p0[0] - ux);
+  // Handle floating-point precision: angles very close to π/2 boundaries
+  const pieces = Math.max(1, Math.ceil((Math.abs(dA) - 1e-9) / (Math.PI / 2)));
+  const out = [];
+  for (let i = 0; i < pieces; i++) {
+    const t0 = a0 + dA * (i / pieces), t1 = a0 + dA * ((i + 1) / pieces);
+    const dt = t1 - t0, k = (4 / 3) * Math.tan(dt / 4);
+    const P = (t) => [ux + r * Math.cos(t), uy + r * Math.sin(t)];
+    const s = P(t0), e = P(t1);
+    out.push({
+      to: e,
+      c1: [s[0] - k * r * Math.sin(t0), s[1] + k * r * Math.cos(t0)],
+      c2: [e[0] + k * r * Math.sin(t1), e[1] - k * r * Math.cos(t1)],
+    });
+  }
+  out[out.length - 1].to = [cx, cy];   // pin the exact endpoint
+  return out;
+}
+
+export function toPaperPath(scope, contour, segMap = null, { open = false } = {}) {
+  const path = new scope.Path({ insert: false });
+  path.moveTo(new scope.Point(contour.start[0], contour.start[1]));
+  let prev = contour.start;
+  contour.segments.forEach((s, i) => {
+    if (s.via) {
+      // Expand {to,via} arc into cubic segments, all sharing one segMap entry
+      const cubics = arcToCubicSegments(prev, s.via, s.to);
+      for (const cubic of cubics) {
+        if (cubic.c1) {
+          path.cubicCurveTo(
+            new scope.Point(cubic.c1[0], cubic.c1[1]),
+            new scope.Point(cubic.c2[0], cubic.c2[1]),
+            new scope.Point(cubic.to[0], cubic.to[1]));
+        } else {
+          // Collinear triple: emit straight segment
+          path.lineTo(new scope.Point(cubic.to[0], cubic.to[1]));
+        }
+        if (segMap) segMap.push(i);
+      }
+      prev = s.to;
+    } else 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]));
+      if (segMap) segMap.push(i);
+      prev = s.to;
+    } else {
+      path.lineTo(new scope.Point(s.to[0], s.to[1]));
+      if (segMap) segMap.push(i);
+      prev = s.to;
+    }
+  });
+  if (!open) {
+    path.closePath();
+    // A contour authored without an explicit closing segment (e.g. pathProfile(...).close())
+    // relies on closePath() to synthesize the closing curve — segMap never saw it. Give it
+    // the next index after the last authored segment so callers can recognize "the implicit
+    // close". When the contour DOES have an explicit closing segment, closePath() joins the
+    // coincident start/end segments and curve count already matches segMap — don't push then.
+    if (segMap && path.curves.length === segMap.length + 1) segMap.push(contour.segments.length);
+  }
+  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;
+}
+
+// Open-path counterpart to toContour: every segment is a real curve of the path (no
+// wrap-around, no implicit-close skip) — for readback of paths built with {open: true}.
+function toOpenContour(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 - 1; i++) {
+    const a = segs[i], b = segs[i + 1];
+    const straight = a.handleOut.isZero() && b.handleIn.isZero();
+    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),
+  }));
+}
+
+// Signed shoelace area of a tessellated ring (CCW positive) — a tiny local sampler so
+// this module doesn't need shape2d-regions.js's ringArea for one call site.
+function shoelaceArea(ring) {
+  let a = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const [x1, y1] = ring[i], [x2, y2] = ring[(i + 1) % ring.length];
+    a += x1 * y2 - x2 * y1;
+  }
+  return a / 2;
+}
+
+// groupPaperPaths (containment-based outer/hole assignment), plus a winding-normalization
+// pass so the emitted contours carry the storage invariant (outer CCW, holes CW in
+// model y-up space). Paper's own `clockwise` flag is in paper's y-down coordinate frame,
+// so it doesn't map onto that invariant directly — decide by area sign of the emitted
+// contour instead: tessellate it and check the shoelace sign, reversing when wrong.
+// closeContourGap re-closes the ring explicitly: toContour() (used by groupPaperPaths,
+// via curve-fill.js too — see its own comment) drops a straight closing edge as
+// "implicit," but every Shape2D region stored from here on must be explicitly closed —
+// contour-ops.js's corner math reads `segments[n-1]` directly as the edge arriving back
+// at `start` and has no other way to know the ring isn't fully spelled out.
+function groupPaperPathsOriented(paths) {
+  const regions = groupPaperPaths(paths);
+  return regions.map(({ outer, holes }) => ({
+    outer: closeContourGap(shoelaceArea(tessellateContour(outer, ORIENT_SEGS)) >= 0 ? outer : reverseContour(outer)),
+    holes: holes.map((h) => closeContourGap(shoelaceArea(tessellateContour(h, ORIENT_SEGS)) < 0 ? h : reverseContour(h))),
+  }));
+}
+
+function cloneRegion(rg) {
+  return JSON.parse(JSON.stringify(rg));
+}
+
+function regionsToCompound(scope, regions) {
+  const children = [];
+  for (const rg of regions) {
+    children.push(toPaperPath(scope, rg.outer));
+    for (const h of rg.holes) children.push(toPaperPath(scope, h));
+  }
+  return new scope.CompoundPath({ children, fillRule: "evenodd" });
+}
+
+// Boolean op between two region lists (each in contour IR) via paper.js's planar boolean
+// engine. op: "unite" | "subtract" | "intersect" — same semantics as bracket.js's Shape2D
+// toolkit. Result regions come back in contour IR with the storage winding invariant
+// (outer CCW, holes CW) restored by groupPaperPathsOriented. Empty result → [].
+export function booleanRegions(aRegions, bRegions, op) {
+  if (!["unite", "subtract", "intersect"].includes(op)) throw new Error(`booleanRegions: unknown op "${op}"`);
+  if (aRegions.length === 0) return op === "unite" ? bRegions.map(cloneRegion) : [];
+  if (bRegions.length === 0) return op === "intersect" ? [] : aRegions.map(cloneRegion);
+  const scope = paperScope();
+  try {
+    const A = regionsToCompound(scope, aRegions), B = regionsToCompound(scope, bRegions);
+    const out = A[op](B, { insert: false });
+    const paths = (out.className === "CompoundPath" ? out.children : [out])
+      .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/polygon.js

@@ -430,3 +430,11 @@ export function offsetPolygon(profile, delta, opts = {}) {
     throw new Error("offsetPolygon: offset result self-intersects (reduce |delta| or simplify the profile)");
   return cleaned;
 }
+
+// The 2-D editing surface (transforms, corner ops, queries, cleanup, validation) lives in
+// contour-ops.js; re-exported here so `partforge/geometry` stays the single import surface.
+export { translateProfile, rotateProfile, scaleProfile, mirrorProfile,
+  filletProfile, chamferProfile, profileCorners,
+  profileLength, profilePointAt, profileTangentAt, profileNearestPoint,
+  profileBounds, profileArea, profileContains,
+  simplifyProfile, validateProfile } from "./contour-ops.js";

package/src/framework/geometry/probe.js

@@ -19,13 +19,21 @@ import {
 } from "./kernel.js";
 import { KERNEL_OP_SPECS, SOLID_OP_SPECS, isPlainOptions } from "./op-options.js";
 
-// The probe returns ONE chainable handle for every non-query op, so it cannot tell a
-// Solid from a Shape2D — k.box() and k.shape2d() yield the same object. The solid-scope
-// allowlist is therefore the union of all three surfaces: deliberately permissive, so
-// it never false-positives on an error-severity rule.
+// The probe hands out TWO chainable handles: k.shape2d()/k.text2d() yield a Shape2D
+// handle (whose extrude/revolve yield the Solid handle), everything else yields the
+// Solid handle. The split exists for one reason — backend routing: `Shape2D.fillet`
+// is the shared pure-JS implementation and must NOT route a part to OCCT, while
+// `Solid.fillet` must. Handle-level VALIDATION stays deliberately permissive (one
+// union allowlist for both handle kinds), so the split can never false-positive on
+// an error-severity rule.
 const KERNEL_ALLOWED = new Set([...KERNEL_OPS, ...KERNEL_OPTIONAL_OPS]);
 const SOLID_ALLOWED = new Set([...SOLID_OPS, ...SOLID_OPTIONAL_OPS, ...SHAPE2D_OPS]);
 
+// Kernel ops whose result is a Shape2D, and Shape2D ops whose result is a Solid —
+// the only two places the probe's handle kind changes.
+const SHAPE2D_YIELDING_KERNEL_OPS = new Set(["shape2d", "text2d"]);
+const SOLID_YIELDING_SHAPE2D_OPS = new Set(["extrude", "revolve"]);
+
 export const MAX_PROBE_OPS = 100000;
 
 // Thrown to unwind a runaway build. Never escapes runValidatingProbe.
@@ -64,37 +72,52 @@ function makeProbe(onCall) {
   // every query bypass the counter entirely, so a query-only loop (`for(;;)
   // s.volume()`) never tripped MAX_PROBE_OPS and hung forever. Wrap it the same
   // way as the chaining branch below: observe the call, then run the real query.
-  const opProxy = (queries, scope) => new Proxy({}, {
+  // `routeFor(op)` picks which handle an op's result chains to — resolved at call
+  // time so the three proxies can reference each other despite declaration order.
+  const opProxy = (queries, scope, routeFor) => new Proxy({}, {
     get(_t, key) {
       if (ignore(key)) return undefined;
       if (key in queries) return (...args) => { onCall(scope, key, args); return queries[key](...args); };
-      return (...args) => { onCall(scope, key, args); return proxy; };
+      return (...args) => { onCall(scope, key, args); return routeFor(key); };
     },
   });
 
-  const proxy = opProxy(solidQueries, "solid");   // a solid handle: every op chains back to itself
-  const kernel = opProxy(kernelQueries, "kernel"); // factory ops (cylinder/box/prism/…) return a solid
-  return { kernel, proxy };
+  // Shape2D handles reuse solidQueries: boundingBox/volume/… dummies chain the same
+  // either way, and a 3-component bbox is as good a dummy as a 2-component one.
+  const proxy = opProxy(solidQueries, "solid", () => proxy);   // a solid handle: every op chains back to itself
+  const shape2d = opProxy(solidQueries, "shape2d",
+    (key) => (SOLID_YIELDING_SHAPE2D_OPS.has(key) ? proxy : shape2d));
+  const kernel = opProxy(kernelQueries, "kernel",             // factory ops (cylinder/box/prism/…) return a solid
+    (key) => (SHAPE2D_YIELDING_KERNEL_OPS.has(key) ? shape2d : proxy));
+  return { kernel, proxy, shape2d };
 }
 
 export function createProbeKernel() {
-  const used = new Set();
-  const { kernel } = makeProbe((_scope, key) => used.add(key));
-  return { kernel, used };
+  const used = new Set();       // every op name, any handle kind
+  const solidUsed = new Set();  // ops recorded on kernel/Solid handles only — the
+                                // routing set: Shape2D.fillet must not look like Solid.fillet
+  const { kernel } = makeProbe((scope, key) => {
+    used.add(key);
+    if (scope !== "shape2d") solidUsed.add(key);
+  });
+  return { kernel, used, solidUsed };
 }
 
 export function createValidatingProbe({ maxOps = MAX_PROBE_OPS } = {}) {
   const calls = [];
   const issues = [];
   const used = new Set();
+  const solidUsed = new Set();  // same split as createProbeKernel: non-Shape2D-handle ops
   let count = 0;
   let solidProxy = null;
+  let shape2dProxy = null;
 
   // Args are recorded as strings so two probe runs can be compared for determinism.
-  // The chainable handle is a single shared object, so identity is enough to spot it —
+  // Each chainable handle is a single shared object, so identity is enough to spot it —
   // and checking identity FIRST matters, because JSON.stringify would trip its traps.
   const describe = (a) => {
     if (a === solidProxy) return "<solid>";
+    if (a === shape2dProxy) return "<shape2d>";
     if (typeof a === "function") return "<fn>";
     try { return JSON.stringify(a) ?? String(a); } catch { return "<unserializable>"; }
   };
@@ -102,6 +125,7 @@ export function createValidatingProbe({ maxOps = MAX_PROBE_OPS } = {}) {
   const onCall = (scope, op, args) => {
     if (++count > maxOps) throw new ProbeRunawayError(`build exceeded ${maxOps} kernel operations`);
     used.add(op);
+    if (scope !== "shape2d") solidUsed.add(op);
     const allowed = scope === "kernel" ? KERNEL_ALLOWED : SOLID_ALLOWED;
     if (!allowed.has(op)) issues.push({ kind: "unknown-op", scope, op });
     // Validate ONLY the options form — the normative rule (KERNEL-CONTRACT.md
@@ -118,9 +142,10 @@ export function createValidatingProbe({ maxOps = MAX_PROBE_OPS } = {}) {
     calls.push({ scope, op, args: args.map(describe) });
   };
 
-  const { kernel, proxy } = makeProbe(onCall);
+  const { kernel, proxy, shape2d } = makeProbe(onCall);
   solidProxy = proxy;
-  return { kernel, calls, issues, used };
+  shape2dProxy = shape2d;
+  return { kernel, calls, issues, used, solidUsed };
 }
 
 /**
@@ -140,5 +165,5 @@ export function runValidatingProbe(part, p, d, { maxOps = MAX_PROBE_OPS } = {})
       throws.push({ subpart: name, message: e?.message || String(e) });
     }
   }
-  return { calls: probe.calls, issues: probe.issues, used: probe.used, throws, runaway };
+  return { calls: probe.calls, issues: probe.issues, used: probe.used, solidUsed: probe.solidUsed, throws, runaway };
 }

package/src/framework/geometry/profile.js

@@ -143,3 +143,54 @@ export function tessellateProfile(profile, segs) {
   const { outer, holes } = normalizeProfile(profile);
   return { outer: tessellateContour(outer, segs), holes: holes.map((hl) => tessellateContour(hl, segs)) };
 }
+
+// Build a straight-edged path contour from a bare point list — the canonical lift for
+// legacy [[x,y],…] inputs into the { start, segments } IR. Lives here (not contour-ops.js)
+// so paper-bridge.js can reach it without importing contour-ops (contour-ops already
+// imports paper-bridge; this module is a pure leaf both can share without a cycle).
+export function pointsToContour(points) {
+  return { start: [points[0][0], points[0][1]],
+    segments: [...points.slice(1).map((p) => ({ to: [p[0], p[1]] })), { to: [points[0][0], points[0][1]] }] };
+}
+
+// Ensure a contour's ring is EXPLICITLY closed: the last segment's `to` must coincide
+// with `start`. Several contour producers leave that closing edge only implicit —
+// paper.js's own Path#closePath() (see toContour() in paper-bridge.js, which drops a
+// straight closing edge as redundant) and any hand-authored `pathProfile(...).close()`
+// that never revisits its own start — relying on a downstream consumer (tessellation,
+// an SVG "Z") to re-synthesize the missing edge. `contourCorners`/`buildCornerOpRing`
+// (contour-ops.js) don't re-synthesize anything: they read `contour.segments` directly
+// and assume `segments[n-1]` really is the edge arriving back at `start` (corner 0's
+// "previous segment", and the wraparound neighbor for every other corner's modular
+// indexing). When that assumption is false, corner 0 gets paired with the wrong
+// segment entirely — if that segment is curved, the fillet/chamfer tangency solve
+// fails outright (`could not fit ... max ≈ 0`); if it's a line, the corner's position
+// and radius are silently miscomputed instead. Call this wherever a contour is about
+// to be stored (Shape2D regions) or handed to any contour-ops function; a no-op when
+// the ring is already closed, so it's safe to call unconditionally.
+export function closeContourGap(contour) {
+  const segs = contour.segments;
+  if (!segs || segs.length === 0) return contour;
+  const [sx, sy] = contour.start;
+  const [lx, ly] = segs[segs.length - 1].to;
+  if (Math.hypot(lx - sx, ly - sy) <= 1e-9) return contour;
+  return { start: contour.start, segments: [...segs, { to: [sx, sy] }] };
+}
+
+// Reverse a contour's traversal direction: walks segments back-to-front, swapping each
+// cubic's control points (c1 ↔ c2) and keeping `via` (an arc's through-point is
+// direction-independent). Lives here alongside pointsToContour for the same reason —
+// paper-bridge.js's booleanRegions needs it to normalize emitted winding without
+// importing contour-ops.js.
+export function reverseContour(contour) {
+  const pts = [contour.start, ...contour.segments.map((s) => s.to)];
+  const segments = [];
+  for (let i = contour.segments.length - 1; i >= 0; i--) {
+    const s = contour.segments[i];
+    const m = { to: [pts[i][0], pts[i][1]] };
+    if (s.via) m.via = [s.via[0], s.via[1]];
+    if (s.c1) { m.c1 = [s.c2[0], s.c2[1]]; m.c2 = [s.c1[0], s.c1[1]]; }
+    segments.push(m);
+  }
+  return { start: [pts[pts.length - 1][0], pts[pts.length - 1][1]], segments };
+}

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

@@ -97,6 +97,62 @@ 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) →
@@ -132,3 +188,47 @@ 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

@@ -0,0 +1,91 @@
+// Shared, backend-agnostic Shape2D factory. Storage is the curve-native contour IR
+// (Tasks 4-10's regions: [{outer, holes}]) — booleans/transforms/queries all run against
+// that IR directly (paper.js under the hood for booleans/area/bounds, no backend WASM
+// 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.
+import { addShape2dSugar } from "./shape2d-sugar.js";
+import { assembleRegions } from "./shape2d-regions.js";
+import { tessellateContour } from "./profile.js";
+import { booleanRegions } from "./paper-bridge.js";
+import { h } from "./solid-hash.js";
+import { closeContourGap } from "./profile.js";
+import {
+  liftProfile, ensureRegionWinding, translateProfile, rotateProfile, scaleProfile,
+  mirrorProfile, filletProfile, chamferProfile, simplifyProfile, profileCorners,
+  profileArea, profileBounds, profileContains,
+} from "./contour-ops.js";
+
+const deepCopy = (regions) => JSON.parse(JSON.stringify(regions));
+
+// Degenerate-input guard, carried over from the tessellation path the Manifold
+// backend used to lift through: a 2-point "polygon" bounds no area, and silently
+// accepting one yields an empty shape instead of an error. POINT LISTS only — a
+// curve contour legitimately closes in one or two segments (a circle is two arcs),
+// so no segment-count rule applies there. Every lift runs this, including the ones
+// behind a boolean operand (`.cut([[0,0],[1,0]])`), so the message names the VALUE
+// (Shape2D) rather than the `shape2d()` entry point.
+const isPointList = (x) => Array.isArray(x) && Array.isArray(x[0]);
+const checkPointRing = (c, role) => {
+  if (isPointList(c) && c.length < 3) throw new Error(`Shape2D: a point-list ${role} needs ≥3 points`);
+};
+const checkProfile = (x) => {
+  if (!x || x._shape2d) return;
+  if (isPointList(x)) { checkPointRing(x, "profile"); return; }
+  for (const rg of Array.isArray(x) ? x : [x]) {
+    if (!rg || !rg.outer) continue;
+    checkPointRing(rg.outer, "outer contour");
+    for (const hole of rg.holes ?? []) checkPointRing(hole, "hole");
+  }
+};
+
+export function makeShape2dFactory({ segs, offsetRegions, 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.
+  const liftRegions = (x) => {
+    if (x && x._shape2d) return deepCopy(x._regions);
+    checkProfile(x);
+    return liftProfile(x).regions.map(ensureRegionWinding);
+  };
+
+  const make = (regions) => {
+    const hash = h("shape2d", regions);
+    const viaOps = (fn) => make(fn(regions));            // regions-in → regions-out delegation
+    const s = {
+      _shape2d: true, _regions: regions, _hash: hash,
+      union:     (o) => make(booleanRegions(regions, liftRegions(o), "unite")),
+      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.
+      offset:    (delta, opts = {}) => make(offsetRegions(regions, delta, opts)
+        .map((rg) => ({ outer: closeContourGap(rg.outer), holes: rg.holes.map(closeContourGap) }))),
+      area:      () => profileArea(regions),
+      boundingBox: () => profileBounds(regions),
+      toRegions: () => assembleRegions(regions.flatMap((rg) =>
+        [tessellateContour(rg.outer, segs), ...rg.holes.map((hl) => tessellateContour(hl, segs))])),
+      toContours: () => deepCopy(regions),
+      clone:     () => make(deepCopy(regions)),
+      translate: (v) => viaOps((r) => translateProfile(r, v)),
+      rotate:    (deg, center) => viaOps((r) => rotateProfile(r, deg, center)),
+      scale:     (f, center) => viaOps((r) => scaleProfile(r, f, center)),
+      mirror:    (axis) => viaOps((r) => mirrorProfile(r, axis)),
+      fillet:    (r, opts) => viaOps((rg) => filletProfile(rg, r, opts)),
+      chamfer:   (d, opts) => viaOps((rg) => chamferProfile(rg, d, opts)),
+      simplify:  (tol) => viaOps((r) => simplifyProfile(r, tol)),
+      corners:   () => profileCorners(regions),
+      contains:  (p) => profileContains(regions, p),
+    };
+    return addShape2dSugar(s, { shape2d, extrude, revolve });
+  };
+  const shape2d = (profile) => (profile && profile._shape2d ? profile : make(liftRegions(profile)));
+  return shape2d;
+}

package/src/framework/jobs.js

@@ -215,12 +215,25 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // The view is built HERE rather than inside measure, and handed down through
       // `opts.built`, because optional match scoring needs the same meshes: one build
       // feeds the measurement and the six silhouette rasterizations both.
-      const built = buildView(kernel, part, msg.view, msg.params ?? {});
-      const measured = measure(kernel, part, msg.view, msg.params ?? {}, { minWall: true, built });
+      //
+      // The default matters and must match measure()'s own: buildView has NO view
+      // default — viewSubParts(part, undefined) returns [] without erroring — so an
+      // inspect with no `view` (partforge-cloud's requestReport has always sent
+      // undefined, meaning "the current view") built an EMPTY view here, and every
+      // downstream consumer degraded silently: measure reported zero subparts and a
+      // [0,0,0] bbox, match scored nothing, and verify still passed. Pre-0.55,
+      // measure built internally and its own signature default hid this. Found by a
+      // live browser check, not by tests: this suite passes explicit views, and the
+      // cloud's unit tests fake the worker.
+      const view = msg.view ?? Object.keys(part.views)[0];
+      const built = buildView(kernel, part, view, msg.params ?? {});
+      const measured = measure(kernel, part, view, msg.params ?? {}, { minWall: true, built });
       const report = {
         measure: measured,
         verify: verify(kernel, part, {
-          view: msg.view,
+          // The defaulted view, not msg.view: the seed below was measured on it, and
+          // verify's seed reuse is only sound when both name the same view.
+          view,
           seed: { params: msg.params ?? {}, result: measured },
         }),
       };