partforge 0.121.0 → 0.121.1

package/package.json

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

package/src/framework/geometry/arc-math.js

@@ -0,0 +1,27 @@
+// Pure arc math, paper-free: circumcircle center + signed sweep for the arc through three
+// points. Split out of paper-bridge.js so callers that only need this number crunching (the
+// oracle's shape-probe.js, contour-ops.js's corner/tangent math) don't pull in paper-core —
+// paper-bridge.js still re-exports arcCenterAndSweep so every existing importer of it is
+// unaffected.
+
+// 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
+// (paper-bridge.js) 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 };
+}

package/src/framework/geometry/contour-corners.js

@@ -0,0 +1,130 @@
+// Paper-free corner/tangent math for the contour IR, split out of contour-ops.js so the
+// oracle's shape-probe.js (and anything else that only needs a shape's corners/tangents, not
+// its booleans/transforms) doesn't pull in paper-core through contour-ops.js's own
+// paper-bridge.js import. Imports only profile.js, shape2d-regions.js and arc-math.js — never
+// paper-bridge.js or contour-ops.js, which is what keeps this leaf paper-free.
+import { isPathContour, tessellateContour, pointsToContour, closeContourGap } from "./profile.js";
+import { ringArea } from "./shape2d-regions.js";
+import { arcCenterAndSweep } from "./arc-math.js";
+
+export const WINDING_SEGS = 64;   // tessellation LOD for orientation/containment sampling
+
+export const isPointList = (x) => Array.isArray(x) && x.length > 0 && Array.isArray(x[0]);
+// pointsToContour always closes explicitly; a raw {start,segments} contour (hand-authored
+// via pathProfile, or handed back from a Shape2D's own stored regions) might not —
+// closeContourGap is a no-op when it's already closed, so every ring liftProfile hands to
+// contour-ops' corner/transform/query functions is guaranteed explicitly closed.
+export const liftContour = (c) => (isPointList(c) ? pointsToContour(c) : closeContourGap(c));
+
+export function liftProfile(input) {
+  if (input && input._shape2d) return { kind: "regions", regions: input.toContours() };
+  if (isPointList(input)) return { kind: "points", regions: [{ outer: pointsToContour(input), holes: [] }] };
+  if (isPathContour(input)) return { kind: "contour", regions: [{ outer: closeContourGap(input), holes: [] }] };
+  if (Array.isArray(input) && input.every((r) => r && r.outer))
+    return { kind: "regions", regions: input.map((r) => ({ outer: liftContour(r.outer), holes: (r.holes ?? []).map(liftContour) })) };
+  if (input && input.outer)
+    return { kind: "region", regions: [{ outer: liftContour(input.outer), holes: (input.holes ?? []).map(liftContour) }] };
+  throw new Error("contour-ops: input must be [[x,y],…], a {start,segments} contour, {outer,holes}, or a region array");
+}
+
+export const contourIsCCW = (c) => ringArea(tessellateContour(c, WINDING_SEGS)) >= 0;
+
+// ── Corner model ────────────────────────────────────────────────────────────
+// profileCorners() walks a contour's joints and reports each non-smooth one: the interior
+// angle, whether it's convex (material-relative — see below), and the segment kinds either
+// side of it. jointTangents() is the shared per-vertex tangent computation, reused by Task 6.
+
+export const SMOOTH_JOINT_DEG = 1;
+
+// Unit tangent of segment `s` (from `from`) at its start (dir=+1) or end (dir=-1 → arrival direction).
+// Exported for contour-winding.js's _chain: junction ordering at a curved pinch point needs
+// the exact endpoint tangent, not an approximation (via/c1/c2 are NOT control points that
+// happen to sit near the tangent — via in particular is a THROUGH point near mid-sweep, so
+// from->via is systematically biased by about sweep/4). This recovers it exactly for arcs
+// (perpendicular to the radius at the recovered center, oriented by the sweep's sign) and
+// cubics (including the degenerate c1===from case, where the true tangent comes from c2).
+export function segTangent(from, s, atStart) {
+  const norm = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L, y / L]; };
+  if (s.c1) {
+    if (atStart) {
+      const d = [s.c1[0] - from[0], s.c1[1] - from[1]];
+      return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.c2[0] - from[0], s.c2[1] - from[1]]);
+    }
+    const d = [s.to[0] - s.c2[0], s.to[1] - s.c2[1]];
+    return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.to[0] - s.c1[0], s.to[1] - s.c1[1]]);
+  }
+  if (s.via) {
+    // tangent ⊥ radius, oriented along the sweep (recover center like arcToCubicSegments)
+    const c = arcCenterAndSweep(from, s.via, s.to);          // {center:[x,y], dA} or null
+    if (!c) return norm([s.to[0] - from[0], s.to[1] - from[1]]);
+    const p = atStart ? from : s.to;
+    const r = [p[0] - c.center[0], p[1] - c.center[1]];
+    const t = c.dA >= 0 ? [-r[1], r[0]] : [r[1], -r[0]];
+    return norm(t);
+  }
+  return norm([s.to[0] - from[0], s.to[1] - from[1]]);
+}
+
+export function jointTangents(contour) {  // per vertex i: tangent arriving at and leaving vertex i
+  const n = contour.segments.length;
+  const pts = [contour.start, ...contour.segments.map((s) => s.to)];
+  return contour.segments.map((_, i) => {
+    const prevSeg = contour.segments[(i - 1 + n) % n];
+    const prevFrom = pts[(i - 1 + n) % n];
+    return {
+      point: pts[i],
+      inTan: segTangent(prevFrom, prevSeg, false),
+      outTan: segTangent(pts[i], contour.segments[i], true),
+    };
+  });
+}
+
+export const segType = (s) => (s.c1 ? "cubic" : s.via ? "arc" : "line");
+
+export function contourCorners(contour) {
+  const ccw = contourIsCCW(contour);
+  const n = contour.segments.length;
+  const out = [];
+  jointTangents(contour).forEach(({ point, inTan, outTan }, i) => {
+    const cross = inTan[0] * outTan[1] - inTan[1] * outTan[0];
+    const dot = Math.min(1, Math.max(-1, inTan[0] * outTan[0] + inTan[1] * outTan[1]));
+    const turnDeg = (Math.atan2(Math.abs(cross), dot) * 180) / Math.PI;
+    if (turnDeg < SMOOTH_JOINT_DEG) return;
+    const leftTurn = cross > 0;
+    out.push({
+      index: i, point: [point[0], point[1]],
+      interiorAngleDeg: ccw === leftTurn ? 180 - turnDeg : 180 + turnDeg,
+      convex: leftTurn === ccw,
+      segTypes: [segType(contour.segments[(i - 1 + n) % n]), segType(contour.segments[i])],
+    });
+  });
+  return out;
+}
+
+// Two numbers on every corner, and they are NOT interchangeable. `index` is the joint's
+// vertex number within its own contour (what buildCornerOpRing, simplify and the lofts
+// key on); `position` is the corner's place in THIS returned list — the one
+// `{corners: {indices}}` selects by. They diverge as soon as a contour has a smooth
+// joint (a collinear midpoint, a G1 arc-line join), and on region input `index`
+// restarts per ring while `position` runs on through the flattened order.
+const withPositions = (corners) => corners.map((c, position) => ({ ...c, position }));
+
+export function profileCorners(input) {
+  const { kind, regions } = liftProfile(input);
+  if (kind === "points" || kind === "contour") return withPositions(contourCorners(regions[0].outer));
+  const out = [];
+  regions.forEach((rg, regionIndex) => {
+    for (const c of contourCorners(rg.outer)) out.push({ regionIndex, ring: "outer", ...c });
+    rg.holes.forEach((h, hi) => { for (const c of contourCorners(h)) out.push({ regionIndex, ring: { hole: hi }, ...c }); });
+  });
+  return withPositions(out);
+}
+
+export function cubicAt(p0, c1, c2, p1, t) {
+  const u = 1 - t;
+  return [0, 1].map((k) => u * u * u * p0[k] + 3 * u * u * t * c1[k] + 3 * u * t * t * c2[k] + t * t * t * p1[k]);
+}
+export function cubicDeriv(p0, c1, c2, p1, t) {
+  const u = 1 - t;
+  return [0, 1].map((k) => 3 * u * u * (c1[k] - p0[k]) + 6 * u * t * (c2[k] - c1[k]) + 3 * t * t * (p1[k] - c2[k]));
+}

package/src/framework/geometry/contour-ops.js

@@ -1,32 +1,19 @@
-import { isPathContour, tessellateContour, pointsToContour, reverseContour, closeContourGap } from "./profile.js";
+import { reverseContour, closeContourGap } from "./profile.js";
 import { ringArea, pointInRing } from "./shape2d-regions.js";
 import { arcToCubicSegments, arcCenterAndSweep, paperScope, toPaperPath, toContour, toOpenContour } from "./paper-bridge.js";
+import { liftProfile, contourIsCCW, contourCorners, cubicAt, cubicDeriv } from "./contour-corners.js";
 
 // Re-exported so existing importers (test/contour-ops-lift.test.js and others) keep
-// working unchanged — the definitions live in profile.js (the contour-IR home) so
-// paper-bridge.js can use them without importing this module (which already imports
+// working unchanged — the definition lives in profile.js (the contour-IR home) so
+// paper-bridge.js can use it without importing this module (which already imports
 // paper-bridge.js; importing back would cycle).
-export { pointsToContour, reverseContour };
-
-const WINDING_SEGS = 64;   // tessellation LOD for orientation/containment sampling
-
-const isPointList = (x) => Array.isArray(x) && x.length > 0 && Array.isArray(x[0]);
-// pointsToContour always closes explicitly; a raw {start,segments} contour (hand-authored
-// via pathProfile, or handed back from a Shape2D's own stored regions) might not —
-// closeContourGap is a no-op when it's already closed, so every ring liftProfile hands to
-// contour-ops' corner/transform/query functions is guaranteed explicitly closed.
-const liftContour = (c) => (isPointList(c) ? pointsToContour(c) : closeContourGap(c));
-
-export function liftProfile(input) {
-  if (input && input._shape2d) return { kind: "regions", regions: input.toContours() };
-  if (isPointList(input)) return { kind: "points", regions: [{ outer: pointsToContour(input), holes: [] }] };
-  if (isPathContour(input)) return { kind: "contour", regions: [{ outer: closeContourGap(input), holes: [] }] };
-  if (Array.isArray(input) && input.every((r) => r && r.outer))
-    return { kind: "regions", regions: input.map((r) => ({ outer: liftContour(r.outer), holes: (r.holes ?? []).map(liftContour) })) };
-  if (input && input.outer)
-    return { kind: "region", regions: [{ outer: liftContour(input.outer), holes: (input.holes ?? []).map(liftContour) }] };
-  throw new Error("contour-ops: input must be [[x,y],…], a {start,segments} contour, {outer,holes}, or a region array");
-}
+export { reverseContour };
+
+// The paper-free corner/tangent/lift math now lives in contour-corners.js — so the oracle's
+// shape-probe.js can use profileCorners()/cubicAt() without pulling in paper-core through
+// this module's own paper-bridge.js import below — re-exported here so every existing
+// importer of these names from contour-ops.js keeps working unchanged.
+export { liftProfile, contourIsCCW, SMOOTH_JOINT_DEG, segTangent, jointTangents, profileCorners, cubicAt } from "./contour-corners.js";
 
 export function restoreProfile(kind, regions) {
   if (kind === "regions") return regions;
@@ -43,8 +30,6 @@ export function restoreProfile(kind, regions) {
   return outer;   // curves were introduced — upgrade to a contour
 }
 
-export const contourIsCCW = (c) => ringArea(tessellateContour(c, WINDING_SEGS)) >= 0;
-
 export function ensureRegionWinding(region) {
   return {
     outer: contourIsCCW(region.outer) ? region.outer : reverseContour(region.outer),
@@ -116,97 +101,6 @@ export function mirrorProfile(input, axis) {
   return transformProfile(input, [a, b, b, -a, px - a * px - b * py, py - b * px + a * py]);
 }
 
-// ── Corner model ────────────────────────────────────────────────────────────
-// profileCorners() walks a contour's joints and reports each non-smooth one: the interior
-// angle, whether it's convex (material-relative — see below), and the segment kinds either
-// side of it. jointTangents() is the shared per-vertex tangent computation, reused by Task 6.
-
-export const SMOOTH_JOINT_DEG = 1;
-
-// Unit tangent of segment `s` (from `from`) at its start (dir=+1) or end (dir=-1 → arrival direction).
-// Exported for contour-winding.js's _chain: junction ordering at a curved pinch point needs
-// the exact endpoint tangent, not an approximation (via/c1/c2 are NOT control points that
-// happen to sit near the tangent — via in particular is a THROUGH point near mid-sweep, so
-// from->via is systematically biased by about sweep/4). This recovers it exactly for arcs
-// (perpendicular to the radius at the recovered center, oriented by the sweep's sign) and
-// cubics (including the degenerate c1===from case, where the true tangent comes from c2).
-export function segTangent(from, s, atStart) {
-  const norm = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L, y / L]; };
-  if (s.c1) {
-    if (atStart) {
-      const d = [s.c1[0] - from[0], s.c1[1] - from[1]];
-      return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.c2[0] - from[0], s.c2[1] - from[1]]);
-    }
-    const d = [s.to[0] - s.c2[0], s.to[1] - s.c2[1]];
-    return norm(Math.hypot(d[0], d[1]) > 1e-9 ? d : [s.to[0] - s.c1[0], s.to[1] - s.c1[1]]);
-  }
-  if (s.via) {
-    // tangent ⊥ radius, oriented along the sweep (recover center like arcToCubicSegments)
-    const c = arcCenterAndSweep(from, s.via, s.to);          // {center:[x,y], dA} or null
-    if (!c) return norm([s.to[0] - from[0], s.to[1] - from[1]]);
-    const p = atStart ? from : s.to;
-    const r = [p[0] - c.center[0], p[1] - c.center[1]];
-    const t = c.dA >= 0 ? [-r[1], r[0]] : [r[1], -r[0]];
-    return norm(t);
-  }
-  return norm([s.to[0] - from[0], s.to[1] - from[1]]);
-}
-
-export function jointTangents(contour) {  // per vertex i: tangent arriving at and leaving vertex i
-  const n = contour.segments.length;
-  const pts = [contour.start, ...contour.segments.map((s) => s.to)];
-  return contour.segments.map((_, i) => {
-    const prevSeg = contour.segments[(i - 1 + n) % n];
-    const prevFrom = pts[(i - 1 + n) % n];
-    return {
-      point: pts[i],
-      inTan: segTangent(prevFrom, prevSeg, false),
-      outTan: segTangent(pts[i], contour.segments[i], true),
-    };
-  });
-}
-
-const segType = (s) => (s.c1 ? "cubic" : s.via ? "arc" : "line");
-
-function contourCorners(contour) {
-  const ccw = contourIsCCW(contour);
-  const n = contour.segments.length;
-  const out = [];
-  jointTangents(contour).forEach(({ point, inTan, outTan }, i) => {
-    const cross = inTan[0] * outTan[1] - inTan[1] * outTan[0];
-    const dot = Math.min(1, Math.max(-1, inTan[0] * outTan[0] + inTan[1] * outTan[1]));
-    const turnDeg = (Math.atan2(Math.abs(cross), dot) * 180) / Math.PI;
-    if (turnDeg < SMOOTH_JOINT_DEG) return;
-    const leftTurn = cross > 0;
-    out.push({
-      index: i, point: [point[0], point[1]],
-      interiorAngleDeg: ccw === leftTurn ? 180 - turnDeg : 180 + turnDeg,
-      convex: leftTurn === ccw,
-      segTypes: [segType(contour.segments[(i - 1 + n) % n]), segType(contour.segments[i])],
-    });
-  });
-  return out;
-}
-
-// Two numbers on every corner, and they are NOT interchangeable. `index` is the joint's
-// vertex number within its own contour (what buildCornerOpRing, simplify and the lofts
-// key on); `position` is the corner's place in THIS returned list — the one
-// `{corners: {indices}}` selects by. They diverge as soon as a contour has a smooth
-// joint (a collinear midpoint, a G1 arc-line join), and on region input `index`
-// restarts per ring while `position` runs on through the flattened order.
-const withPositions = (corners) => corners.map((c, position) => ({ ...c, position }));
-
-export function profileCorners(input) {
-  const { kind, regions } = liftProfile(input);
-  if (kind === "points" || kind === "contour") return withPositions(contourCorners(regions[0].outer));
-  const out = [];
-  regions.forEach((rg, regionIndex) => {
-    for (const c of contourCorners(rg.outer)) out.push({ regionIndex, ring: "outer", ...c });
-    rg.holes.forEach((h, hi) => { for (const c of contourCorners(h)) out.push({ regionIndex, ring: { hole: hi }, ...c }); });
-  });
-  return withPositions(out);
-}
-
 // ── Fillet / chamfer ─────────────────────────────────────────────────────────
 // Resolve opts.corners against a flat corner list (contourCorners()'s order, or
 // profileCorners()'s flattened order for region/regions input — {indices} always
@@ -280,14 +174,6 @@ const normalize2 = ([x, y]) => { const L = Math.hypot(x, y) || 1; return [x / L,
 const rot90 = ([x, y]) => [-y, x];
 const addScaled = (p, v, s) => [p[0] + v[0] * s, p[1] + v[1] * s];
 
-export function cubicAt(p0, c1, c2, p1, t) {
-  const u = 1 - t;
-  return [0, 1].map((k) => u * u * u * p0[k] + 3 * u * u * t * c1[k] + 3 * u * t * t * c2[k] + t * t * t * p1[k]);
-}
-function cubicDeriv(p0, c1, c2, p1, t) {
-  const u = 1 - t;
-  return [0, 1].map((k) => 3 * u * u * (c1[k] - p0[k]) + 6 * u * t * (c2[k] - c1[k]) + 3 * t * t * (p1[k] - c2[k]));
-}
 // Exact de Casteljau split of cubic (p0,c1,c2,p1) at t → two exact cubic pieces.
 export function splitCubic(p0, c1, c2, p1, t) {
   const lerp = (a, b) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];

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

@@ -3,6 +3,7 @@
 // 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";
+import { arcCenterAndSweep } from "./arc-math.js";
 
 const ORIENT_SEGS = 8;   // points/segment for the local orientation sampler below
 
@@ -12,27 +13,9 @@ function paperScope() {
   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 };
-}
+// arcCenterAndSweep now lives in arc-math.js (paper-free), re-exported here so every
+// existing importer of it from this module keeps working unchanged.
+export { arcCenterAndSweep } from "./arc-math.js";
 
 // 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.

package/src/framework/oracle/shape-probe.js

@@ -40,8 +40,8 @@
 // out at rings[] → ring → arcs[] → arc → center[] — 4 containers below the summary
 // object itself (5 including it), against the cloud's `DESCRIBE_MAX_DEPTH = 8`, with
 // headroom even wrapped in the paired-probe `{pair: {mine, ref}}` form.
-import { arcCenterAndSweep } from "../geometry/paper-bridge.js";
-import { cubicAt, profileCorners } from "../geometry/contour-ops.js";
+import { arcCenterAndSweep } from "../geometry/arc-math.js";
+import { cubicAt, profileCorners } from "../geometry/contour-corners.js";
 
 export const MAX_ARCS = 64;
 export const MAX_CORNERS = 64;