partforge 0.67.4 → 0.69.0

package/src/framework/annotate/ink.js

@@ -0,0 +1,124 @@
+// Pure stroke model for annotation mode: normalized-coordinate polylines with
+// point thinning while drawing, undo/clear, closed-stroke detection and anchor
+// selection. No DOM, no three — unit-testable directly (the feature-dims.js
+// stance). Points are [nx, ny] normalized 0..1 per viewport axis; distances
+// are measured in viewport-DIAGONAL units so thresholds mean the same thing
+// horizontally and vertically regardless of aspect.
+
+// Stroke width as a fraction of the viewport's short edge (spec: payload
+// carries this unit so any re-render can reproduce line weight).
+export const DEFAULT_STROKE_WIDTH = 0.004;
+// Spec: endpoints within 5% of the viewport diagonal = closed stroke.
+const CLOSED_THRESHOLD = 0.05;
+// pointermove fires per-pixel; keep only points this far (in diagonal units)
+// from the previous kept point. ~2px at 1080p.
+const MIN_POINT_DISTANCE = 0.0015;
+
+export function diagDistance(a, b, aspect = 1) {
+  const dx = (a[0] - b[0]) * aspect;
+  const dy = a[1] - b[1];
+  return Math.hypot(dx, dy) / Math.hypot(aspect, 1);
+}
+
+export function createInkStore({ minDistance = MIN_POINT_DISTANCE } = {}) {
+  const strokes = [];
+  let active = null;
+  const listeners = new Set();
+  const notify = () => { for (const cb of [...listeners]) cb(); };
+  return {
+    begin(nx, ny, { width = DEFAULT_STROKE_WIDTH, aspect = 1 } = {}) {
+      active = { points: [[nx, ny]], width, aspect };
+      strokes.push(active);
+      notify();
+    },
+    extend(nx, ny) {
+      if (!active) return;
+      const last = active.points[active.points.length - 1];
+      if (diagDistance([nx, ny], last, active.aspect) < minDistance) return;
+      active.points.push([nx, ny]);
+      notify();
+    },
+    end() {
+      if (!active) return;
+      active = null; // one-point strokes stay: a click leaves a visible dot
+      notify();
+    },
+    strokes: () => strokes.map((s) => ({ points: s.points.map((p) => [...p]), width: s.width })),
+    isEmpty: () => strokes.length === 0,
+    strokeCount: () => strokes.length,
+    undo() {
+      if (!strokes.length) return;
+      strokes.pop();
+      active = null;
+      notify();
+    },
+    clear() {
+      if (!strokes.length && !active) return;
+      strokes.length = 0;
+      active = null;
+      notify();
+    },
+    onChange(cb) { listeners.add(cb); return () => listeners.delete(cb); },
+  };
+}
+
+export function pointAt(points, t, aspect = 1) {
+  if (points.length === 1) return [...points[0]];
+  const lengths = [0];
+  for (let i = 1; i < points.length; i++) {
+    lengths.push(lengths[i - 1] + diagDistance(points[i], points[i - 1], aspect));
+  }
+  const total = lengths[lengths.length - 1];
+  if (total === 0) return [...points[0]];
+  const target = t * total;
+  let i = 1;
+  while (i < lengths.length - 1 && lengths[i] < target) i++;
+  const span = lengths[i] - lengths[i - 1];
+  const f = span === 0 ? 0 : (target - lengths[i - 1]) / span;
+  const [ax, ay] = points[i - 1];
+  const [bx, by] = points[i];
+  return [ax + (bx - ax) * f, ay + (by - ay) * f];
+}
+
+export function isClosedStroke(points, aspect = 1) {
+  if (points.length < 3) return false;
+  return diagDistance(points[0], points[points.length - 1], aspect) <= CLOSED_THRESHOLD;
+}
+
+// Area-weighted polygon centroid (shoelace); for a degenerate (near-zero-area)
+// point set, fall back to the plain point average.
+export function strokeCentroid(points) {
+  let area2 = 0, cx = 0, cy = 0;
+  for (let i = 0; i < points.length; i++) {
+    const [x0, y0] = points[i];
+    const [x1, y1] = points[(i + 1) % points.length];
+    const cross = x0 * y1 - x1 * y0;
+    area2 += cross;
+    cx += (x0 + x1) * cross;
+    cy += (y0 + y1) * cross;
+  }
+  if (Math.abs(area2) < 1e-9) {
+    let sx = 0, sy = 0;
+    for (const [x, y] of points) { sx += x; sy += y; }
+    return [sx / points.length, sy / points.length];
+  }
+  return [cx / (3 * area2), cy / (3 * area2)];
+}
+
+// Anchor sample points for one stroke: start / arc-length-midpoint / end, plus
+// the enclosed-region centroid when the stroke closes on itself ("what did
+// they circle"). A one-point dot gets a single anchor. The orchestrator turns
+// each spec's normalized `screen` point into a raycast.
+export function anchorSpecs(points, aspect = 1) {
+  if (points.length === 0) return [];
+  if (points.length === 1) return [{ t: 0, screen: [...points[0]] }];
+  const specs = [
+    { t: 0, screen: [...points[0]] },
+    { t: 0.5, screen: pointAt(points, 0.5, aspect) },
+    { t: 1, screen: [...points[points.length - 1]] },
+  ];
+  if (isClosedStroke(points, aspect)) {
+    specs.push({ kind: "centroid", screen: strokeCentroid(points) });
+  }
+  return specs;
+}

package/src/framework/app.css

@@ -323,6 +323,20 @@ button.action:focus-visible, .adv-toggle:focus-visible, .sec-title:focus-visible
 #viewbar .pf-measure-actions { display: flex; gap: 4px; }
 #viewbar .pf-measure-actions[hidden] { display: none; }
 #viewbar .pf-measure-actions button { width: auto; min-width: 56px; padding: 0 8px; }
+#viewbar .pf-annotate-actions { display: flex; gap: 4px; }
+#viewbar .pf-annotate-actions[hidden] { display: none; }
+#viewbar .pf-annotate-actions button { width: auto; min-width: 56px; padding: 0 8px; }
+/* Annotate's actions row has three buttons (Undo/Clear/Send) against
+   cutaway's/measure's two, so it is the first to overflow the stage's left
+   edge as the viewport narrows — the full-size pill (5 icon buttons + this
+   row, ~374px) already exceeds a 375-390px phone's usable width (viewport
+   minus the stage's 12px margins on both sides) before the shared 360px
+   rule below ever engages. Shrink only this row here; the icon buttons and
+   the other two action rows still have room down to 360px. */
+@media (max-width: 430px) {
+  #viewbar .pf-annotate-actions { gap: 3px; }
+  #viewbar .pf-annotate-actions button { min-width: 40px; padding: 0 5px; font-size: 11px; }
+}
 #viewbar button:disabled { opacity: .38; cursor: not-allowed; }
 #viewbar button:disabled:hover { color: var(--pf-muted-2); background: transparent; }
 #viewbar button:hover { color: var(--pf-text); background: var(--pf-surface-2); }
@@ -337,8 +351,12 @@ button.action:focus-visible, .adv-toggle:focus-visible, .sec-title:focus-visible
 @media (max-width: 360px) {
   #viewbar { gap: 3px; }
   #viewbar button { width: 30px; height: 30px; font-size: 13px; }
-  #viewbar .pf-cutaway-actions, #viewbar .pf-measure-actions { gap: 3px; }
-  #viewbar .pf-cutaway-actions button, #viewbar .pf-measure-actions button { min-width: 44px; padding: 0 6px; }
+  #viewbar .pf-cutaway-actions, #viewbar .pf-measure-actions, #viewbar .pf-annotate-actions { gap: 3px; }
+  #viewbar .pf-cutaway-actions button, #viewbar .pf-measure-actions button, #viewbar .pf-annotate-actions button { min-width: 44px; padding: 0 6px; }
+  /* Annotate's three-button row (Undo/Clear/Send) is wider than cutaway's or
+     measure's two-button rows at the shared size above, so it still clips the
+     pill's left edge at 320px — shrink it further than the shared rule. */
+  #viewbar .pf-annotate-actions button { min-width: 38px; padding: 0 4px; font-size: 10px; }
 }
 
 /* ---- measurement mode -----------------------------------------------------

package/src/framework/chrome.css

@@ -356,3 +356,21 @@
 @media (prefers-reduced-motion: reduce) {
   .pf-rail, .pf-rail-seam > span { transition: none; }
 }
+
+/* ---- annotation ink layer: a transparent 2D canvas over the viewer --------
+   Shown only while annotation mode is on. It deliberately owns pointer events
+   while visible — that is what freezes orbit/pan/zoom during drawing. Below
+   the viewbar (z 15) so Undo/Clear/Send stay clickable. */
+.pf-ink-canvas {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  z-index: 10;
+  /* Pencil cursor (the viewbar toggle's lucide pencil), hotspot at the tip.
+     White halo under a dark stroke keeps it readable over both the model and
+     the backdrop; crosshair is the no-custom-cursor fallback. */
+  cursor: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24' fill='none' stroke-linecap='round' stroke-linejoin='round'%3E%3Cg stroke='white' stroke-width='4.5'%3E%3Cpath d='M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z'/%3E%3Cpath d='m15 5 4 4'/%3E%3C/g%3E%3Cg stroke='%231d232b' stroke-width='2'%3E%3Cpath d='M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z'/%3E%3Cpath d='m15 5 4 4'/%3E%3C/g%3E%3C/svg%3E") 2 22, crosshair;
+  touch-action: none;
+}
+.pf-ink-canvas[hidden] { display: none; }

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

@@ -713,12 +713,14 @@ const flattenRing = (contour, segs) => {
 //
 // RATES, and where they come from. `node scripts/offset-rates.mjs` sweeps the committed
 // corpus (600 seeded shapes + 6 glyphs, 20 deltas, 3 styles = 36 090 offsets). After the
-// adaptive pinch classifier, failures before the ladder / after it are:
-//   round 1 -> 0   chamfer 2 -> 0   sharp 4 -> 0
-// All seven rescues are oracle-checked: median area error 0.0972 %, worst 1.663 %, with zero
-// region-count losses and zero complete arc losses. The ladder stays because those seven raw
+// adaptive pinch classifier and the fold-aware clearance fix in contour-winding's
+// scanArrangement (which also resolved five of the seven former pre-ladder failures),
+// failures before the ladder / after it are:
+//   round 0 -> 0   chamfer 1 -> 0   sharp 1 -> 0
+// Both rescues are oracle-checked: median area error 0.0727 %, worst 0.073 %, with zero
+// region-count losses and zero complete arc losses. The ladder stays because those two raw
 // arrangements remain numerically unclosable, not because the formerly parked comb/text
-// failures still exist. Those seven are all erosion (negative delta) or single-region cases;
+// failures still exist. Both are erosion (negative delta) or single-region cases;
 // the per-region rung below is positive-delta-and-multi-region only, so it wins none of them
 // and the rates above are unchanged by its addition — its own coverage class (whole-word text
 // dilation, feedback 86970b00) sits outside this corpus, whose glyphs are single characters

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

@@ -407,16 +407,24 @@ function bisectMaxDistChamfer(fromA, segA, fromB, segB, dist) {
 // cubic or arc) and return {tA, tB, TA, TB, connector} — tA/tB in the
 // neighbors' own parameterizations, ready for trimSegment(); connector is
 // the {to,via?} spliced between the trimmed neighbors.
-function solveCurveCorner(pts, contour, n, i, param, isFillet, label) {
+function solveCurveCorner(pts, contour, n, i, param, isFillet, label, record) {
   const inIdx = (i - 1 + n) % n, fromA = pts[inIdx], segA = contour.segments[inIdx];
   const fromB = pts[i], segB = contour.segments[i];
   const A = curveEvaluator(fromA, segA), B = curveEvaluator(fromB, segB);
   const p1 = pts[i];
   if (isFillet) {
-    const solved = solveFilletTangency(A, B, param);
+    let solved = solveFilletTangency(A, B, param);
     if (!solved) {
-      const maxR = roundNice(bisectMaxRFillet(A, B, param));
-      throw new Error(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): could not fit r=${param} against the curved segment; max ≈ ${maxR}`);
+      // Clamp rather than refuse. bisectMaxRFillet returns a radius the solver
+      // ACCEPTED (lo only ever moves to a solved midpoint), so re-solving at it
+      // succeeds — except when it never found one at all (lo stays 0), which is
+      // a corner with no valid fillet at any radius and stays an error.
+      const maxR = bisectMaxRFillet(A, B, param);
+      solved = maxR > 0 ? solveFilletTangency(A, B, maxR) : null;
+      if (!solved)
+        throw new Error(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): could not fit r=${param} against the curved segment; max ≈ ${roundNice(maxR)}`);
+      record?.(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): r=${param} does not fit against the curved segment — clamped to ${roundNice(maxR)}`);
+      param = maxR;
     }
     const { tA, tB, TA, TB, C } = solved;
     const a0 = Math.atan2(TA[1] - C[1], TA[0] - C[0]);
@@ -427,10 +435,15 @@ function solveCurveCorner(pts, contour, n, i, param, isFillet, label) {
     const M = [C[0] + param * Math.cos(mid), C[1] + param * Math.sin(mid)];
     return { tA, tB, TA, connector: { to: TB, via: M } };
   }
-  const solved = solveChamferArcLength(fromA, segA, fromB, segB, param);
+  let solved = solveChamferArcLength(fromA, segA, fromB, segB, param);
   if (!solved) {
-    const maxDist = roundNice(bisectMaxDistChamfer(fromA, segA, fromB, segB, param));
-    throw new Error(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): could not fit dist=${param} against the curved segment; max ≈ ${maxDist}`);
+    // Same clamp-don't-refuse rule as the fillet branch above.
+    const maxDist = bisectMaxDistChamfer(fromA, segA, fromB, segB, param);
+    solved = maxDist > 0 ? solveChamferArcLength(fromA, segA, fromB, segB, maxDist) : null;
+    if (!solved)
+      throw new Error(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): could not fit dist=${param} against the curved segment; max ≈ ${roundNice(maxDist)}`);
+    record?.(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): dist=${param} does not fit against the curved segment — clamped to ${roundNice(maxDist)}`);
+    param = maxDist;
   }
   const { tA, tB, TA, TB } = solved;
   return { tA, tB, TA, connector: { to: TB } };
@@ -440,19 +453,26 @@ function solveCurveCorner(pts, contour, n, i, param, isFillet, label) {
 // Mirrors cornerArc's tangent/center math (polygon.js:107) but WITHOUT its silent
 // per-corner clamp — filletProfile/chamferProfile throw instead of clamping, so the
 // clamp math is reproduced here unclamped, gated by our own explicit fit checks.
-function buildCornerOpRing(contour, picks, isFillet, label) {
+// ONE attempt at a ring, with `paramAt` supplying each selected corner's current
+// magnitude. Per-corner over-runs are clamped in place here (each has its own
+// computable ceiling); a SHARED-EDGE overlap cannot be, because shrinking one
+// corner changes what its neighbour may claim — so those are reported back as
+// `overlaps` for buildCornerOpRing's loop to resolve and retry.
+function attemptCornerOpRing(contour, picks, isFillet, label, paramAt, clamp, record) {
   const n = contour.segments.length;
   const pts = [contour.start, ...contour.segments.map((s) => s.to)].slice(0, n);
   const plans = new Map();   // vertex index -> {A, B, M, setback} (line-line corners only)
   const curvePlans = new Map();   // vertex index -> {tA, tB, connector} (curve-adjacent corners)
   const selected = new Set(picks.map((p) => p.corner.index));   // this ring's selected vertex indices
+  const overlaps = [];
 
-  for (const { corner, param } of picks) {
+  for (const { corner } of picks) {
     const i = corner.index;
+    let param = paramAt(i);
     if (corner.segTypes[0] !== "line" || corner.segTypes[1] !== "line") {
       // Curve-adjacent corner: routed through the numeric tangency solver, never
       // through the line-line closed-form math below (exactness/speed for lines).
-      curvePlans.set(i, solveCurveCorner(pts, contour, n, i, param, isFillet, label));
+      curvePlans.set(i, solveCurveCorner(pts, contour, n, i, param, isFillet, label, record));
       continue;
     }
     const p0 = pts[(i - 1 + n) % n], p1 = pts[i], p2 = pts[(i + 1) % n];
@@ -461,7 +481,7 @@ function buildCornerOpRing(contour, picks, isFillet, label) {
     const v0 = [v0x / l0, v0y / l0], v2 = [v2x / l2, v2y / l2];
     const cosA = Math.max(-1, Math.min(1, v0[0] * v2[0] + v0[1] * v2[1]));
     const half = Math.acos(cosA) / 2;                        // angle between the two edges, halved
-    const setback = isFillet ? param / Math.tan(half) : param;
+    let setback = isFillet ? param / Math.tan(half) : param;
     // Per-corner ceiling: never past either edge's own end (hard cap, always full — a
     // tangent point can never pass an edge's own extent regardless of who else is
     // selected), and never past half the LONGER edge's "fair share" (soft cap). The soft
@@ -474,9 +494,15 @@ function buildCornerOpRing(contour, picks, isFillet, label) {
     const softL0 = prevShared ? l0 / 2 : l0, softL2 = nextShared ? l2 / 2 : l2;
     const maxSetback = Math.min(l0, l2, Math.max(softL0, softL2));
     if (setback > maxSetback + 1e-9) {
-      const maxParam = roundNice(isFillet ? maxSetback * Math.tan(half) : maxSetback);
+      // Clamp to the ceiling this corner's own edges allow, and go on. The old
+      // throw named the very number used here, so nothing is being guessed —
+      // the caller is simply spared having to read an error and retry by hand.
+      const maxParam = isFillet ? maxSetback * Math.tan(half) : maxSetback;
       const paramTxt = isFillet ? `r=${param}` : `dist=${param}`;
-      throw new Error(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): ${paramTxt} does not fit; max ≈ ${maxParam}`);
+      record?.(`${label}: corner ${i} at (${p1[0]}, ${p1[1]}): ${paramTxt} does not fit — clamped to ${roundNice(maxParam)}`);
+      clamp(i, maxParam);
+      param = maxParam;
+      setback = maxSetback;
     }
     const A = [p1[0] + v0[0] * setback, p1[1] + v0[1] * setback];
     const B = [p1[0] + v2[0] * setback, p1[1] + v2[1] * setback];
@@ -506,8 +532,10 @@ function buildCornerOpRing(contour, picks, isFillet, label) {
       // Curved segment: only curve corners can claim it (line-line requires both
       // neighbors to be "line", so a curved seg is never in `plans`). Overlap ⇔
       // the kept t-span [startCurve.tB, endCurve.tA] collapses or reverses.
-      if (endCurve.tA - startCurve.tB <= 1e-9)
-        throw new Error(`${label}: corners ${k} and ${kNext} overlap on segment ${k} (reduce r)`);
+      // A curve segment's claims are t-parameters, which are not linear in the
+      // magnitude, so there is no exact scale factor to solve for — report the
+      // pair and let the loop back both off geometrically until they fit.
+      if (endCurve.tA - startCurve.tB <= 1e-9) overlaps.push({ k, kNext, factor: null });
     } else {
       // Line segment: a curve-corner claim on it is a t-parameter (curvePlans.tB
       // measures forward from this segment's start; curvePlans.tA forward from its
@@ -516,8 +544,10 @@ function buildCornerOpRing(contour, picks, isFillet, label) {
       const segLen = Math.hypot(pts[kNext][0] - pts[k][0], pts[kNext][1] - pts[k][1]);
       const startClaim = startPlan ? startPlan.setback : startCurve.tB * segLen;
       const endClaim = endPlan ? endPlan.setback : (1 - endCurve.tA) * segLen;
+      // On a straight segment the claim IS the setback, linear in the magnitude,
+      // so the exact scale that makes the pair fit is solvable in one step.
       if (startClaim + endClaim > segLen + 1e-9)
-        throw new Error(`${label}: corners ${k} and ${kNext} overlap on segment ${k} (reduce r)`);
+        overlaps.push({ k, kNext, factor: segLen / (startClaim + endClaim) });
     }
   }
 
@@ -540,14 +570,69 @@ function buildCornerOpRing(contour, picks, isFillet, label) {
     if (endPlan) segments.push(isFillet ? { to: endPlan.B, via: endPlan.M } : { to: endPlan.B });
     if (endCurve) segments.push(endCurve.connector);
   }
-  return { start, segments };
+  return { ring: { start, segments }, overlaps };
 }
 
-function applyCornerOp(input, param, opts, label, isFillet) {
+// How many times the loop below may back off overlapping corner pairs. Each pass
+// only ever REDUCES magnitudes and a straight-segment pair is solved exactly in
+// one step, so real inputs settle in one or two; the bound exists so a
+// pathological ring cannot spin, and reaching it is a genuine failure that
+// throws rather than emitting a ring built from magnitudes still known to
+// overlap.
+const MAX_OVERLAP_PASSES = 8;
+
+// Fillet/chamfer one ring, CLAMPING every magnitude that does not fit rather
+// than refusing the whole profile. Two ceilings apply: a per-corner one, applied
+// in place by the attempt above, and a shared-edge one between two corners
+// claiming the same segment, resolved here because backing one corner off
+// changes what its neighbour may take.
+function buildCornerOpRing(contour, picks, isFillet, label, record) {
+  const params = new Map(picks.map((p) => [p.corner.index, p.param]));
+  const requested = new Map(params);
+  for (let pass = 0; ; pass++) {
+    const last = pass === MAX_OVERLAP_PASSES;
+    const passClamps = new Map();   // corner -> per-corner ceiling this pass applied
+    const messages = [];
+    const { ring, overlaps } = attemptCornerOpRing(
+      contour, picks, isFillet, label,
+      (i) => params.get(i),
+      (i, v) => passClamps.set(i, v),
+      (msg) => messages.push(msg),
+    );
+    if (overlaps.length === 0) {
+      // Report only now, from the pass that actually produced the ring: an
+      // earlier pass's clamp is routinely superseded by a later, smaller one,
+      // and emitting both would describe magnitudes the result never used.
+      for (const msg of messages) record?.(msg);
+      // A magnitude reduced by the overlap loop rather than by a per-corner
+      // ceiling has no message of its own — the attempt never saw it as a
+      // clamp, it was simply handed a smaller number. Report those here, so a
+      // shared-edge shrink is as visible as a per-corner one.
+      for (const { corner } of picks) {
+        const i = corner.index, was = requested.get(i), now = params.get(i);
+        if (now < was - 1e-9 && !passClamps.has(i))
+          record?.(`${label}: corner ${i}: ${isFillet ? "r" : "dist"}=${was} overruns the edge it shares with a neighbouring corner — clamped to ${roundNice(now)}`);
+      }
+      return ring;
+    }
+    if (last)
+      throw new Error(`${label}: corners ${overlaps[0].k} and ${overlaps[0].kNext} overlap on segment ${overlaps[0].k} (reduce r)`);
+    for (const { k, kNext, factor } of overlaps) {
+      // A hair under the exact fit so the next pass's `> segLen + 1e-9` test
+      // clears rather than landing back on the boundary; a null factor (curved
+      // segment, no closed-form scale) backs off geometrically instead.
+      const f = factor === null ? 0.8 : factor * 0.999;
+      for (const i of [k, kNext]) if (params.has(i)) params.set(i, params.get(i) * f);
+    }
+  }
+}
+
+
+function applyCornerOp(input, param, opts, label, isFillet, record) {
   const { kind, regions } = liftProfile(input);
   if (kind === "points" || kind === "contour") {
     const picks = resolveCornerSelector(contourCorners(regions[0].outer), param, opts, label);
-    const outer = buildCornerOpRing(regions[0].outer, picks, isFillet, label);
+    const outer = buildCornerOpRing(regions[0].outer, picks, isFillet, label, record);
     // Always surface a {start,segments} contour, even for a "points" input and an
     // all-line chamfer result: restoreProfile's points-downgrade is for shape-preserving
     // transforms, but a corner op changes the vertex count — it must not collapse back.
@@ -572,20 +657,26 @@ function applyCornerOp(input, param, opts, label, isFillet) {
   for (const { ringRef, picks: ringPicks } of byRing.values()) {
     const rg = newRegions[ringRef.ri];
     const contour = ringRef.key === "outer" ? rg.outer : rg.holes[ringRef.hi];
-    const rebuilt = buildCornerOpRing(contour, ringPicks, isFillet, label);
+    const rebuilt = buildCornerOpRing(contour, ringPicks, isFillet, label, record);
     if (ringRef.key === "outer") rg.outer = rebuilt; else rg.holes[ringRef.hi] = rebuilt;
   }
   return restoreProfile(kind, newRegions);
 }
 
-export function filletProfile(input, r, opts) {
-  return applyCornerOp(input, r, opts, "filletProfile", true);
+// `record` receives one message per magnitude CLAMPED to what the geometry can
+// take (see buildCornerOpRing). Defaulted to console.warn so a direct call still
+// says something; Shape2D threads its kernel's recorder in, which is what puts a
+// clamp on the build result where a caller — or the cloud agent — can act on it.
+export function filletProfile(input, r, opts, record = defaultRecord) {
+  return applyCornerOp(input, r, opts, "filletProfile", true, record);
 }
 
-export function chamferProfile(input, dist, opts) {
-  return applyCornerOp(input, dist, opts, "chamferProfile", false);
+export function chamferProfile(input, dist, opts, record = defaultRecord) {
+  return applyCornerOp(input, dist, opts, "chamferProfile", false, record);
 }
 
+const defaultRecord = (msg) => console.warn(`partforge: ${msg}`);
+
 // ── simplifyProfile (Task 9) ─────────────────────────────────────────────────
 // Corner-preserving decimation/refit: split each contour at its corners (contourCorners,
 // SMOOTH_JOINT_DEG), then reduce each run independently, and reassemble. Corner points are

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

@@ -309,7 +309,21 @@ function scanArrangement(p, tessRings, near = null) {
       if (near) {
         const n = ring.length;
         const delta = r === near.ring ? (i - near.edge + n) % n : -1;
-        const incident = r === near.ring && (delta === 0 || delta === 1 || delta === n - 1);
+        // The projected edge and its immediate neighbours are incident geometry, not an
+        // obstruction — but ONLY while the neighbour actually continues the run. At a fold
+        // apex (a hairpin doubling back on itself within a couple of tessellation edges),
+        // the antiparallel return branch IS edge±1, and blanket-excluding it made clearance
+        // overestimate the safe probe radius by an order of magnitude: the probe stepped
+        // across the fold into a face not adjacent to the piece at all, and _classify kept
+        // an interior piece on the fabricated wRight (the Scott-label italic offset,
+        // feedback 746c4ac2). A neighbour that turns back against the projected edge
+        // (direction dot < 0) is a wall the probe can hit, so it participates in clearance.
+        let incident = r === near.ring && (delta === 0 || delta === 1 || delta === n - 1);
+        if (incident && delta !== 0) {
+          const e = ring[(near.edge + 1) % n], s = ring[near.edge];
+          const dot = (b[0] - a[0]) * (e[0] - s[0]) + (b[1] - a[1]) * (e[1] - s[1]);
+          if (dot < 0) incident = false;
+        }
         if (!incident) clearance = Math.min(clearance, pointEdgeDistance(near.point, a, b));
       }
     }

package/src/framework/geometry/kernel-front.js

@@ -59,7 +59,10 @@ export function finishKernel(k) {
     const raw = k[op];
     if (!raw) continue;
     k[op] = (...a) => {
-      const pos = a.length === 1 && isPlainOptions(a[0]) ? toArgs(a[0]) : a;
+      // toArgs gets the kernel's warning recorder: a couple of specs (roundedBox's
+      // rim clamp) DEGRADE during normalization rather than throwing, and that
+      // degrade has to reach the build's warning list, not just the console.
+      const pos = a.length === 1 && isPlainOptions(a[0]) ? toArgs(a[0], k._recordWarning) : a;
       check?.(...pos);
       return raw(...pos);
     };

package/src/framework/geometry/kernel.js

@@ -31,6 +31,12 @@ export const KERNEL_OPS = [
 // `?.`, so a third-party backend may simply omit them.
 export const KERNEL_OPTIONAL_OPS = [
   "beginSubPart", "endSubPart", "sweepCache", "cacheStats", "resetCacheStats", "cleanup",
+  // Drains the feature-skip warnings recorded since the last drain — a fillet or
+  // chamfer the geometry defeated and the backend skipped rather than failed the
+  // build over. Both backends implement it; a host that never calls it sees the
+  // pre-0.69 behavior (console.warn only). See KERNEL-CONTRACT.md § "Feature-skip
+  // warnings channel".
+  "takeBuildWarnings",
 ];
 
 // Ops every Solid must implement (including the sugar addSugar() attaches).
@@ -153,4 +159,5 @@ export const ROUTED_CAD_OPS = ["shell"];
  * @property {() => {hits:number,misses:number}} [cacheStats]
  * @property {() => void} [resetCacheStats]
  * @property {() => void} [cleanup]   free per-job WASM objects (Manifold backend); call after each job
+ * @property {() => string[]} [takeBuildWarnings]   drain feature-skip warnings (a fillet/chamfer/roundAll the backend skipped rather than failing the build over); drain per sub-part to attribute each message
  */