partforge 0.68.0 → 0.70.0

package/docs/AUTHORING-PARTS.md

@@ -1209,6 +1209,14 @@ Three rules worth internalizing before reaching for any of this:
   paper.js, which is cubic-only — an arc entering a boolean returns as a cubic
   approximation (relative error ~1e-6). `union`/`cut` first, `fillet` last keeps the
   rounded corners true circular arcs all the way to STEP export.
+- **A radius that doesn't fit is CLAMPED, not refused.** `fillet`/`chamfer` reduce any
+  corner whose magnitude its edges cannot hold down to the largest that they can, and
+  report each clamp on the build's warnings — so a slider that used to kill the part at
+  r=3.1 now rounds at whatever fits. Two ceilings apply: the corner's own edges, and
+  the edge it shares with a neighbouring selected corner (both back off together there).
+  It still throws when there is no feasible magnitude at all. **If an exact radius is
+  functionally required** — a bearing seat, a mating fit — do not trust the request:
+  clamp it yourself from the geometry that limits it, or assert it in `verify`.
 - **Run `validateProfile` after mutations.** `fillet`/`chamfer` check only their own
   corner's local fit — not whether the result self-intersects globally (a large radius
   on a narrow profile can produce arcs that cross the far side). `validateProfile`
@@ -2213,6 +2221,17 @@ radius self-intersects its cutters and yields a wrong shape rather than a skippe
 feature (OCCT skips instead). Clamp magnitudes against local geometry the way
 `filleted-box.js` does: `Math.min(p.fillet, halfWidth - 0.5, p.h - 0.5)`.
 
+**A defeated fillet/chamfer skips, and the build reports it.** On both backends a
+fillet or chamfer the geometry defeats does **not** fail the build: the op returns its
+input solid unchanged (edges left sharp) and the build result carries a feature-skip
+warning naming the op, its magnitude, and the reason. The same channel carries every
+other degrade — an `extrude` rim bevel reduced or left square, a `roundedBox` rim
+clamped to `round.side`, a `Shape2D` corner rounded smaller than asked — so the part on screen is real,
+minus that one feature, with everything downstream of it still applied. When a build
+answer includes such a warning, treat it as a failed feature, not a success: say so,
+and either adjust the geometry/radius and retry or leave the feature off deliberately.
+Do not conclude a fillet landed just because the build succeeded.
+
 **Preview routing is per sub-part.** Each sub-part is probed and routed independently, and
 a mixed part's regen fans out to both workers in parallel — a shelled body pays for OCCT
 while a plain lid rebuilds at Manifold speed beside it. Two scopes

package/docs/ERROR-PATTERNS.md

@@ -81,11 +81,11 @@ Variant literals under this entry: `extrude: unknown bevel option`, `extrude: be
 
 - **Symptom:** `partforge: extrude bevel` warning saying the requested distance `exceeds what the profile can take — reduced to` a smaller one (or `has no valid offset for this profile — rim left square`; `hole` in place of `profile` when a hole's flare is the limit).
 - **Cause:** Offsetting the rim by the bevel distance would pinch a narrow feature (a tooth land, a thin bar, a thin web beside a hole) shut, so the bevel deterministically backs off to the largest offset the outline can take — the same geometric limit OCCT's chamfer hits, resolved in pure JS instead of kernel re-runs.
-- **Fix:** Usually nothing — the reduced bevel is the correct maximum for the geometry. To silence it, clamp the bevel parameter below the printed value or widen the narrow feature.
+- **Fix:** Usually nothing — the reduced bevel is the correct maximum for the geometry. To silence it, clamp the bevel parameter below the printed value or widen the narrow feature. Since partforge 0.69 this warning also rides the build result's `warnings` (see [feature-skipped-warning](#feature-skipped-warning)), so a host or agent is told the rim was left square rather than having to read the console.
 
 ## roundedbox-rim-clamped
 
-- **Symptom:** `roundedBox: round.top <n> clamped to round.side <m> (side must be 0 or ≥ rim radii; use side: 0 for a rim-only round-over)` in the console, and the built rim round-over is smaller than the `round.top`/`round.bottom` you passed.
+- **Symptom:** `roundedBox: round.top <n> clamped to round.side <m> (side must be 0 or ≥ rim radii; use side: 0 for a rim-only round-over)` in the console — and, since partforge 0.69, on the build result's `warnings` (see [feature-skipped-warning](#feature-skipped-warning)) — with the built rim round-over smaller than the `round.top`/`round.bottom` you passed.
 - **Cause:** the middle regime `0 < side < rim` has no closed-form corner shared by both backends, so the rim radii clamp down to `side` (the footprint-defining radius never grows silently).
 - **Fix:** either raise `round.side` to ≥ the rim radii (torus/sphere corners), or set `side: 0` exactly for a full-size rim-only round-over on sharp vertical edges.
 
@@ -394,37 +394,44 @@ growing a shape past the hole's own width.
 - **Symptom:** `contour-winding: could not chain offset boundary (incomplete intersection
   set)` thrown from `Shape2D.offset` (or `offsetPolygon`) after a raw offset self-overlaps
   at a narrow pinch.
-- **Cause:** *(Known corpus fixed in partforge 0.60; ID retained permanently.)* The resolver
+- **Cause:** *(Known corpus fixed in partforge 0.60, fold-apex case in 0.68.1; ID retained
+  permanently.)* The resolver
   used to classify every boundary piece from one fixed midpoint probe. At a narrow cell that
   probe could cross a nearby non-incident edge, read the wrong winding on both sides, and
   drop a real continuation. Fully eroded round text counters were a separate upstream cause:
-  their raw offset could retain a negative pocket even under a correct Positive fill.
-- **Fix:** Upgrade to partforge ≥ 0.60. The classifier now chooses among deterministic
-  interior samples by local boundary clearance and caps its probe distance accordingly.
+  their raw offset could retain a negative pocket even under a correct Positive fill. A third
+  cause survived to 0.68.1: at a hairpin fold the antiparallel return branch is the probe
+  anchor's immediate ring neighbour, which the clearance measurement blanket-excluded as
+  incident geometry — the probe stepped across the fold and kept an interior piece
+  (italic-sheared whole-word text was the reproduction).
+- **Fix:** Upgrade to partforge ≥ 0.68.1. The classifier chooses among deterministic
+  interior samples by local boundary clearance, caps its probe distance accordingly, and
+  counts a fold-back neighbour edge (direction reversed against the anchor's) as an
+  obstruction rather than incident geometry.
   Positive round offsets also decide counter collapse from the source hole's inradius before
   generating a raw outline. On the committed 36,090-offset corpus
   (`node scripts/offset-rates.mjs`), chain failures before the retry ladder are
-  1 round / 2 chamfer / 4 sharp and **zero remain after it**; the full glyph matrix,
+  0 round / 1 chamfer / 1 sharp and **zero remain after it**; the full glyph matrix,
   including `"Scott"` through +3, has no throw or topology divergence.
 
   The literal error remains intentionally loud if a new pathological arrangement defeats
-  every retry rung. If it appears on ≥0.60, report the profile, delta, and corner style so it
+  every retry rung. If it appears on ≥0.68.1, report the profile, delta, and corner style so it
   can become a deterministic fixture. Reducing `|delta|` or simplifying nearly coincident
   features is a temporary workaround; changing corner style is not a reliable general fix.
 
 ## fillet-chamfer-radius-does-not-fit
 
-- **Symptom:** `filletProfile: corner <i> at (<x>, <y>): r=<r> does not fit; max ≈ <m>` (or `chamferProfile: … dist=<d> does not fit; max ≈ <m>`) thrown from `Shape2D.fillet`/`.chamfer` or the free `filletProfile`/`chamferProfile` functions.
+- **Symptom:** *(partforge ≥ 0.69 — a WARNING, no longer a throw.)* `filletProfile: corner <i> at (<x>, <y>): r=<r> does not fit — clamped to <m>` (or `chamferProfile: … dist=<d> does not fit — clamped to <m>`) from `Shape2D.fillet`/`.chamfer` or the free `filletProfile`/`chamferProfile` functions, and the corner comes back rounded at `<m>` rather than at what was asked for.
 - **Cause:** The requested radius/distance exceeds what the corner's adjacent edges (or curved neighbor) can hold before the tangent point runs past the segment's own end.
-- **Fix:** Use the reported `max ≈` value, or narrow `opts.corners` to skip that corner. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Editing profiles".
+- **Fix:** Usually nothing — the clamp is the designed degrade, and `<m>` is the largest magnitude that corner can hold. It throws only when a corner admits **no** valid magnitude at all. If the exact radius is functionally required (a bearing seat, a mating fit), the part must give the corner longer edges or select fewer corners; assert it in a `verify` block rather than trusting the request. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Editing profiles".
 
-Variant literal for a curve-adjacent corner (note the semicolon form, not parenthesized): `filletProfile: corner <i> at (<x>, <y>): could not fit r=<r> against the curved segment; max ≈ <m>` (`chamferProfile: … could not fit dist=<d> against the curved segment; max ≈ <m>` for chamfer).
+Variant literal for a curve-adjacent corner: `filletProfile: corner <i> at (<x>, <y>): r=<r> does not fit against the curved segment — clamped to <m>` (`chamferProfile: … dist=<d> …` for chamfer). Its ceiling is bisected rather than closed-form, and the residual throw (`could not fit r=<r> against the curved segment; max ≈ <m>`) survives for a corner where the solver finds no valid radius at all.
 
 ## fillet-chamfer-corners-overlap
 
-- **Symptom:** `filletProfile: corners <i> and <j> overlap on segment <k> (reduce r)` (or the same from `chamferProfile`).
+- **Symptom:** *(partforge ≥ 0.69 — normally a WARNING now.)* `filletProfile: corner <i>: r=<r> overruns the edge it shares with a neighbouring corner — clamped to <m>`. The throw `filletProfile: corners <i> and <j> overlap on segment <k> (reduce r)` survives only as a backstop, when eight successive back-off passes still cannot fit the pair.
 - **Cause:** Two adjacent selected corners each claim more of the edge between them than it has — their combined setbacks exceed the segment's length (or curved arc-length span).
-- **Fix:** Reduce `r`/`dist`, or fillet/chamfer only one of the two corners (drop the other from `opts.corners`). See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Editing profiles".
+- **Fix:** Usually nothing — both corners are scaled down until they fit (exactly, in one step, on a straight shared edge; geometrically on a curved one). Fillet/chamfer only one of the two corners if you would rather keep the other's full radius. See [AUTHORING-PARTS.md](AUTHORING-PARTS.md) § "Editing profiles".
 
 ## profile-query-needs-single-contour
 
@@ -585,6 +592,15 @@ between the Manifold preview and the OCCT STEP export.
 - **Symptom:** A Manifold-built fillet/chamfer produces a mangled or over-cut shape (no error), where the same part on OCCT would skip the feature with a `fillet(…) failed` warning.
 - **Cause:** The mesh fillet does not validate radius feasibility — a magnitude larger than the local geometry self-intersects its cutter solids and the booleans happily apply them.
 - **Fix:** Clamp the magnitude against local dimensions in the part (`Math.min(p.fillet, halfWidth - 0.5, …)` — see `src/parts/filleted-box.js`), which is required practice on the mesh class per [KERNEL-CONTRACT.md](KERNEL-CONTRACT.md) § "Mesh degrade policy".
+
+## feature-skipped-warning
+
+- **Symptom:** The build succeeds but its result carries a warning like `fillet 1.15 failed (<reason>) — feature skipped, edges left sharp` (mesh backend), or `fillet(2) failed (…) — feature skipped` / `chamfer 3 over-ran the geometry — reduced to …` (OCCT repair policy), and the rendered part is missing the blend.
+- **Cause:** *(partforge ≥ 0.69.)* A fillet/chamfer the geometry (or its own selector) defeats no longer fails the whole build on either backend: the op returns its input solid unchanged, everything downstream still applies, and the skip is recorded on the build result's `warnings` (`kernel.takeBuildWarnings()` / the `meshes` message's `warnings: [{part, message}]`).
+- **Fix:** Read the parenthesized reason. A bad selector (unknown plane, wrong `at` height) is a part bug — fix the selector. A geometry-defeated blend usually wants a smaller magnitude or simpler input (clamp per the entry above), or the feature deliberately left off. Treat the warning as "this feature did not land", never as a cosmetic note — the shape on screen genuinely lacks it.
+
+  The same channel carries every other degrade in a build: an `extrude` rim bevel reduced or skipped (`extrude bevel <b> …`), a `roundedBox` rim radius clamped to `round.side`, and the `Shape2D` corner-op clamps in the two entries above. A build result's `warnings` is the complete list of what the part asked for and did not get.
+
 # Hardware library
 
 Reserved for `hardware-*` patterns (issue #30). No entries yet.

package/docs/KERNEL-CONTRACT.md

@@ -98,6 +98,23 @@ them loses sub-part caching and mesh-topology gates (`holes`, emptiness), nothin
 a part (never inside a `beginSubPart`/`endSubPart` bracket), it drops cache partitions that
 have gone unbuilt for three consecutive rebinds.
 
+Sub-part brackets bound cache RETENTION, not reuse: a solid one sub-part builds is reused
+by any other that asks for the same content hash, so a sheet of identical cells split
+across row sub-parts evaluates each distinct cell once rather than once per row. An adopted
+entry is retained by both partitions and disposed only when the last one drops it.
+
+**Transform hoisting.** Booleans commute with rigid transforms, so a conforming backend MAY
+lift a transform every operand shares out of the boolean and apply it to the result
+instead — which is what lets N identically-built copies share one evaluation. Two
+consequences a host must expect. Hoisting evaluates the boolean in a different frame, so
+the result is geometrically equivalent but **not** guaranteed mesh-identical: vertex order,
+triangulation, and triangle count may differ (measured on the in-repo `scott-label`
+lettering: same genus and bounding box, volume agreeing to ~1e-9 relative, ~1% more
+triangles). Output stays deterministic for a given build. And an op is eligible only if it
+provably commutes with the transform — `fillet`/`chamfer` do NOT, because their edge
+selectors can be world-space, so hoisting past one would select different edges and emit
+wrong geometry.
+
 **`import`.** `kernel.import(name) → Solid` returns previously-registered imported geometry
 (STL/STEP/3MF geometry declared in a part's `imports` field); `_registerImport`/
 `_importDigest`/`_acceptsStep`/`_acceptsMesh` are the underscore-prefixed side-channel the
@@ -396,14 +413,43 @@ garbage). A failing chamfer instead binary-searches the largest valid distance.
 conforming B-rep kernel must degrade this way — a fillet request must never brick the
 build, and authors should expect all-or-nothing filleting per call, not per edge.
 
-**Mesh degrade policy** (`mesh-fillet.js`): the mesh class degrades by *rerouting*, not
-skipping — an unsupported edge class or an empty selection throws
-`KernelCapabilityError` and the framework retries the build on the B-rep kernel, which
-then applies its own repair policy. One asymmetry is deliberate: the mesh class does
-**not** validate radius feasibility (an oversized radius yields self-intersecting tools
-and a wrong shape rather than a skipped feature), so parts should clamp magnitudes
-against local geometry the way `filleted-box.js` does — good practice on both classes,
-mandatory on this one.
+**Mesh degrade policy** (`mesh-fillet.js` + `manifold-backend.js`): an unsupported edge
+class or a function selector *reroutes* — it throws `KernelCapabilityError` and the
+framework retries the build on the B-rep kernel, which then applies its own repair
+policy. Every other fillet/chamfer failure on the mesh class (a geometry-defeated
+blend, a selector naming an unknown plane, an empty selection error from the machinery)
+now **skips like the B-rep policy**: the op returns its input solid unchanged and
+records a feature-skip warning instead of failing the build. One asymmetry is
+deliberate: the mesh class does **not** validate radius feasibility (an oversized
+radius yields self-intersecting tools and a wrong shape rather than a skipped feature),
+so parts should clamp magnitudes against local geometry the way `filleted-box.js`
+does — good practice on both classes, mandatory on this one.
+
+**2-D corner-op policy** (`contour-ops.js`, partforge 0.69): `Shape2D.fillet`/`.chamfer`
+— and the free `filletProfile`/`chamferProfile` — **CLAMP** a magnitude the geometry
+cannot take rather than throwing. Two ceilings apply, and both were already computed
+for the error messages this replaces: a per-corner one (closed-form for a line-line
+corner, bisected for a curve-adjacent one) and a shared-edge one where two selected
+corners claim the same segment, resolved by scaling both until they fit — exactly in
+one step on a straight edge, geometrically on a curved one, bounded at 8 passes. Each
+clamp is reported through the warnings channel. It still throws where there is no
+feasible magnitude at all: a corner the curve solver cannot fit at any radius, a
+selector matching no corner, and a shared edge still overlapping after the pass bound.
+A conforming implementation must not silently return the requested magnitude.
+
+**Feature-skip warnings channel** (both backends, partforge 0.69): every skipped,
+clamped, or rescued feature is recorded on the kernel and drained with
+`kernel.takeBuildWarnings()`. The full set: a mesh fillet/chamfer that returned its
+input, occt-repair's skip/bisection rescues, a `roundall-skipped`, an `extrude` rim
+bevel reduced or left square, a `roundedBox` rim radius clamped to `round.side`, and
+a `Shape2D.fillet`/`.chamfer` corner clamped to what its edges can hold. Backend-neutral
+helpers reach the recorder through the kernel's internal `_recordWarning`, so there is
+one list per build rather than one per subsystem. The worker job layer (`jobs.js`) drains per
+sub-part and attaches `warnings: [{part, message}]` to the `meshes` /
+`capture-meshes` result when any were recorded, so a host can tell its user (or its
+agent) that the part on screen is missing a feature it asked for. A skipped op still
+console.warns as before; the channel is additive. Hosts that ignore the field see
+exactly the old behavior.
 
 ## Shape2D (2-D booleans)
 
@@ -530,13 +576,14 @@ delta.
 
 **Measured failure surface.** The committed instrument is
 `node scripts/offset-rates.mjs`, over 600 deterministic seeded shapes plus six glyph cases,
-20 deltas, and three corner styles (36,090 attempts). In partforge 0.60 it reports:
+20 deltas, and three corner styles (36,090 attempts). In partforge 0.68.1 (after the
+fold-aware clearance fix in the winding classifier) it reports:
 
-- before the retry ladder: round 1/12,030 (0.008%), chamfer 2/12,030 (0.017%), sharp
-  4/12,030 (0.033%);
+- before the retry ladder: round 0/12,030, chamfer 1/12,030 (0.008%), sharp
+  1/12,030 (0.008%);
 - after the retry ladder: zero chain-incomplete failures for all three styles;
-- seven oracle-checked rescues, with median area error 0.0972%, worst 1.663%
-  (2.2373 mm²), zero region-count losses, and zero complete arc losses.
+- two oracle-checked rescues, with median area error 0.0727%, worst 0.073%
+  (0.0720 mm²), zero region-count losses, and zero complete arc losses.
 
 The ladder remains a numerical escape hatch: it perturbs delta by 1e-9, coarsens crossing
 clustering, then tries polyline outlines. A future case that reaches a coarse clustering or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.68.0",
+  "version": "0.70.0",
   "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/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
  */

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

@@ -7,6 +7,7 @@ import { h } from "./solid-hash.js";
 import { ensureOutward, openEdgeCount } from "./mesh-repair.js";
 import { manifoldFromMesh } from "./mesh-build.js";
 import { createSolidCache } from "./solid-cache.js";
+import { hoistCommonSuffix } from "./transform-hoist.js";
 import { addSugar } from "./solid-sugar.js";
 import { makeShape2dFactory } from "./shape2d.js";
 import { offsetRegions } from "./contour-offset.js";
@@ -54,6 +55,33 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
   const unionRaw = (ms) => (ms.length === 1 ? ms[0] : T(Manifold.union(ms)));
 
   const cache = createSolidCache();
+  // Feature-skip warnings (the OCCT backend's safeOp policy, adopted here): a
+  // fillet/chamfer whose mesh machinery is defeated by the geometry returns its
+  // INPUT solid unchanged and records one message here instead of failing the
+  // whole build. jobs.js drains this per sub-part (takeBuildWarnings) and ships
+  // it out on the meshes message, so a caller — the cloud agent above all — is
+  // TOLD the feature was skipped rather than left believing it landed.
+  const buildWarnings = [];
+  // cache key -> warning message for ops that skipped. The identity result is
+  // deliberately NOT cached (a later build should re-attempt the feature after
+  // upstream geometry changes — same key means same failure, so re-warning is
+  // cheap), but a repeated call in the SAME session must still re-emit the
+  // warning: without this map, a no-op re-apply would rebuild from warm caches
+  // upstream, hit the recorded skip nowhere, silently re-fail and re-warn — fine
+  // — but a memoized wrapper above us could also swallow the retry. Keeping the
+  // message per key makes "skipped before, skipped again" deterministic and free.
+  const skippedOps = new Map();
+  // The one recorder. Shared, backend-neutral degrades (the extrude rim bevel in
+  // rim-bevel.js, roundedBox's rim clamp in op-options.js, Shape2D's corner-op
+  // clamps in contour-ops.js) reach it through the kernel's `_recordWarning`, so
+  // every degrade in the build lands in one drainable list rather than only in
+  // the console.
+  const recordWarning = (msg) => { buildWarnings.push(msg); console.warn(`partforge: ${msg}`); };
+  const skipFeature = (key, op, magnitude, err) => {
+    const msg = `${op} ${magnitude} failed (${String(err?.message || err).slice(0, 200)}) — feature skipped, edges left sharp`;
+    skippedOps.set(key, msg);
+    recordWarning(msg);
+  };
   const featureLabels = new Map(); // originalID -> label string (grows per label(); tiny)
   const oidPolicies = new Map();   // originalID -> shading policy (grows per faceted/hinted loft; tiny)
   // name -> { m, digest, hash } | { error, digest } — imported geometry the framework
@@ -67,6 +95,20 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     return { value: wrap(m, hash), pin: m, dispose: () => m.delete?.() };
   });
 
+  // Booleans commute with any invertible affine map, so a transform EVERY operand
+  // ends with can be lifted out of the boolean and applied to its result instead.
+  // That is what collapses N identically-built copies into one evaluation: with the
+  // shared transform gone, the operand hashes are identical for every copy, so the
+  // boolean itself hits the cache. Returns null when nothing is shared, leaving the
+  // caller on its ordinary path.
+  const hoistBoolean = (opName, solids, evaluate) => {
+    const { hoisted, residuals } = hoistCommonSuffix(solids.map((s2) => s2._canon.chain));
+    if (!hoisted.length) return null;
+    const ops = solids.map((s2, i) => replay(wrap(s2._canon.m, s2._canon.hash), residuals[i]));
+    const canonical = cached(h(opName, ops.map((s2) => s2._hash)), () => evaluate(ops));
+    return replay(canonical, hoisted);
+  };
+
   // Contour-IR region list -> flat point rings at `nSeg` (outer + holes, even/odd
   // fill sorts them out). The one place the IR meets CrossSection.ofPolygons.
   const regionPolys = (regions, nSeg) => regions.flatMap((rg) =>
@@ -80,6 +122,7 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     segs,
     extrude: (o) => kernel.extrude(o),
     revolve: (o) => kernel.revolve(o),
+    recordWarning,
   });
   // Lazy CrossSection materialization, memoized through the solid cache by content
   // hash + LOD: the same shape extruded twice (or extruded and revolved) tessellates
@@ -237,8 +280,13 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
         let base = T(Manifold.extrude(cur, height));
         if (z0 !== 0) base = T(base.translate([0, 0, z0]));
         const wrapped = wrap(base, h("roundAllPrismBase", mHash, r, quality));
-        // selector-free: every sharp edge of the mitered prism gets its radius here
-        const filleted = wrapped.fillet(r);
+        // selector-free: every sharp edge of the mitered prism gets its radius here.
+        // The THROWING form deliberately: this path's answer to a failed fillet is
+        // the `catch` below, which returns null and hands the job to the reference
+        // Minkowski roundAll. The degrading public fillet would instead hand back
+        // the un-rounded prism, and this function would emit it as a successful
+        // roundAll — silently wrong geometry instead of a correct slow result.
+        const filleted = wrapped._filletRaw(r);
         // Decouple from the fillet cache's pin: cached() will pin the object this
         // returns under the roundAll hash, and one WASM object must never sit
         // under two cache entries (double-dispose on eviction). The decouple is
@@ -273,22 +321,79 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     }
   };
 
-  const wrap = (m, hash) => addSugar({
+  // Replay a recorded transform chain onto a solid. Each record maps back to the op
+  // that produced it, so the replayed solid rebuilds the same chain on its own canon.
+  const replay = (solid, chain) => chain.reduce(
+    (s2, r) => (r.op === "translate" ? s2.translate(r.v) : s2.rotate(r.deg, r.center, r.axis)), solid);
+
+  // `canon` is this solid expressed as a base solid plus the trailing transform chain
+  // applied to it (oldest first). Only ops that provably COMMUTE with a rigid
+  // transform extend the chain — translate, rotate, and label; everything else starts
+  // a fresh canonical base. fillet/chamfer are deliberately excluded even though they
+  // look eligible: their edge selectors can be world-space, so filleting the
+  // untranslated base would pick different edges — wrong geometry, not a missed hit.
+  //
+  // `self` names the wrapper being built so the degrading public fillet/chamfer
+  // can delegate to their throwing `_`-prefixed twins above without re-deriving
+  // the cache key or the capability checks. Declared as a binding the closures
+  // capture: every reference runs after addSugar has returned.
+  const wrap = (m, hash, canon = { m, hash, chain: [] }) => {
+    const self = addSugar({
     _m: m,
     _hash: hash,
+    _canon: canon,
     cut: (t) => cached(h("cut", hash, t._hash), () => T(m.subtract(t._m))),
-    fillet: (r, selector) => {
+    // THROWING forms. These are the composition primitives — internal callers
+    // that have their own recovery (prismRoundAllFast, which answers a failed
+    // fillet by falling back to the reference Minkowski roundAll) must use
+    // these, never the degrading public ops below: a skip there would emit an
+    // UN-rounded prism as a successful roundAll, which is silently wrong
+    // geometry rather than a reported missing feature.
+    _filletRaw: (r, selector) => {
       if (typeof selector === "function") throw new KernelCapabilityError("fillet: function selectors need the OCCT backend");
       if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
       return cached(h("fillet", hash, r, selector ?? null, segs), () =>
         meshCadOp("fillet", m, () => meshFillet(kernel, wrap(m, hash), { r, edges: selector, segs })));
     },
-    chamfer: (d, selector) => {
+    _chamferRaw: (d, selector) => {
       if (typeof selector === "function") throw new KernelCapabilityError("chamfer: function selectors need the OCCT backend");
       if (d === 0) return wrap(m, hash);
       return cached(h("chamfer", hash, d, selector ?? null, segs), () =>
         meshCadOp("chamfer", m, () => meshChamfer(kernel, wrap(m, hash), { d, edges: selector, segs })));
     },
+
+    // The AUTHOR-FACING ops degrade on failure instead of failing the build (the
+    // OCCT backend's safeOp policy — see occt-repair.js): a defeated op returns
+    // the INPUT solid and records a feature-skip warning. Only NEEDS_OCCT
+    // capability errors still propagate — they are the split-backend reroute
+    // signal, not a geometry failure, and swallowing one would strand the
+    // sub-part on the wrong backend. The skip result is not cached: same key →
+    // same failure → same cheap re-warn, while an upstream geometry change mints
+    // a new key and genuinely re-attempts the feature.
+    fillet: (r, selector) => {
+      const key = h("fillet", hash, r, selector ?? null, segs);
+      const skipped = skippedOps.get(key);
+      if (skipped !== undefined) { buildWarnings.push(skipped); return wrap(m, hash); }
+      try {
+        return self._filletRaw(r, selector);
+      } catch (e) {
+        if (e?.code === "NEEDS_OCCT") throw e;
+        skipFeature(key, "fillet", r, e);
+        return wrap(m, hash);
+      }
+    },
+    chamfer: (d, selector) => {
+      const key = h("chamfer", hash, d, selector ?? null, segs);
+      const skipped = skippedOps.get(key);
+      if (skipped !== undefined) { buildWarnings.push(skipped); return wrap(m, hash); }
+      try {
+        return self._chamferRaw(d, selector);
+      } catch (e) {
+        if (e?.code === "NEEDS_OCCT") throw e;
+        skipFeature(key, "chamfer", d, e);
+        return wrap(m, hash);
+      }
+    },
     roundAll: (r) => {
       if (r === 0) return wrap(m, hash); // contract: zero magnitude is the identity
       // `quality` in the key is redundant but harmless — the cache lives on a
@@ -311,6 +416,11 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // registry entry lives exactly as long as the cache pins the solid — eviction
     // disposes both, so the registry can't grow unboundedly across regenerates.
     label: (name) => {
+      // Labeling only re-stamps surface ids, so it commutes with the trailing
+      // transform. This is load-bearing rather than an optimization: the common
+      // authoring idiom labels each piece AFTER positioning it, which would give every
+      // copy its own canonical base and stop the hoist below from ever firing.
+      if (canon.chain.length) return replay(wrap(canon.m, canon.hash).label(name), canon.chain);
       const lh = h("label", hash, name);
       return cache.lookup(lh, () => {
         // Blend-aware re-stamp. If this mesh carries blend surfaces (the boundaryLines
@@ -415,14 +525,16 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     volume: () => m.volume(),
     genus: () => m.genus(),
     isEmpty: () => m.isEmpty(),
-    translate: (v) => wrap(T(m.translate(v)), h("translate", hash, v)),
+    translate: (v) => wrap(T(m.translate(v)), h("translate", hash, v),
+      { m: canon.m, hash: canon.hash, chain: [...canon.chain, { op: "translate", v }] }),
     rotate: (deg, center, axis) => {
       const nz = (axis[0] !== 0) + (axis[1] !== 0) + (axis[2] !== 0);
       const a = T(m.translate([-center[0], -center[1], -center[2]]));
       const b = nz <= 1
         ? T(a.rotate([axis[0] * deg, axis[1] * deg, axis[2] * deg]))   // basis axis — euler is exact; unchanged
         : T(a.transform(axisAngleMat4(axis, deg)));                    // general axis-angle
-      return wrap(T(b.translate(center)), h("rotate", hash, deg, center, axis));
+      return wrap(T(b.translate(center)), h("rotate", hash, deg, center, axis),
+        { m: canon.m, hash: canon.hash, chain: [...canon.chain, { op: "rotate", deg, center, axis }] });
     },
     mirror: (plane) => wrap(T(m.mirror(PLANE_NORMAL[plane])), h("mirror", hash, plane)),
     scale: (factor, center) => { // factor validated (and center defaulted) by addSugar
@@ -433,7 +545,9 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     toMesh: () => meshOut(m, false),
     toSTL: () => Promise.resolve(meshOut(m, true)),
     toIndexedMesh: () => indexedMeshOut(m),
-  });
+    });
+    return self;
+  };
 
   const kernel = finishKernel({
     cylinder: (rb, rt, h2, { center = false } = {}) =>
@@ -524,7 +638,8 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     // would pin one WASM object under two entries and eviction would dispose it twice.
     union: (solids) => solids.length === 1
       ? solids[0]
-      : cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
+      : hoistBoolean("union", solids, (ops) => unionRaw(ops.map((s) => s._m)))
+        ?? cached(h("union", solids.map((s) => s._hash)), () => unionRaw(solids.map((s) => s._m))),
     // Imported geometry, registered pre-build by the framework via `_registerImport`
     // (ensureImports, Task 8). The master Manifold is kernel-lifetime (untracked —
     // see `imports` above); wrap() is free, so every call is cheap.
@@ -571,6 +686,13 @@ export function createManifoldKernel(wasm, { quality = "preview" } = {}) {
     sweepCache: () => cache.sweep(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
+    // Drain the feature-skip warnings recorded since the last drain (see
+    // buildWarnings above). jobs.js calls this per sub-part so a warning is
+    // attributed to the sub-part whose build recorded it.
+    takeBuildWarnings: () => buildWarnings.splice(0),
+    // Internal (underscore = not the contract surface): the recorder shared,
+    // backend-neutral helpers report their own degrades through.
+    _recordWarning: recordWarning,
     // Free every WASM object created since the last cleanup EXCEPT solids the cache
     // still pins (they must survive for the next build to resume from them).
     cleanup: () => { for (const o of tracked) if (!cache.isPinned(o)) o.delete?.(); tracked.length = 0; },

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

@@ -39,9 +39,15 @@ export function createOcctKernel(replicad) {
   const { makeCylinder, makeBox, makeCircle, makeHelix, assembleWire, genericSweep,
           loft, draw, exportSTEP, importSTEP, measureVolume, makeSphere, makeLine, Plane } = replicad;
 
+  // Feature-skip warnings: everything occt-repair (and roundAll) skips or rescues
+  // is recorded here as well as console.warned, and jobs.js drains it per
+  // sub-part (takeBuildWarnings) onto the meshes message — same channel as the
+  // Manifold backend's fillet/chamfer degradation.
+  const buildWarnings = [];
+  const recordWarning = (msg) => { buildWarnings.push(msg); console.warn(`partforge: ${msg}`); };
   // Fillet/chamfer/shell failure recovery (skip-on-failure, chamfer binary search) —
   // see occt-repair.js for the policies and why they differ per op.
-  const { validChamfer, safeOp } = createOcctRepair(measureVolume);
+  const { validChamfer, safeOp } = createOcctRepair(measureVolume, recordWarning);
 
   // name -> { shape, digest } | { error, digest } — imported geometry the framework
   // registers pre-build via `_registerImport` (kernel-lifetime, untracked by the
@@ -234,7 +240,7 @@ export function createOcctKernel(replicad) {
         return cached(key, () => {
           const a = mat();
           if (r === 0) return wrap(a._s.clone(), cloneLabels(a._labels), key);
-          return wrap(occtRoundAll(replicad, a._s, r), cloneLabels(a._labels), key);
+          return wrap(occtRoundAll(replicad, a._s, r, recordWarning), cloneLabels(a._labels), key);
         });
       },
       shell: (thickness, openFaces) => {
@@ -367,6 +373,7 @@ export function createOcctKernel(replicad) {
     segs: SHAPE2D_SEGS,
     extrude: (o) => kernel.extrude(o),
     revolve: (o) => kernel.revolve(o),
+    recordWarning,
   });
   // Lazy Drawing materialization for the kernel ops that need one. drawingFromRegions
   // draws a FRESH Drawing on every call, so callers never need to .clone() the result
@@ -524,6 +531,12 @@ export function createOcctKernel(replicad) {
     sweepCache: () => cache.sweep(),
     cacheStats: () => cache.stats(),
     resetCacheStats: () => cache.resetStats(),
+    // Drain the feature-skip warnings recorded since the last drain — the
+    // Manifold backend's channel, mirrored (see occt-repair.js for the sources).
+    takeBuildWarnings: () => buildWarnings.splice(0),
+    // Internal: the recorder shared, backend-neutral helpers report through
+    // (rim-bevel, roundedBox's clamp, Shape2D corner-op clamps).
+    _recordWarning: recordWarning,
   });
   return kernel;
 }

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

@@ -33,7 +33,11 @@ export const isClosedSolid = (shape) => {
   return true;
 };
 
-export function createOcctRepair(measureVolume) {
+// `warn` receives every feature-skip / rescue message. The default keeps the
+// historical console.warn; the OCCT backend injects a recorder that ALSO feeds
+// the kernel's takeBuildWarnings channel, so a skipped feature reaches the
+// build result (and, in the cloud app, the agent) instead of only the console.
+export function createOcctRepair(measureVolume, warn = (msg) => console.warn(`partforge: ${msg}`)) {
   // The true maximum chamfer for an edge depends on local angles and adjacent features,
   // which is hard to predict analytically (and OCCT exposes no max-radius query). So
   // VALIDATE the result instead of guessing: try the requested distance, and if it makes
@@ -65,8 +69,8 @@ export function createOcctRepair(measureVolume) {
     // multiplies an already-expensive op by ~8x, so make the cost loud enough to
     // act on (lower the distance, or bevel profile rims with a loft instead).
     const cost = `${attempts} attempts, ${((performance.now() - t0) / 1000).toFixed(1)}s — see ERROR-PATTERNS.md#chamfer-rescue-bisection`;
-    if (best) { console.warn(`partforge: chamfer ${distance} over-ran the geometry — reduced to ${bestD.toFixed(2)} (largest valid; ${cost})`); return best; }
-    console.warn(`partforge: chamfer ${distance} has no valid distance for this geometry — feature skipped (${cost})`);
+    if (best) { warn(`chamfer ${distance} over-ran the geometry — reduced to ${bestD.toFixed(2)} (largest valid; ${cost})`); return best; }
+    warn(`chamfer ${distance} has no valid distance for this geometry — feature skipped (${cost})`);
     return shape.clone();                                    // nothing valid — skip the chamfer
   };
 
@@ -90,10 +94,10 @@ export function createOcctRepair(measureVolume) {
       const resultVolume = measureVolume(result);
       if (resultVolume > 0 && (!isValid || isValid(resultVolume, beforeVolume))) { backup.delete?.(); return result; }
       result.delete?.();
-      if (resultVolume > 0) console.warn(`partforge: ${label} produced invalid geometry — feature skipped`);
-      else console.warn(`partforge: ${label} produced an empty solid — feature skipped (radius out of range?)`);
+      if (resultVolume > 0) warn(`${label} produced invalid geometry — feature skipped`);
+      else warn(`${label} produced an empty solid — feature skipped (radius out of range?)`);
     } catch (e) {
-      console.warn(`partforge: ${label} failed (${e?.message || e}) — feature skipped`);
+      warn(`${label} failed (${e?.message || e}) — feature skipped`);
     }
     return backup;
   };

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

@@ -31,7 +31,7 @@ const VARIANTS = [
   { join: "int", inter: true },
 ];
 
-export function occtRoundAll(replicad, shape, r) {
+export function occtRoundAll(replicad, shape, r, warn = (msg) => console.warn(`partforge: ${msg}`)) {
   if (!Number.isFinite(r) || r <= 0) throw new Error("roundAll: r must be a finite number > 0 (r = 0 is handled as the identity by the caller)");
   const oc = replicad.getOC();
   const tryOffset = (topo, offset, v) => {
@@ -60,7 +60,7 @@ export function occtRoundAll(replicad, shape, r) {
     vol = replicad.measureVolume(shape);
   } catch (e) {
     // Can't gate what can't be measured — skip rather than run the cascade blind.
-    console.warn(`partforge: roundall-skipped: the input solid's volume could not be measured (${e?.message || e}); returning the un-rounded solid`);
+    warn(`roundall-skipped: the input solid's volume could not be measured (${e?.message || e}); returning the un-rounded solid`);
     return shape.clone(); // if the clone throws too, the caller's shape is unusable — let it propagate
   }
   let cur = shape;
@@ -85,7 +85,7 @@ export function occtRoundAll(replicad, shape, r) {
     }
     if (cur !== shape) cur.delete?.(); // superseded intermediate; never the caller's shape
     if (!next) {
-      console.warn(`partforge: roundall-skipped: offset step ${off} produced no valid solid — r=${r} is likely at/above the smallest feature size; returning the un-rounded solid`);
+      warn(`roundall-skipped: offset step ${off} produced no valid solid — r=${r} is likely at/above the smallest feature size; returning the un-rounded solid`);
       return shape.clone();
     }
     cur = next;

package/src/framework/geometry/op-options.js

@@ -150,7 +150,7 @@ const checkRoundRadius = (op, name, v, max, maxDesc) => {
   if (v > max + 1e-9) throw new Error(`${op}: ${name} (${v}) must be ≤ ${maxDesc}`);
 };
 
-export function roundedBoxArgs(o) {
+export function roundedBoxArgs(o, record) {
   checkKeys("roundedBox", o, ["size", "center", "round"]);
   const size = req("roundedBox", o, "size");
   if (!Array.isArray(size) || size.length !== 3 || !size.every((v) => Number.isFinite(v) && v > 0))
@@ -174,6 +174,11 @@ export function roundedBoxArgs(o) {
         // message (and a distinct Set entry) on every rebuild, defeating the dedupe.
         const dedupeKey = `roundedBox.${key}|${round.side}`;
         const msg = `roundedBox: round.${key} ${round[key]} clamped to round.side ${round.side} (side must be 0 or ≥ rim radii; use side: 0 for a rim-only round-over)`;
+        // The console dedupe stays (a slider sweep would otherwise spam it), but
+        // the RECORDER is fed every time: warnings are drained per build, so
+        // deduping them across builds would silently drop the clamp from the
+        // second and every later build that still clamps.
+        record?.(msg);
         if (!warnedClamps.has(dedupeKey)) { warnedClamps.add(dedupeKey); console.warn(msg); }
         round[key] = round.side;
       }

package/src/framework/geometry/rim-bevel.js

@@ -67,7 +67,7 @@ const ccw = (r) => {
 // loop is deterministic, preserving build purity. `corners: "sharp"` keeps the
 // offset 1:1 with the input points — loft stitching requires every ring to
 // share the profile's exact point count (a mismatch is treated as a failed try).
-const fit = (ring, delta, what) => {
+const fit = (ring, delta, what, record) => {
   const requested = Math.abs(delta), sign = Math.sign(delta);
   let c = requested;
   for (;;) {
@@ -75,13 +75,13 @@ const fit = (ring, delta, what) => {
       const off = offsetPolygon(ring, sign * c, { corners: "sharp" });
       if (off.length === ring.length) {
         if (c < requested)
-          console.warn(`partforge: extrude bevel ${requested} exceeds what the ${what} can take — reduced to ${c.toFixed(2)}`);
+          record(`extrude bevel ${requested} exceeds what the ${what} can take — reduced to ${c.toFixed(2)}`);
         return { ring: off, c };
       }
     } catch { /* offset collapsed or self-intersected — try smaller */ }
     c *= 0.85;
     if (c < 0.05) {
-      console.warn(`partforge: extrude bevel ${requested} has no valid offset for this ${what} — rim left square`);
+      record(`extrude bevel ${requested} has no valid offset for this ${what} — rim left square`);
       return null;
     }
   }
@@ -96,12 +96,12 @@ const outerRings = (outer, h, b, t) => {
   return rings;
 };
 
-const bevelRegion = (k, region, h, bottom, top) => {
+const bevelRegion = (k, region, h, bottom, top, record) => {
   const outer = ccw(region.outer);
   const holes = (region.holes ?? []).map(ccw);
   let s = k.extrude({ profile: holes.length ? { outer, holes } : outer, h });
-  const b = bottom > 0 ? fit(outer, -bottom, "profile") : null;
-  const t = top > 0 ? fit(outer, -top, "profile") : null;
+  const b = bottom > 0 ? fit(outer, -bottom, "profile", record) : null;
+  const t = top > 0 ? fit(outer, -top, "profile", record) : null;
   // shading: "smooth" on all three internal lofts — a bevel band inherits the
   // profile's own shading intent (sharp corners at the bevel's start/end
   // rings, as a real chamfer would look), not the loft op's own facet-vs-
@@ -112,11 +112,11 @@ const bevelRegion = (k, region, h, bottom, top) => {
   if (b || t) s = s.intersect(k.loft({ rings: outerRings(outer, h, b, t), shading: "smooth" }));
   const cutters = [];
   for (const hole of holes) {
-    const hb = bottom > 0 ? fit(hole, bottom, "hole") : null;
+    const hb = bottom > 0 ? fit(hole, bottom, "hole", record) : null;
     if (hb) cutters.push(k.loft({ rings: [
       { polygon: hb.ring, z: -1 }, { polygon: hb.ring, z: 0 }, { polygon: hole, z: hb.c },
     ], shading: "smooth" }));
-    const ht = top > 0 ? fit(hole, top, "hole") : null;
+    const ht = top > 0 ? fit(hole, top, "hole", record) : null;
     if (ht) cutters.push(k.loft({ rings: [
       { polygon: hole, z: h - ht.c }, { polygon: ht.ring, z: h }, { polygon: ht.ring, z: h + 1 },
     ], shading: "smooth" }));
@@ -124,7 +124,14 @@ const bevelRegion = (k, region, h, bottom, top) => {
   return cutters.length ? s.cutAll(cutters) : s;
 };
 
-export function beveledExtrude(k, { profile, h, twist, scaleTop, bevel }) {
+// `record` reports the two ways a rim bevel degrades — reduced to what the ring
+// can take, or skipped entirely with the rim left square. Both used to reach only
+// console.warn, which meant a build could come back ok:true with a bevel the part
+// asked for and never got, invisible to the caller (and to the cloud agent). The
+// kernel supplies its own recorder; the default keeps the historical console.warn
+// for a direct call with no kernel recorder behind it.
+export function beveledExtrude(k, { profile, h, twist, scaleTop, bevel },
+                               record = k?._recordWarning ?? ((m) => console.warn(`partforge: ${m}`))) {
   if (twist !== undefined || scaleTop !== undefined)
     throw new Error("extrude: bevel cannot combine with twist or scaleTop");
   const { bottom, top } = resolveBevel(bevel, h);
@@ -135,5 +142,5 @@ export function beveledExtrude(k, { profile, h, twist, scaleTop, bevel }) {
     ? profile.toRegions()
     : [tessellateProfile(profile, BEVEL_SEGS)];
   if (regions.length === 0) throw new Error("extrude: bevel profile produced no regions");
-  return regions.map((r) => bevelRegion(k, r, h, bottom, top)).reduce((a, x) => a.union(x));
+  return regions.map((r) => bevelRegion(k, r, h, bottom, top, record)).reduce((a, x) => a.union(x));
 }

package/src/framework/geometry/shape2d.js

@@ -45,7 +45,11 @@ const checkProfile = (x) => {
   }
 };
 
-export function makeShape2dFactory({ segs, extrude, revolve }) {
+// `recordWarning` is the kernel's build-warning recorder (see manifold-backend /
+// occt-backend). Corner ops CLAMP a magnitude the geometry cannot take rather
+// than throwing, and a clamp that only reached the console would leave a caller
+// believing it got the radius it asked for.
+export function makeShape2dFactory({ segs, extrude, revolve, recordWarning }) {
   // 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.
@@ -86,8 +90,8 @@ export function makeShape2dFactory({ segs, extrude, revolve }) {
       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)),
+      fillet:    (r, opts) => viaOps((rg) => filletProfile(rg, r, opts, recordWarning)),
+      chamfer:   (d, opts) => viaOps((rg) => chamferProfile(rg, d, opts, recordWarning)),
       simplify:  (tol) => viaOps((r) => simplifyProfile(r, tol)),
       corners:   () => profileCorners(regions),
       contains:  (p) => profileContains(regions, p),

package/src/framework/geometry/solid-cache.js

@@ -1,23 +1,41 @@
 // Worker-side cache of boundary-op solids, partitioned per sub-part. Retention is
 // bounded to the CURRENT build's graph: each begin()/end() bracket rebuilds a
 // sub-part's retained set from scratch, disposing any entry not re-used this round.
+// Partitions bound RETENTION, never reuse: a `index` keyed by hash spans them all, so
+// geometry one sub-part builds is adopted by the next rather than rebuilt (a sheet of
+// identical cells split across row sub-parts paid that rebuild per row). An adopted
+// entry is retained by BOTH partitions, so disposal is refcounted — see release().
 // WASM-agnostic — it stores opaque {value, pin, dispose} triples supplied by the
 // caller (the Manifold backend), so it is unit-testable with plain objects.
 export function createSolidCache() {
-  const caches = new Map(); // name -> Map(hash -> { value, pin, dispose })
+  const caches = new Map(); // name -> Map(hash -> { value, pin, dispose, refs })
   const pinned = new Set();  // every live `pin` across all sub-parts
+  const index = new Map();   // hash -> entry, ACROSS partitions: identical geometry built
+                             // for one sub-part is reused by every other (see lookup).
   const lastBuilt = new Map(); // name -> rebind generation of the partition's last begin()
   let generation = 0;          // bumped only by sweep() (i.e. per part rebind)
   let name = null, active = null, prev = null;
   let hits = 0, misses = 0;
 
+  // One partition stops retaining `entry`. Disposal waits for the LAST holder:
+  // a solid shared across sub-parts is one WASM object, so disposing it when the
+  // first partition drops it would leave every other partition — and the shared
+  // index — pointing at freed memory. Dropping the index entry in the same breath
+  // is what keeps the cache from handing out a disposed solid later.
+  const release = (hash, entry) => {
+    if (--entry.refs > 0) return;
+    if (index.get(hash) === entry) index.delete(hash);
+    pinned.delete(entry.pin);
+    entry.dispose();
+  };
+
   return {
     begin(n) { name = n; lastBuilt.set(n, generation); prev = caches.get(n) ?? new Map(); active = new Map(); },
 
     end() {
       if (name == null) return;
       for (const [hash, entry] of prev) {
-        if (!active.has(hash)) { pinned.delete(entry.pin); entry.dispose(); } // evict
+        if (!active.has(hash)) release(hash, entry); // this partition drops it
       }
       caches.set(name, active);
       name = null; active = prev = null;
@@ -31,7 +49,7 @@ export function createSolidCache() {
       generation++;
       for (const [n, entries] of caches) {
         if (generation - (lastBuilt.get(n) ?? 0) < 3) continue;
-        for (const entry of entries.values()) { pinned.delete(entry.pin); entry.dispose(); }
+        for (const [hash, entry] of entries) release(hash, entry); // refcounted: a shared solid survives
         caches.delete(n);
         lastBuilt.delete(n);
       }
@@ -41,9 +59,14 @@ export function createSolidCache() {
       if (name == null) return make().value; // not bracketed → no caching
       if (active.has(hash)) { hits++; return active.get(hash).value; }
       if (prev.has(hash)) { hits++; const e = prev.get(hash); active.set(hash, e); return e.value; }
+      // Another sub-part already built this exact solid — adopt it. `refs` rises
+      // because a second partition now retains it; see release().
+      if (index.has(hash)) { hits++; const e = index.get(hash); e.refs++; active.set(hash, e); return e.value; }
       misses++;
       const entry = make();
+      entry.refs = 1;
       active.set(hash, entry);
+      index.set(hash, entry);
       pinned.add(entry.pin);
       return entry.value;
     },

package/src/framework/geometry/transform-hoist.js

@@ -0,0 +1,47 @@
+// Pure suffix-matching for boolean transform hoisting. A solid carries the trailing
+// transform chain applied to its canonical base (`canon.chain`, oldest first, so the
+// LAST record is the outermost transform). Booleans commute with any invertible
+// affine map, so a transform every operand ends with can be lifted out of the boolean
+// and applied to its result instead — which is what lets 30 identically-built cells
+// share ONE evaluated union instead of 30.
+//
+// Matching is SYMBOLIC (compare the recorded arguments), never numeric: deriving a
+// residual as X⁻¹·xᵢ would make rotations disagree in the last bits from copy to copy
+// and the hoist would silently stop firing. Comparing arguments is exact.
+
+const same = (a, b) => {
+  if (a.op !== b.op) return false;
+  if (a.op === "translate") return vecEq(a.v, b.v);
+  return a.deg === b.deg && vecEq(a.center, b.center) && vecEq(a.axis, b.axis);
+};
+const vecEq = (a, b) => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+
+export function hoistCommonSuffix(chains) {
+  const rest = chains.map((c) => c.slice());
+  const hoisted = [];
+  for (;;) {
+    if (rest.some((c) => c.length === 0)) break;
+    const last = rest.map((c) => c[c.length - 1]);
+    if (last.every((r) => same(r, last[0]))) {
+      hoisted.unshift(last[0]);
+      for (const c of rest) c.pop();
+      continue;
+    }
+    // Trailing translations that DISAGREE still share a common part, and splitting it
+    // out is what the grid case needs: a cell's hub ends .at([cx,cy,0]) while its
+    // support ends .at([cx,cy,z]), so exact matching alone would hoist nothing.
+    // Translations commute, so translate(vᵢ) = translate(v₀) ∘ translate(vᵢ−v₀), and
+    // subtracting shared coordinates is exact. Splitting leaves a translate behind on
+    // every other operand, so nothing deeper can match — this always ends the loop.
+    if (!last.every((r) => r.op === "translate")) break;
+    const v0 = last[0].v;
+    for (const [i, c] of rest.entries()) {
+      const d = [last[i].v[0] - v0[0], last[i].v[1] - v0[1], last[i].v[2] - v0[2]];
+      c.pop();
+      if (d[0] !== 0 || d[1] !== 0 || d[2] !== 0) c.push({ op: "translate", v: d });
+    }
+    hoisted.unshift({ op: "translate", v: v0 });
+    break;
+  }
+  return { hoisted, residuals: rest };
+}

package/src/framework/jobs.js

@@ -130,6 +130,13 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       const t0 = Date.now();
       const useCache = msg.cache !== false; // ?debug toggle can disable caching (cache:false)
       const meshes = [];
+      // Feature-skip warnings (a fillet/chamfer the geometry defeated — see the
+      // backends' takeBuildWarnings): drained per sub-part below so each message
+      // names the sub-part whose build recorded it, and drained-and-discarded here
+      // first so a previous job's stragglers (an oracle build, an export) cannot be
+      // misattributed to this build's first sub-part.
+      kernel.takeBuildWarnings?.();
+      const warnings = [];
       kernel.resetCacheStats?.(); // count hits/misses for just this job
       for (const [i, name] of msg.subparts.entries()) {
         if (useCache) kernel.beginSubPart?.(name); // open the per-sub-part cache round
@@ -137,6 +144,7 @@ export async function handle(kernel, part, msg, post, opts = {}) {
           const m = posed(name, "display").toMesh({ quality: "preview" });
           meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features });
         } finally {
+          for (const message of kernel.takeBuildWarnings?.() ?? []) warnings.push({ part: name, message });
           if (useCache) kernel.endSubPart?.(); // always close the bracket — a throw mid-build must not strand pinned solids
           kernel.cleanup?.();                  // free this round's transients (cached/pinned solids survive)
         }
@@ -152,7 +160,8 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       }
       const transfer = meshes.flatMap((m) =>
         [m.positions.buffer, m.normals?.buffer, m.indices?.buffer, m.edges?.buffer, m.featureIds?.buffer].filter(Boolean));
-      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.() }, transfer);
+      post({ type: "meshes", meshes, ms: Date.now() - t0, cache: kernel.cacheStats?.(),
+             ...(warnings.length ? { warnings } : {}) }, transfer);
     } else if (msg.type === "capture-generate") {
       // A private, job-correlated one-shot channel for captureView — builds a
       // (possibly non-active) view's meshes off the regen loop, so it can never
@@ -161,19 +170,23 @@ export async function handle(kernel, part, msg, post, opts = {}) {
       // isStale/superseded polling — there's nothing to supersede a one-shot.
       const useCache = msg.cache !== false;
       const meshes = [];
+      kernel.takeBuildWarnings?.(); // discard a previous job's stragglers (same as generate)
+      const warnings = [];
       for (const name of msg.subparts) {
         if (useCache) kernel.beginSubPart?.(name);
         try {
           const m = posed(name, "display").toMesh({ quality: "preview" });
           meshes.push({ name, positions: m.positions, normals: m.normals, indices: m.indices, triangles: m.triangles, edges: m.edges, featureIds: m.featureIds, features: m.features });
         } finally {
+          for (const message of kernel.takeBuildWarnings?.() ?? []) warnings.push({ part: name, message });
           if (useCache) kernel.endSubPart?.();
           kernel.cleanup?.();
         }
       }
       const captureTransfer = meshes.flatMap((m) =>
         [m.positions.buffer, m.normals?.buffer, m.indices?.buffer, m.edges?.buffer, m.featureIds?.buffer].filter(Boolean));
-      post({ type: "capture-meshes", jobId: msg.jobId, meshes }, captureTransfer);
+      post({ type: "capture-meshes", jobId: msg.jobId, meshes,
+             ...(warnings.length ? { warnings } : {}) }, captureTransfer);
     } else if (msg.type === "export-stl") {
       const names = selected();
       if (names.length === 0) throw new Error("no exportable parts selected");

package/types/kernel.d.ts

@@ -498,4 +498,10 @@ export interface GeometryKernel {
   resetCacheStats?(): void;
   /** Free per-job WASM objects (Manifold backend); call after each job. */
   cleanup?(): void;
+  /**
+   * Drain the feature-skip warnings recorded since the last drain — one message
+   * per fillet/chamfer (or roundAll) the backend skipped instead of failing the
+   * build over. Drain per sub-part to attribute each message to its build.
+   */
+  takeBuildWarnings?(): string[];
 }