partforge 0.132.0 → 0.133.0

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

@@ -11,21 +11,42 @@
 // cubic's ENDPOINTS to the true circle and only the interior deviates, so a
 // three-point fit through endpoints recovers the original centre and radius to
 // float precision. The tolerances are therefore an acceptance test on the
-// interiors, not the accuracy of the result — see runFits for why there are two
-// of them and why a radius-relative one alone is not enough.
+// interiors and joints, not the accuracy of the result — see probeRun for why
+// there are two of them and why a radius-relative one alone is not enough, and
+// fitCircle for why a fit through three nearly collinear points is refused. What
+// it accepts lies within min(1e-3·r, 2e-3·chord) of each cubic at every probe: a
+// non-circle closer than that to a circle is read as that circle.
 //
-// Pure leaf: DOM-free, node-free.
-import { arcCenterAndSweep } from "./paper-bridge.js";
-import { cubicAt } from "./contour-ops.js";
+// Pure leaf: DOM-free, node-free and paper-free — the laser checks' resolver hands it to
+// the width searches (sheet/resolve.js), and the oracle and lint may not load paper.
+// Those run it before the first step they price, so its cost matters — cheap on real
+// outlines (4,000 cubics in 10–35 ms; growth is closer to n^1.6 than linear on a smooth
+// traced blob — docs/research/sheet-inspect-timing.md) — and its linear-time search
+// (recoverArcs) returns exactly what an exhaustive search of every run length would,
+// identity-checked over 280,000 synthetic rings.
+import { circumcircle } from "./arc-math.js";
+import { cubicAt } from "./contour-corners.js";
 
 const ARC_TOL = 1e-3;            // relative to the FITTED radius
-const CHORD_TOL = 2e-3;          // relative to each cubic's OWN chord — see runFits
-const PROBE_TS = [0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875];
+const CHORD_TOL = 2e-3;          // relative to each cubic's OWN chord — see probeRun
+// Seven interior points of each cubic and its END — every joint of the run as well as
+// its middles (the run's first point is a fit point, on the circle by construction).
+const PROBE_TS = [0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1];
 const MAX_SWEEP = Math.PI;       // split arcs at 180° so the 3-point form stays unambiguous
+const MAX_SPAN_RATIO = 1e4;      // a fitted radius past this × the fit points' span — see fitCircle
+// Rounding, per unit of the numbers' own scale. A three-point fit in absolute coordinates
+// moves a probe by up to about 40·EPS·M²/span (M the largest coordinate; measured over
+// 190,000 fits), and a probe's computed distance from a circle is good to a few EPS of
+// the radius and coordinates; both are taken at this, with headroom.
+const ROUND = 64 * Number.EPSILON;
 
 const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
 
-// Does every probed interior point of every cubic in `run` lie on the circle?
+// Does every probed interior point of every cubic of the run segs[i..j] lie on the circle?
+// → { miss: { dev, bound, at } } for a probe that does not (its distance, the loosest
+// bound any fit can give it — its chord's — and where it is), else { devs, bounds }: how
+// far each cubic's probes lie from the circle at most, and each one's chord bound. With
+// `all`, every probe is measured and none refused.
 //
 // TWO bounds, and the tighter one wins. `ARC_TOL * r` alone is not a usable
 // acceptance test, because r is the FITTED radius: the flatter a curve is, the
@@ -50,17 +71,37 @@ const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
 // from 0.5 to 1e5, the worst genuine deviation is 1.83e-4 of chord — so 2e-3
 // leaves an 11x margin. The two shallow non-circular cubics that used to be
 // accepted deviate by 3.1e-3 and 6.8e-3 of chord, comfortably outside it.
-function runFits(run, from, center, r) {
+//
+// A probe's distance from the circle is taken without cancellation (offCircle): as
+// `|q − centre| − r` it is the difference of two numbers the size of r, and where r
+// is huge it loses every digit the probe's own offset lives in.
+function probeRun(segs, i, j, from, fit, all = false) {
+  const devs = [], bounds = [];
   let p = from;
-  for (const s of run) {
-    const tol = Math.min(ARC_TOL * r, CHORD_TOL * dist(p, s.to));
+  for (let k = i; k <= j; k++) {
+    const s = segs[k], bound = CHORD_TOL * dist(p, s.to);
+    const tol = Math.min(ARC_TOL * fit.r, bound);
+    let most = 0;
     for (const t of PROBE_TS) {
-      const q = cubicAt(p, s.c1, s.c2, s.to, t);
-      if (Math.abs(dist(q, center) - r) > tol) return false;
+      const at = cubicAt(p, s.c1, s.c2, s.to, t), d = Math.abs(offCircle(fit, at));
+      if (d > tol && !all) return { miss: { dev: d, bound, at } };
+      if (d > most) most = d;
     }
+    devs.push(most); bounds.push(bound);
     p = s.to;
   }
-  return true;
+  return { devs, bounds };
+}
+
+// The signed distance of q from the fitted circle, computed in the frame of the fit's
+// first point `a`: with κ = 1/r and u the unit vector from a toward the centre, the
+// circle is κ|q − a|² − 2(q − a)·u = 0, and that left side is f = (ρ² − r²)/r for q at
+// ρ from the centre. So ρ − r = f / (1 + √(1 + κf)) — no difference of r-sized numbers,
+// and finite (the distance from the chord line) as κ goes to zero.
+function offCircle({ a, kappa, u }, q) {
+  const v = [q[0] - a[0], q[1] - a[1]];
+  const f = kappa * (v[0] * v[0] + v[1] * v[1]) - 2 * (v[0] * u[0] + v[1] * u[1]);
+  return f / (1 + Math.sqrt(Math.max(0, 1 + kappa * f)));
 }
 
 // Fit through the run's first, middle and last ENDPOINT — all exact on the
@@ -70,16 +111,98 @@ function runFits(run, from, center, r) {
 // cubic's own midpoint instead. That point is NOT exact on the circle (it's
 // off by paper's kappa error), so the resulting centre/radius are only
 // approximate for a still-unextended single-cubic run — but they're accurate
-// enough to pass runFits's tolerance, and any later join with a second
+// enough to pass probeRun's tolerance, and any later join with a second
 // segment re-fits through three real endpoints and recovers the exact circle.
-function fitCircle(run, from) {
-  const pts = [from, ...run.map((s) => s.to)];
-  const mid = pts.length >= 3
-    ? pts[Math.floor(pts.length / 2)]
-    : cubicAt(from, run[0].c1, run[0].c2, run[0].to, 0.5);
-  const c = arcCenterAndSweep(pts[0], mid, pts.at(-1));
+//
+// A fit through three points that are collinear to float noise is refused: its
+// radius is astronomical (a sine-wave edge fitted across whole periods came out near
+// 1e17), and an arc that size is a straight chord drawn through the curve. It is
+// refused past MAX_SPAN_RATIO × the three points' span, where a real arc's sagitta is
+// under span/80,000 — a line, to every tolerance here — and a centre and `via` built
+// that far out would lose their digits (arcsBetween) besides.
+//
+// The run is read in place, by index — never copied: recoverArcs tries a fit for many
+// lengths of a run. `noise` is how far rounding can move a probe off the fitted circle
+// (ROUND), `scale` how large the numbers its probes are measured with are.
+function fitCircle(segs, i, j, from) {
+  const n = j - i + 1;                  // its endpoints are from, segs[i].to … segs[j].to
+  const mid = n >= 2
+    ? segs[i + Math.floor((n + 1) / 2) - 1].to
+    : cubicAt(from, segs[i].c1, segs[i].c2, segs[i].to, 0.5);
+  const a = from, b = segs[j].to;
+  const c = circumcircle(a, mid, b);
   if (!c || !Number.isFinite(c.r) || c.r <= 0) return null;
-  return c;
+  const span = Math.max(dist(a, mid), dist(mid, b), dist(a, b));
+  if (!(c.r <= MAX_SPAN_RATIO * span)) return null;
+  const u = [(c.center[0] - a[0]) / c.r, (c.center[1] - a[1]) / c.r];
+  const M = Math.max(Math.abs(a[0]), Math.abs(a[1]), Math.abs(mid[0]), Math.abs(mid[1]), Math.abs(b[0]), Math.abs(b[1]));
+  return { center: c.center, r: c.r, a, kappa: 1 / c.r, u, noise: (ROUND * M * M) / span, scale: 3 * c.r + M };
+}
+
+// Does the run segs[i..j] fit the circle c? `known` is the last fit a run from i was
+// probed whole against: its fit, the last cubic it covers (upTo), and how far each covered
+// cubic's probes lay from its fit (devs, with their chord bounds). A probe lies at most
+// |Δcentre| + |Δr| farther from c than from that fit, so a covered cubic whose probes the
+// shift cannot carry past their bound under c is not probed again (the shift is taken with
+// both fits' rounding on top); the rest are. Where more than a quarter of them would be,
+// the run is probed whole and becomes the new `known`.
+// → { miss } as probeRun's, or { known } for the run that fitted.
+function fitsRun(segs, i, j, runFrom, c, known) {
+  const start = (k) => (k === i ? runFrom : segs[k - 1].to);
+  if (known) {
+    const tolR = ARC_TOL * c.r, covered = known.upTo - i + 1;
+    const shift = dist(c.center, known.fit.center) + Math.abs(c.r - known.fit.r) + ROUND * Math.max(c.scale, known.fit.scale);
+    const again = [];
+    if (!(known.dev + shift <= tolR && shift <= known.slack)) {
+      for (let k = 0; k < covered && 4 * again.length <= covered; k++) {
+        if (!(known.devs[k] + shift <= Math.min(tolR, known.bounds[k]))) again.push(i + k);
+      }
+    }
+    if (4 * again.length <= covered) {
+      for (const k of again) { const m = probeRun(segs, k, k, start(k), c); if (m.miss) return m; }
+      const m = probeRun(segs, known.upTo + 1, j, start(known.upTo + 1), c);
+      if (m.miss) return m;
+      const x = probeRun(segs, known.upTo + 1, j, start(known.upTo + 1), known.fit, true);
+      return { known: cover(known, x, j) };
+    }
+  }
+  const m = probeRun(segs, i, j, runFrom, c);
+  return m.miss ? m : { known: cover({ fit: c, devs: [], bounds: [], dev: 0, slack: Infinity }, m, j) };
+}
+// `known` with the cubics measured in `x` (devs against known's own fit) covered, to `upTo`.
+function cover(known, x, upTo) {
+  x.devs.forEach((d, k) => {
+    known.devs.push(d); known.bounds.push(x.bounds[k]);
+    known.dev = Math.max(known.dev, d); known.slack = Math.min(known.slack, x.bounds[k] - d);
+  });
+  known.upTo = upTo;
+  return known;
+}
+
+// Whether no longer run from the same start can fit where the fit `c` of the run segs[i..j]
+// missed. Every longer fit passes through the run's start as c does, and must come within
+// its bound of c's other two fit points — the ends of the cubic at the run's middle and of
+// its last cubic — and of the missed probe. Two circles through one point differ, to first
+// order, by α + β·cos θ + γ·sin θ along the circle, so where they differ by e1 and e2 at the
+// other two fit points they differ by at most |L1|·e1 + |L2|·e2 at the probe (L the
+// trigonometric Lagrange basis on the three fit points' angles about c's centre). Those two
+// fit points sit exactly on c only by construction: for an ill-conditioned fit — two of the
+// three fit points close enough together that rounding swamps their geometry — c's own
+// circle can miss them by more than `noise` allows, and a longer circle is free to differ
+// from c by that same slop before the Lagrange bound above even starts to apply. e1 and e2
+// are that residual — c's own deviation at its middle and last fit points — added into reach
+// so a longer fit isn't cut off by headroom the rounding already spent. A miss farther than
+// the result from any circle a longer run could fit, with a quarter's headroom and the fits'
+// rounding on top, is final.
+function final(segs, i, j, runFrom, c, miss) {
+  const n = j - i + 1, m = i + Math.floor((n + 1) / 2) - 1;       // the cubic ending at the middle fit point
+  const bound = (k) => CHORD_TOL * dist(k === i ? runFrom : segs[k - 1].to, segs[k].to);
+  const angle = (p) => Math.atan2(p[1] - c.center[1], p[0] - c.center[0]);
+  const t0 = angle(runFrom), t1 = angle(segs[m].to), t2 = angle(segs[j].to), tq = angle(miss.at);
+  const basis = (x, y, z) => Math.abs((Math.sin((tq - x) / 2) * Math.sin((tq - y) / 2)) / (Math.sin((z - x) / 2) * Math.sin((z - y) / 2)));
+  const e1 = Math.abs(offCircle(c, segs[m].to)), e2 = Math.abs(offCircle(c, segs[j].to));
+  const reach = basis(t0, t2, t1) * (bound(m) + c.noise + e1) + basis(t0, t1, t2) * (bound(j) + c.noise + e2);
+  return miss.dev > miss.bound + 1.25 * reach + 2 * c.noise;
 }
 
 // One arc from `from` to `to` about `center`, split so no piece exceeds 180°.
@@ -105,10 +228,10 @@ function arcsBetween(from, to, center, r, sweepSign) {
   return out;
 }
 
-// The direction the run actually travels, from the first cubic's own geometry.
-function sweepSignOf(run, from, center) {
+// The direction the run actually travels, from its first cubic's own geometry.
+function sweepSignOf(first, from, center) {
   const a = [from[0] - center[0], from[1] - center[1]];
-  const q = cubicAt(from, run[0].c1, run[0].c2, run[0].to, 0.5);
+  const q = cubicAt(from, first.c1, first.c2, first.to, 0.5);
   const b = [q[0] - center[0], q[1] - center[1]];
   return a[0] * b[1] - a[1] * b[0] >= 0 ? 1 : -1;
 }
@@ -122,22 +245,32 @@ export function recoverArcs(contour) {
   while (i < segs.length) {
     if (!segs[i].c1) { out.push(segs[i]); from = segs[i].to; i++; continue; }
 
-    // Greedy: extend the cubic run while it still fits one circle.
+    // Greedy: the longest run from i that fits one circle. A shorter run failing does not
+    // rule out a longer one — its fit points are closer together, so it is refused as too
+    // flat for its span, or rounding swamps it, or a small cubic near no fit point misses
+    // its small bound where a longer fit lands on it — and a search that stopped at the first
+    // failure changed 117 of 6,000 genuine arcs and near-circles split into up to 8 pieces.
+    // But trying every length made the search cubic in a run of cubics that are not a circle
+    // (1,600 of them: 3.4 s), and re-probing every length of a run that fits, quadratic in a
+    // circle of many cubics (4,000: 3.6 s). So the search ends at a miss no longer run can
+    // make up (final), and a longer fit re-probes only what it could change (fitsRun).
     const runFrom = from;
-    let best = null, bestEnd = i;
-    let j = i;
-    while (j < segs.length && segs[j].c1) {
-      const run = segs.slice(i, j + 1);
-      const c = fitCircle(run, runFrom);
-      if (c && runFits(run, runFrom, c.center, c.r)) { best = c; bestEnd = j; }
-      j++;
+    let best = null, bestEnd = i, known = null;
+    for (let j = i; j < segs.length && segs[j].c1; j++) {
+      const c = fitCircle(segs, i, j, runFrom);
+      if (!c) continue;
+      const r = fitsRun(segs, i, j, runFrom, c, known);
+      if (r.miss) {
+        if (j > i && final(segs, i, j, runFrom, c, r.miss)) break;
+        continue;
+      }
+      best = c; bestEnd = j; known = r.known;
     }
 
     if (!best) { out.push(segs[i]); from = segs[i].to; i++; continue; }
 
-    const run = segs.slice(i, bestEnd + 1);
-    const end = run.at(-1).to;
-    out.push(...arcsBetween(runFrom, end, best.center, best.r, sweepSignOf(run, runFrom, best.center)));
+    const end = segs[bestEnd].to;
+    out.push(...arcsBetween(runFrom, end, best.center, best.r, sweepSignOf(segs[i], runFrom, best.center)));
     from = end;
     i = bestEnd + 1;
   }

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

@@ -9,13 +9,9 @@
 // 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 circle = circumcircle(p0, via, to);
+  if (!circle) return null;
+  const { center: [ux, uy], r } = circle, [ax, ay] = p0, [bx, by] = via, [cx, cy] = to;
   const a0 = Math.atan2(ay - uy, ax - ux);
   const av = Math.atan2(by - uy, bx - ux);
   const a1 = Math.atan2(cy - uy, cx - ux);
@@ -25,3 +21,15 @@ export function arcCenterAndSweep(p0, via, to) {
   const dA = vCCW <= dCCW ? dCCW : dCCW - twoPi;
   return { center: [ux, uy], r, dA };
 }
+
+// The circle through three points as { center, r } — arcCenterAndSweep's own, without the
+// sweep (arc-fit.js tries one for every length of a run). Null for a collinear triple.
+export function circumcircle(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;
+  return { center: [ux, uy], r: Math.hypot(ax - ux, ay - uy) };
+}

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

@@ -104,12 +104,82 @@ function lineIntersect(P, u, Q, v) {
   return add(P, scl(u, cross(w, v) / d));
 }
 
+// A sharp join's miter apex, or null where the miter would pass MITER_LIMIT·|delta| and the
+// join falls back to the bevel — a turn past 120°, i.e. a spike of material under 60°. One
+// spelling for the join itself and for the source-hole disk gate (sharpHoleTakesMiters),
+// which is only sound while no join on the hole bevels.
+function sharpMiter(corner, aEnd, bStart, inTan, outTan, delta, limit = MITER_LIMIT) {
+  const X = lineIntersect(aEnd, inTan, bStart, outTan);
+  return X && dist(X, corner) <= limit * Math.abs(delta) ? X : null;
+}
+
+// A SHARP join where an ARC meets the corner: the two pieces are extended until they meet,
+// the arc along its own circle and the other piece (a line, or a cubic by its end tangent)
+// along itself — OCCT's intersection join. A line–line corner is joinSegs' miter, which is
+// the same thing. Extended along its end TANGENT instead (the plain miter), an arc leaves its
+// circle at once, and the join cuts the corner short wherever the arc curves away from the
+// gap: shrinking a shape and growing it back then lost a sliver beside every such corner (a
+// ring sector's inner corners, a keyhole's, a thumb notch's), which the laser checks read as
+// narrow material. Extended along the circle, a shrink-and-regrow returns the corner exactly.
+// Returns the join's segments, or null where no meeting point lies ahead of both pieces within
+// MITER_LIMIT·|delta| of the corner (the caller then takes the miter, or the bevel).
+const EXTEND_MAX_SWEEP = Math.PI / 2;          // how far along its circle an arc may extend
+function arcCarrier(from, seg) {
+  if (!seg.via) return null;
+  const c = arcCenterAndSweep(from, seg.via, seg.to);
+  return c && c.r > JOIN_EPS ? { c: c.center, r: c.r, s: c.dA >= 0 ? 1 : -1 } : null;
+}
+const angleOf = (c, p) => Math.atan2(p[1] - c[1], p[0] - c[0]);
+// The angle swept from p to q around a carrier, in its own direction, in [0, 2π).
+function sweepAlong({ c, s }, p, q) {
+  const TAU = 2 * Math.PI;
+  const a = (s * (angleOf(c, q) - angleOf(c, p))) % TAU;
+  return a < 0 ? a + TAU : a;
+}
+const pointAlong = ({ c, r, s }, p, ang) => {
+  const t = angleOf(c, p) + s * ang;
+  return [c[0] + r * Math.cos(t), c[1] + r * Math.sin(t)];
+};
+function lineCircle(P, u, { c, r }) {
+  const w = sub(P, c), b = dot(w, u), disc = b * b - (dot(w, w) - r * r);
+  if (disc < 0) return [];
+  const q = Math.sqrt(disc);
+  return [add(P, scl(u, -b - q)), add(P, scl(u, -b + q))];
+}
+function circleCircle(A, B) {
+  const d = dist(A.c, B.c);
+  if (d < 1e-12 || d > A.r + B.r || d < Math.abs(A.r - B.r)) return [];
+  const a = (A.r * A.r - B.r * B.r + d * d) / (2 * d), hh = Math.sqrt(Math.max(0, A.r * A.r - a * a));
+  const e = scl(sub(B.c, A.c), 1 / d), m = add(A.c, scl(e, a)), nrm = [-e[1], e[0]];
+  return [add(m, scl(nrm, hh)), add(m, scl(nrm, -hh))];
+}
+function extendedJoin(corner, aFrom, aSeg, bStart, bSeg, inTan, outTan, delta) {
+  const A = arcCarrier(aFrom, aSeg), B = arcCarrier(bStart, bSeg);
+  if (!A && !B) return null;
+  const aEnd = aSeg.to;
+  const ahead = (X) => (A ? dist(X, aEnd) <= JOIN_EPS || sweepAlong(A, aEnd, X) <= EXTEND_MAX_SWEEP : dot(sub(X, aEnd), inTan) >= -JOIN_EPS);
+  const behind = (X) => (B ? dist(X, bStart) <= JOIN_EPS || sweepAlong(B, X, bStart) <= EXTEND_MAX_SWEEP : dot(sub(bStart, X), outTan) >= -JOIN_EPS);
+  let X = null, best = MITER_LIMIT * Math.abs(delta);
+  for (const P of A && B ? circleCircle(A, B) : A ? lineCircle(bStart, outTan, A) : lineCircle(aEnd, inTan, B)) {
+    const d = dist(P, corner);
+    if (d <= best && ahead(P) && behind(P)) { X = P; best = d; }
+  }
+  if (!X) return null;
+  // An extension too short to bend is a line; its end is snapped onto the next piece.
+  const along = (C, p, q) => { const ang = sweepAlong(C, p, q); return ang > 1e-9 ? { via: pointAlong(C, p, ang / 2), to: q } : { to: q }; };
+  const out = [];
+  if (dist(X, aEnd) > JOIN_EPS) out.push(A ? along(A, aEnd, X) : { to: X });
+  if (dist(X, bStart) > JOIN_EPS) out.push(B ? along(B, X, bStart) : { to: bStart });
+  else if (out.length) out[out.length - 1] = A ? along(A, aEnd, bStart) : { to: bStart };
+  return out.length ? out : [{ to: bStart }];
+}
+
 // Segments bridging aEnd → bStart around `corner` on the gap side.
 function joinSegs(corner, aEnd, bStart, inTan, outTan, delta, corners) {
   if (corners === "chamfer") return [{ to: bStart }];
   if (corners === "sharp") {
-    const X = lineIntersect(aEnd, inTan, bStart, outTan);
-    if (X && dist(X, corner) <= MITER_LIMIT * Math.abs(delta)) return [{ to: X }, { to: bStart }];
+    const X = sharpMiter(corner, aEnd, bStart, inTan, outTan, delta);
+    if (X) return [{ to: X }, { to: bStart }];
     return [{ to: bStart }];                               // miter-limit fallback = bevel
   }
   // round: exact arc about the corner, via on the displacement bisector
@@ -191,7 +261,15 @@ export function _offsetContour(contour, delta, corners) {
     // through to the overlap branch, flat-capping a requested round end; treat it as gap
     // side so the cap is honored (an inward spike's join makes an inverted loop the
     // winding rule cancels, so the choice is safe for either delta sign).
-    if (turn * delta > 0 || turn === 0) { joins[i] = joinSegs(point, aEnd, bStart, inTan, outTan, delta, corners); continue; }
+    if (turn * delta > 0 || turn === 0) {
+      // Sharp, where an arc meets the corner: extend it along its circle (extendedJoin). Not
+      // for a piece the offset inverted or collapsed (dirty): cleanup removes those.
+      const ext = corners === "sharp" && !prev.dirty && !next.dirty
+        ? extendedJoin(point, prev.segments.length > 1 ? prev.segments.at(-2).to : prev.start, prev.segments.at(-1), bStart, next.segments[0], inTan, outTan, delta)
+        : null;
+      joins[i] = ext ?? joinSegs(point, aEnd, bStart, inTan, outTan, delta, corners);
+      continue;
+    }
     // Overlap side: the two offset pieces run into each other instead of leaving a gap.
     // When both neighbors are plain lines and the two offset LINES cross WITHIN both
     // segments' own extents, that crossing is the true corner of the offset outline: trim
@@ -517,10 +595,59 @@ export function validateRawOffset(regions) {
 // before constructing the raw offset avoids the inverted pockets that fully-eroded curved
 // counters can otherwise leave behind. This deliberately examines the SOURCE contour, not
 // the self-tangled raw output — see the removed-prune history above.
+//
+// A SHARP offset erodes a hole at least as deeply — WHILE EVERY JOIN ON IT TAKES THE MITER.
+// At the hole's convex corners the inset lines meet exactly as the disk's would, and at
+// its reflex corners (spikes of material pointing into it) a miter reaches past the arc,
+// so a hole with no room for the disk is gone under sharp corners too. It gets the same
+// question. Without it the inverted ring survived: past twice a hole's half-width a
+// square came back as a small diamond hole and a circle as a mirrored one, so a sharp
+// closing (grow, shrink back) GREW a small hole — the laser gap check never flagged a
+// hole below its floor — and an inverted cubic counter subdivided to MAX_DEPTH and cost
+// the winding resolver seconds per hole.
+// The argument fails at the miter limit. A spike of material under 60° would miter past
+// MITER_LIMIT·delta, so joinSegs bevels it, and the bevel chord adds LESS than the arc:
+// the hole keeps a real pocket beyond the chord that the disk would have filled — a
+// 12-ray star hole (rays 5, spikes to 1.2) in a plate keeps 0.9–1.9 mm² at +1.3…+2, the
+// Minkowski oracle agrees (test/offset-oracle-manifold.test.js), and the gate must not
+// drop it. So a sharp hole is asked the disk question only when no join on it bevels
+// (sharpHoleTakesMiters); one that does takes the ordinary path, as before the gate ran
+// for sharp. Chamfer is left alone for the same reason everywhere: its bevel removes LESS
+// than the arc at every reflex corner, so an empty disk test does not prove an empty inset.
 const SOURCE_DISK_TOL = 5 * OFFSET_TOL;
 const SOURCE_DISK_FLAT_TOL = OFFSET_TOL / 2;
 const SOURCE_DISK_POINT_CAP = 16384;
 
+// Whether a sharp offset of `contour` by `delta` joins every gap-side corner with its miter
+// — the condition under which the disk gate above is sound for sharp. Mirrors
+// _offsetContour's own join decision (zero-length segments dropped, smooth joints skipped,
+// the gap side by the sign of the turn) and joinSegs' through sharpMiter, from the source
+// geometry alone: an offset piece starts and ends exactly one delta along its endpoint
+// normal. The limit is held a hair tighter so a spike sitting exactly on it reads as a
+// bevel and keeps the hole on the ordinary path — never the other way round.
+// An arc's corner may take extendedJoin instead of the miter; that join never bevels where
+// the miter would not (it falls back to the miter first), and its curves stay at least
+// delta from the corner, so it too reaches past the arc a disk would leave — the argument
+// above holds for it unchanged.
+const MITER_GATE_LIMIT = MITER_LIMIT * (1 - 1e-9);
+function sharpHoleTakesMiters(contour, delta) {
+  const froms = [];
+  { let p = contour.start; for (const s of contour.segments) { froms.push(p); p = s.to; } }
+  const keep = contour.segments.map((s, i) => s.c1 || s.via || dist(froms[i], s.to) > 1e-9);
+  const segs = contour.segments.filter((_, i) => keep[i]);
+  if (!segs.length) return true;
+  const start = froms.find((_, i) => keep[i]);
+  for (const { point, inTan, outTan } of jointTangents({ start, segments: segs })) {
+    const turn = cross(inTan, outTan);
+    const turnDeg = (Math.atan2(Math.abs(turn), Math.max(-1, Math.min(1, dot(inTan, outTan)))) * 180) / Math.PI;
+    if (turnDeg < SMOOTH_JOINT_DEG || !(turn * delta > 0 || turn === 0)) continue;   // smooth, or no join
+    const aEnd = add(point, scl(rightOf(inTan), delta)), bStart = add(point, scl(rightOf(outTan), delta));
+    if (dist(aEnd, bStart) <= JOIN_EPS) continue;
+    if (!sharpMiter(point, aEnd, bStart, inTan, outTan, delta, MITER_GATE_LIMIT)) return false;
+  }
+  return true;
+}
+
 function pointSegmentDistance(p, a, b) {
   const ab = sub(b, a);
   const d2 = dot(ab, ab);
@@ -661,8 +788,8 @@ function rawOffset(regions, delta, corners) {
     if (!o.contour) continue;
     const hs = rg.holes.map((h) => {
       const hole = closeContourGap(h);
-      if (delta > 0 && corners === "round" && !_sourceHoleContainsDisk(hole, delta))
-        return { contour: null, dirty: false };
+      const diskGate = delta > 0 && (corners === "round" || (corners === "sharp" && sharpHoleTakesMiters(hole, delta)));
+      if (diskGate && !_sourceHoleContainsDisk(hole, delta)) return { contour: null, dirty: false };
       return _offsetContour(hole, delta, corners);
     });
     // Only a SURVIVING hole's dirtiness can dirty the result. A hole that collapsed

package/src/framework/geometry/polygon.js

@@ -620,3 +620,10 @@ export { translateProfile, rotateProfile, scaleProfile, mirrorProfile,
   profileLength, profilePointAt, profileTangentAt, profileNearestPoint,
   profileBounds, profileArea, profileContains,
   simplifyProfile, validateProfile } from "./contour-ops.js";
+
+// Sheet parts (laser-cut flat stock): the sheetPart() wrapper, the joinery helpers and
+// the drawing ↔ world converters. Plain JS over the contour IR — not kernel ops, so
+// they add nothing to the kernel contract's op lists.
+export { sheetPart } from "../sheet/part.js";
+export { fingers, tabs, tSlots, sheetPanel, matchingSlots, fingerBox, printedTab, sheetHole, JOINERY_SCREWS } from "../sheet/joinery.js";
+export { sheetToWorld, worldToSheet } from "../sheet/pose.js";

package/src/framework/lint/index.js

@@ -21,8 +21,9 @@ import { IMAGE_RULES } from "./rules-images.js";
 import { SOURCE_RULES } from "./rules-source.js";
 import { VECTOR_RULES } from "./rules-vector.js";
 import { MATERIAL_RULES } from "./rules-materials.js";
+import { SHEET_RULES } from "./rules-sheet.js";
 
-export const RULES = [...SHAPE_RULES, ...SCHEMA_RULES, ...BUILD_RULES, ...VERIFY_RULES, ...ANIMATION_RULES, ...PLACE_RULES, ...IMPORT_RULES, ...FONT_RULES, ...IMAGE_RULES, ...SOURCE_RULES, ...VECTOR_RULES, ...MATERIAL_RULES];
+export const RULES = [...SHAPE_RULES, ...SCHEMA_RULES, ...BUILD_RULES, ...VERIFY_RULES, ...ANIMATION_RULES, ...PLACE_RULES, ...IMPORT_RULES, ...FONT_RULES, ...IMAGE_RULES, ...SOURCE_RULES, ...VECTOR_RULES, ...MATERIAL_RULES, ...SHEET_RULES];
 
 // A usable sources input, or null. Deliberately forgiving: lintPart's callers
 // include hosted paths handing over user/LLM-authored trees, so a malformed

package/src/framework/lint/rules-schema.js

@@ -27,7 +27,8 @@ const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArr
 // It is read only by controlBoundKeys({ excludeHidden }); every other rule
 // ignores it, so their populations are unchanged. `when` is deliberately not
 // hiddenness — a `when`-conditioned node can still appear.
-function collectDescriptors(part) {
+// Exported for rules-sheet.js's sheet-kerf-control, which reads every control's key and label.
+export function collectDescriptors(part) {
   const out = [];
   sections(part).forEach((sec, si) => {
     const secHidden = sec?.hidden === true;

package/src/framework/lint/rules-shape.js

@@ -3,6 +3,11 @@
 // defaults and build but not `views`, and had already drifted from the eval runner's
 // separate views check. One source of truth ends that split.
 import { err, warn } from "./finding.js";
+import { SHEET_DOC_ID } from "../sheet/constants.js";
+
+// A sub-part that carries a `sheet` declaration but no build was meant to be a sheet
+// part: point it at sheetPart(), which supplies build.
+const SHEET_NO_BUILD_HINT = "Every entry in `parts` needs a `build(k, p, d)` function that returns a solid. For a laser-cut flat part, wrap the whole sub-part in `sheetPart({ … })` from partforge/geometry — it supplies build and place.";
 
 const isPlainObject = (x) => x !== null && typeof x === "object" && !Array.isArray(x);
 const partEntries = (part) => (isPlainObject(part?.parts) ? Object.entries(part.parts) : []);
@@ -35,9 +40,11 @@ export const SHAPE_RULES = [
       }
       return entries
         .filter(([, sp]) => typeof sp?.build !== "function")
-        .map(([name]) => err("no-buildable-parts", `sub-part "${name}" has no \`build\` function`,
-          "Every entry in `parts` needs a `build(k, p, d)` function that returns a solid.",
-          `parts.${name}.build`));
+        .map(([name, sp]) => (sp?.sheet !== undefined
+          ? err("no-buildable-parts", `sub-part "${name}" has no \`build\` function`, SHEET_NO_BUILD_HINT, `parts.${name}.build`, SHEET_DOC_ID)
+          : err("no-buildable-parts", `sub-part "${name}" has no \`build\` function`,
+            "Every entry in `parts` needs a `build(k, p, d)` function that returns a solid.",
+            `parts.${name}.build`)));
     },
   },
   {