@rig-c/core 2.82.1 → 2.83.0

package/docs/MOTION.md

@@ -818,20 +818,22 @@ rigc pose
                    found on a 20x25 anchor grid, step 4 at 2x reduction
   PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.3°  scale=0.955  residual=0.0135  unexplained=  0%
                    found on a 40x50 anchor grid, step 2 at 2x reduction
-  AMBIG  post.png  x=   79.9  y=  149.0  rot=   -0.1°  scale=0.971  residual=0.0593  unexplained= 16%
+  AMBIG  post.png  x=   80.0  y=  148.6  rot=   -0.1°  scale=0.982  residual=0.0587  unexplained= 16%
                    found on a 14x17 anchor grid, step 6 at 2x reduction
-                   alt 2: x=   79.0  y=  141.7  rot=   -0.5°  scale=0.691  residual=0.0687  unexplained= 25%
-                   ambiguous: part is 14x96 px (span 93.2 frame px, opaque 1) with texture 0.0146, detail 1.406; 43 candidate(s), best 0.0593, next 0.0687, spread 0.0095 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; either the frame holds more than one place this part fits, or every candidate missed the true one — a narrower --scale or --rotation window around what you know of the part tells the two apart
+                   alt 2: x=   78.7  y=  164.0  rot=   -0.6°  scale=0.573  residual=0.0612  unexplained= 19%
+                   alt 3: x=   79.0  y=  141.7  rot=   -0.5°  scale=0.691  residual=0.0687  unexplained= 25%
+                   alt 4: x=   78.4  y=  135.5  rot=   -0.5°  scale=0.500  residual=0.0702  unexplained= 23%
+                   ambiguous: part is 14x96 px (span 94.3 frame px, opaque 1) with texture 0.0146, detail 1.406; 50 candidate(s), best 0.0587, next 0.0612, spread 0.0025 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; either the frame holds more than one place this part fits, or every candidate missed the true one — a narrower --scale or --rotation window around what you know of the part tells the two apart
 ```
 
-⚠️ **The post came back `AMBIG`: a best at scale 0.971 and an alternate at 0.691, 7.3 px
-higher, trailing it by a spread of 0.0095.** That is §2.2's caveat in the open. The post
+⚠️ **The post came back `AMBIG`: a best at scale 0.982 and its next alternate at 0.573,
+15.4 px lower, trailing it by a spread of 0.0025.** That is §2.2's caveat in the open. The post
 is a long part with most of its area in one colour, so a shrunken copy sitting inside the
 real post explains those pixels nearly as well, and the report's own `ambiguous:` line
 says size and texture do not account for how close the two come. The report cannot say
-which one is true, and it says so: it names both and asks for a narrower window. The
+which one is true, and it says so: it names the alternatives and asks for a narrower window. The
 picture can. The arm and the flag read 0.970 and 0.955, so the picture is at the art's
-own resolution, and a post at 0.69 would be drawn at about 0.7 of the size of everything
+own resolution, and a post at 0.573 would be drawn at about 0.6 of the size of everything
 bolted to it. ⇒ Narrow, and say so:
 
 ```bash
@@ -861,12 +863,19 @@ rigc pose
   ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
   PLACE  arm.png   x=  102.5  y=   94.8  rot=  -18.3°  scale=0.974  residual=0.0305  unexplained=  4%
                    found on a 20x25 anchor grid, step 4 at 2x reduction
-  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.6°  scale=0.956  residual=0.0134  unexplained=  0%
+  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.4°  scale=0.958  residual=0.0134  unexplained=  0%
                    found on a 40x50 anchor grid, step 2 at 2x reduction
   PLACE  post.png  x=   80.0  y=  148.0  rot=    0.0°  scale=0.995  residual=0.0394  unexplained=  9%
                    found on a 14x17 anchor grid, step 6 at 2x reduction
 ```
 
+The worked derivation and recipe below keep their recorded rounded authoring inputs:
+pose A as printed here, and pose B with the flag at screen rotation −6.6° and scale
+0.956. The current rerun above reads −6.4° and 0.958 for that flag. The 0.2° rotation
+and 0.002 scale differences are changes in the estimator's reading; the fixed inputs
+used to derive this worked rig and its motion are stated here so that the recipe does
+not silently change with a rerun.
+
 Three things to read out of that pair, none of which is a score:
 
 - **Scale.** All six readings sit in 0.956–0.995, a spread of about 4 %. The one part
@@ -887,7 +896,8 @@ Three things to read out of that pair, none of which is a score:
 
 ### 3. Convert, and derive the rig
 
-`cropToSpineY(y, 200) = 200 − y` and `screenToSpineDegrees(d) = −d`, both from
+For those recorded authoring inputs, `cropToSpineY(y, 200) = 200 − y` and
+`screenToSpineDegrees(d) = −d`, both from
 [`src/transform.ts`](../src/transform.ts) (§2.2 — do not open-code either):
 
 | | pose A, Spine world | pose B, Spine world |
@@ -1042,8 +1052,8 @@ which is which is worth being able to point at:
 
 | Key | Where it came from |
 | --- | --- |
-| arm `t: 0` = −61.9, flag `t: 0` = −22.2 | **given** — pose A, converted. Untouched, per §3.6 |
-| arm `t: 0.55` = 18.3, flag `t: 0.55` = −11.7 | **given** — pose B. The flag's is `6.6 − 18.3`: both world rotations converted first, then differenced, because a child's track carries a **local** rotation under a rotated parent |
+| arm `t: 0` = −61.9, flag `t: 0` = −22.2 | **given** — the recorded pose A reading, converted. Untouched, per §3.6 |
+| arm `t: 0.55` = 18.3, flag `t: 0.55` = −11.7 | **given** — the recorded pose B reading. The flag's is `6.6 − 18.3`: both world rotations converted first, then differenced, because a child's track carries a **local** rotation under a rotated parent |
 | arm `t: 0.07` = −66.4 | §3.6 — 4.5° against an 80° excursion (5.6 %), at 13 % of the duration |
 | arm `t: 0.32` = 24.7 | §3.8 — 6.4° past the end value (8 %), at 58 % of the duration |
 | flag `t: 0.09`, `t: 0.47` | §3.7 — the flag's extreme lands at 85 % of the duration against the arm's 58 %, an offset of **+27 %**, the middle of its row's band, and it drags the other way first. Not the top of the band: at 35 % (`t: 0.51`) the crossing and the settle below would share 0.04 s, and the 24 fps render would still show the flag at its extreme one frame before the last |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.82.1",
+  "version": "2.83.0",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/cli/shared.ts

@@ -1070,10 +1070,10 @@ const FLAG_MEANINGS: Record<string, string> = {
   extremes: 'also write extremes.json and a native six-panel extremes.png per set: setup, geometry-pair min/max and premultiplied RGBA diffs, with a legend. Per-channel extrema are recorded separately and valid channels survive geometry/image SKIPs; channel refusals are named separately. Still geometry reports SKIP; a reading, not a gate. Attachment identity/count changes record a named SKIP without changing render exit; supports --slot/--hide on both posers',
   seam:
     `also read, for each <slot>:<slot> pair, where the two drawings stop meeting, and write ${SEAM_FILE} into each frame directory: ` +
-    'per pair, the frames with a gap — background inside the hull of the band the two drawings share at the setup pose, carried to the frame by both — ' +
-    'and the frames with a ghost — the band of one drawing showing where, from its partner\'s point of view, nothing was drawn at the setup pose — each with ' +
+    'per pair, the frames with a gap — background inside the carried overlap hull and a local sweep of the same setup band cell through both drawings — ' +
+    'and the frames with a visible ghost after draw order — the band of one drawing showing where, from its partner\'s point of view, nothing was drawn at the setup pose — each with ' +
     `its cell count, area and world box. Cells are one texel of the coarser drawing, drawn at ${DRAWN_ALPHA} of 255 or more. One line per pair; a pair whose ` +
-    'drawings share no cell at the setup pose is a SKIP. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
+    'drawings share no cell at the setup pose is a SKIP. exposureA/B count each named slot’s positive-alpha cells on otherwise empty skeleton background, even without a band or partner. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
     'a slot that draws on no frame, a malformed list and a pair named twice in either order are refused by name. Not with --slot/--hide',
   'angle-range':
     'also read, for each <bone>:<relative-to> pair, the range of the first bone\'s world direction against the second\'s over each set\'s ' +
@@ -1762,7 +1762,7 @@ export const COMMANDS: CommandDoc[] = [
       'rigc render … --slot <name[,name…]> | --hide <name[,name…]>   (a subset of the slots, on the whole rig\'s grid)',
       'rigc render … --environment <schedule.json>   (the wind and gravity the physics answers, in time)',
       'rigc render … --pass-through <cloth>:<leg>[,…]   (the frames where a cloth drawn over a leg passes through it)',
-      'rigc render … --seam <slot>:<slot>[,…]   (the frames where two slots that meet open a gap or show a ghost)',
+      'rigc render … --seam <slot>:<slot>[,…]   (joint gaps, visible ghosts and each named slot’s background exposure)',
       'rigc render … --overlaps   (which slot each frame drew over which, by name, with an outline plate)',
       'rigc render … --angle-range <bone>:<relative-to>[,…]   (how far a bone turns against another, per animation)',
       'rigc render … --viewport <x,y,w,h> | --viewport-from <frames.json>   (a box given, not fitted: two renders on one pixel grid)',

package/src/pose.ts

@@ -835,6 +835,8 @@ export interface PoseOptions {
    * stride fraction in force in `search.coarse.strideFraction`.
    */
   coarseGrid?: PoseCoarseGrid;
+  /** Historical-search control for instruments; the CLI uses short-support coverage. */
+  coarsePolicy?: 'legacy-only' | 'short-support';
 }
 
 /** A search candidate as the trace states it: where the part image's centre would land, frame pixels. */
@@ -900,6 +902,8 @@ export interface PoseTrace {
   levels: PoseTraceLevel[];
   /** Per part, every candidate that reached the report, with its every-pixel residual, best first. */
   measured: { part: string; candidates: PoseTraceCandidate[] }[];
+  /** The independent coverage lane; `levels` retains the original lane's pyramid. */
+  supplemental?: { part: string; levels: PoseTraceLevel[] }[];
 }
 
 // ---------------------------------------------------------------------------
@@ -1388,8 +1392,15 @@ function coarseCellResidual(level: Level, s: Samples, scale: number, rotDeg: num
  * exactly two such cells — and the accepted list then keeps them apart so the
  * refinement budget is not spent twice on one hill.
  */
-function localMinima(field: CoarseField, radius: number, keep: number): Candidate[] {
-  const found: Candidate[] = [];
+export function poseCoarseMinima(
+  field: CoarseField,
+  radius: number,
+  keep: number,
+  support = Infinity,
+  covered: readonly Candidate[] = [],
+  observation?: { accepted: number; covered: number; spacingChecks?: number },
+): Candidate[] {
+  const found: { candidate: Candidate; gx: number; gy: number }[] = [];
   for (let gy = 0; gy < field.rows; gy++) {
     for (let gx = 0; gx < field.cols; gx++) {
       const here = field.residual[gy * field.cols + gx];
@@ -1400,7 +1411,7 @@ function localMinima(field: CoarseField, radius: number, keep: number): Candidat
           const nx = gx + dx;
           const ny = gy + dy;
           if (nx < 0 || ny < 0 || nx >= field.cols || ny >= field.rows) continue;
-          if (field.residual[ny * field.cols + nx] < here) {
+          if (hypot2(dx * field.stride, dy * field.stride) <= support && field.residual[ny * field.cols + nx] < here) {
             minimal = false;
             break;
           }
@@ -1408,23 +1419,45 @@ function localMinima(field: CoarseField, radius: number, keep: number): Candidat
       }
       if (!minimal) continue;
       const cell = gy * field.cols + gx;
-      found.push({
+      found.push({ gx, gy, candidate: {
         cx: gx * field.stride + field.stride / 2,
         cy: gy * field.stride + field.stride / 2,
         rotDeg: field.rotDeg[cell],
         scale: field.scale,
         residual: here,
-      });
+      } });
     }
   }
-  found.sort((a, b) => a.residual - b.residual);
-  const accepted: Candidate[] = [];
-  for (const cand of found) {
-    if (accepted.length >= keep) break;
-    if (accepted.some((a) => hypot2(a.cx - cand.cx, a.cy - cand.cy) <= radius * field.stride)) continue;
-    accepted.push(cand);
+  found.sort((a, b) => a.candidate.residual - b.candidate.residual);
+  const spacing = Math.min(radius * field.stride, support);
+  const gridRadius = spacing / field.stride;
+  const bucketSpan = Math.max(1, Math.floor(gridRadius));
+  const reach = Math.ceil(gridRadius / bucketSpan);
+  const accepted = new Map<string, Candidate[]>();
+  const novel: Candidate[] = [];
+  for (const entry of found) {
+    if (novel.length >= keep) break;
+    const cand = entry.candidate;
+    const bx = Math.floor(entry.gx / bucketSpan), by = Math.floor(entry.gy / bucketSpan);
+    let overlaps = false;
+    for (let y = by - reach; y <= by + reach && !overlaps; y++) {
+      for (let x = bx - reach; x <= bx + reach && !overlaps; x++) {
+        for (const a of accepted.get(`${x}:${y}`) ?? []) {
+          if (observation !== undefined) observation.spacingChecks = (observation.spacingChecks ?? 0) + 1;
+          if (hypot2(a.cx - cand.cx, a.cy - cand.cy) <= spacing) { overlaps = true; break; }
+        }
+      }
+    }
+    if (overlaps) continue;
+    const key = `${bx}:${by}`, bucket = accepted.get(key) ?? [];
+    bucket.push(cand);
+    accepted.set(key, bucket);
+    if (observation !== undefined) observation.accepted++;
+    if (covered.some((b) => hypot2(cand.cx - b.cx, cand.cy - b.cy) <= support)) {
+      if (observation !== undefined) observation.covered++;
+    } else novel.push(cand);
   }
-  return accepted;
+  return novel;
 }
 
 /**
@@ -1859,6 +1892,9 @@ export function partFiles(imagesDir: string, exclude: string): string[] {
 // ---------------------------------------------------------------------------
 
 export function estimatePose(options: PoseOptions): PoseReport {
+  if (options.coarsePolicy !== undefined && options.coarsePolicy !== 'legacy-only' && options.coarsePolicy !== 'short-support') {
+    throw new PoseError(`coarsePolicy ${JSON.stringify(options.coarsePolicy)}: expected "short-support" or "legacy-only" — omit it for the current search`);
+  }
   const framePath = resolve(options.framePath);
   if (!existsSync(framePath)) throw new PoseError(`no pose frame at ${framePath}`);
   let frame: Plate;
@@ -1959,6 +1995,7 @@ export function estimatePose(options: PoseOptions): PoseReport {
         { min: scaleMin, max: scaleMax },
         rotationBounds,
         options.coarseGrid ?? COARSE_GRID,
+        options.coarsePolicy ?? 'short-support',
         options.trace,
       ),
     );
@@ -1977,6 +2014,7 @@ function placePart(
   scaleBounds: { min: number; max: number },
   rotationBounds: { min: number; max: number; wraps: boolean },
   coarseGrid: PoseCoarseGrid,
+  coarsePolicy: 'legacy-only' | 'short-support',
   trace?: PoseTrace,
 ): PosePart {
   const scaleMin = scaleBounds.min;
@@ -2114,11 +2152,23 @@ function placePart(
   const stride = Math.max(1, Math.round(spanAtCoarse * coarseGrid.strideFraction));
   const coarseSamples = samplesFor(coarse.reduction, COARSE_SAMPLES);
   let candidates: Candidate[] = [];
+  const supplementalSeeds: Candidate[] = [];
   let grid = { reduction: coarse.reduction, cols: 0, rows: 0, stride };
   for (const scale of scales) {
     const field = coarseScan(coarse, coarseSamples, scale, searchRotations, stride);
     grid = { reduction: coarse.reduction, cols: field.cols, rows: field.rows, stride };
-    candidates.push(...localMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale));
+    const legacy = poseCoarseMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale);
+    candidates.push(...legacy);
+    if (coarsePolicy === 'short-support') {
+      // An isotropic half-LONG-span neighborhood can suppress another position
+      // along a thin part. Its inscribed material disk supplies a rotation-free
+      // bound, in level pixels, derived from the actual rung scale (issue #1649).
+      const support = thickness * scale / (2 * coarse.reduction);
+      const extra = poseCoarseMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale, support, legacy);
+      // Charge the independent budget AFTER excluding already represented
+      // positions; charging it first spends its slots on seeds then discarded.
+      supplementalSeeds.push(...extra);
+    }
   }
   base.coarse = grid;
   candidates.sort((a, b) => a.residual - b.residual);
@@ -2140,147 +2190,159 @@ function placePart(
   // that arm is one half of the two-identical-limbs answer the whole instrument
   // exists to report. Re-gridding the ladder at the first level with real detail
   // brought it back at +35.
-  const branchLevel = Math.max(0, coarseIndex - 1);
-  /** How many rotations survive the re-grid at the branch level, per position. */
-  const BRANCH_ROTATIONS = 3;
-  let rotStep = rotationFree ? 0 : COARSE_ROTATION_STEP / 2;
-  for (let li = coarseIndex; li >= 0; li--) {
-    const level = levels[li];
-    const plate = plates[li];
-    const smooth = li !== coarseIndex;
-    const branch = li === branchLevel;
-    const keep = li === coarseIndex ? scales.length * coarseGrid.minimaPerScale : REFINE_CANDIDATES;
-    const s = samplesFor(level.reduction, li === 0 ? POLISH_SAMPLES : REFINE_SAMPLES);
-    // The coarse pass only sampled every `stride` pixels, so entering the
-    // refinement the anchor can be half a stride out; the first polish gets a
-    // step big enough to cross that rather than a step that assumes a pixel.
-    const step = { translate: li === coarseIndex ? Math.max(1.5, stride) : 1.5, rotate: rotStep, scale: 0.08 };
-    const floor =
-      li === 0 ? { translate: 0.05, rotate: 0.1, scale: 0.001 } : { translate: 0.25, rotate: 0.5, scale: 0.01 };
-    const seeds: Candidate[] = [];
-    for (const start of candidates.slice(0, keep)) {
-      if (branch && !rotationFree) {
-        const grid: Candidate[] = [];
-        for (const rotDeg of searchRotations) {
-          const probe: Candidate = { ...start, rotDeg, residual: 0 };
-          probe.residual = residualAt(level, plate, s, probe, smooth);
-          grid.push(probe);
+  const refineLane = (initial: Candidate[], supplemental = false, levelTrace?: PoseTraceLevel[]): Candidate[] => {
+    let candidates = initial;
+    const branchLevel = Math.max(0, coarseIndex - 1);
+    /** How many rotations survive the re-grid at the branch level, per position. */
+    const BRANCH_ROTATIONS = 3;
+    let rotStep = rotationFree ? 0 : COARSE_ROTATION_STEP / 2;
+    for (let li = coarseIndex; li >= 0; li--) {
+      const level = levels[li];
+      const plate = plates[li];
+      const smooth = li !== coarseIndex;
+      const branch = li === branchLevel;
+      // Coarse scale scores are not comparable. Give the coverage pool its
+      // first detailed/rotation-regridded reading before ranking scales together.
+      const keep = li === coarseIndex || (supplemental && li === branchLevel) ? scales.length * coarseGrid.minimaPerScale : REFINE_CANDIDATES;
+      const s = samplesFor(level.reduction, li === 0 ? POLISH_SAMPLES : REFINE_SAMPLES);
+      // The coarse pass only sampled every `stride` pixels, so entering the
+      // refinement the anchor can be half a stride out; the first polish gets a
+      // step big enough to cross that rather than a step that assumes a pixel.
+      const step = { translate: li === coarseIndex ? Math.max(1.5, stride) : 1.5, rotate: rotStep, scale: 0.08 };
+      const floor =
+        li === 0 ? { translate: 0.05, rotate: 0.1, scale: 0.001 } : { translate: 0.25, rotate: 0.5, scale: 0.01 };
+      const seeds: Candidate[] = [];
+      for (const start of candidates.slice(0, keep)) {
+        if (branch && !rotationFree) {
+          const grid: Candidate[] = [];
+          for (const rotDeg of searchRotations) {
+            const probe: Candidate = { ...start, rotDeg, residual: 0 };
+            probe.residual = residualAt(level, plate, s, probe, smooth);
+            grid.push(probe);
+          }
+          grid.sort((a, b) => a.residual - b.residual);
+          // One position and one scale throughout, so this dedupe is a spread over
+          // rotation alone: an angle within 25 degrees of one already kept is the
+          // same basin under a slightly different name.
+          seeds.push(...dedupe(grid, 1, 25, Infinity).slice(0, BRANCH_ROTATIONS));
+          continue;
         }
-        grid.sort((a, b) => a.residual - b.residual);
-        // One position and one scale throughout, so this dedupe is a spread over
-        // rotation alone: an angle within 25 degrees of one already kept is the
-        // same basin under a slightly different name.
-        seeds.push(...dedupe(grid, 1, 25, Infinity).slice(0, BRANCH_ROTATIONS));
-        continue;
+        seeds.push(start);
       }
-      seeds.push(start);
-    }
-    const paths = seeds.map((): { start: number; steps: PoseTraceStep[] } => ({ start: 0, steps: [] }));
-    candidates = seeds.map((seed, i) =>
-      polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? POLISH_SCALE_ESCAPES : [], trace === undefined ? undefined : paths[i]),
-    );
-    const polished = candidates.slice();
-    candidates.sort((a, b) => a.residual - b.residual);
-    // ⚠️ Eight branches that walked to one optimum are one candidate, not eight —
-    // and the radius has to scale with the PART rather than be a pixel count.
-    // Narrowing by residual alone lets near-copies of the best hill fill the
-    // budget and crowd the SECOND hill out, which is exactly the answer this
-    // instrument exists to keep: with a fixed one-pixel radius the fixture lost
-    // one of its two identical arms.
-    candidates = dedupe(candidates, Math.max(1, (0.2 * span * scaleReference) / level.reduction), 5, 1.03);
-    if (trace !== undefined) {
-      const ou = part.width / 2 - anchorX;
-      const ov = part.height / 2 - anchorY;
-      const said = (c: Candidate): PoseTraceCandidate => {
-        const cos = Math.cos(c.rotDeg * DEG) * c.scale;
-        const sin = Math.sin(c.rotDeg * DEG) * c.scale;
-        return {
-          x: c.cx * level.reduction + ou * cos - ov * sin,
-          y: c.cy * level.reduction + ou * sin + ov * cos,
-          rotationDeg: normaliseDegrees(c.rotDeg),
-          scale: c.scale,
-          residual: c.residual,
-        };
-      };
-      let probeResidual: number | null = null;
-      if (trace.probe !== undefined) {
-        const q = trace.probe;
-        const cos = Math.cos(q.rotationDeg * DEG) * q.scale;
-        const sin = Math.sin(q.rotationDeg * DEG) * q.scale;
-        const at: Candidate = {
-          cx: (q.x - (ou * cos - ov * sin)) / level.reduction,
-          cy: (q.y - (ou * sin + ov * cos)) / level.reduction,
-          rotDeg: q.rotationDeg,
-          scale: q.scale,
-          residual: 0,
+      const paths = seeds.map((): { start: number; steps: PoseTraceStep[] } => ({ start: 0, steps: [] }));
+      candidates = seeds.map((seed, i) =>
+        polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? POLISH_SCALE_ESCAPES : [], trace === undefined ? undefined : paths[i]),
+      );
+      const polished = candidates.slice();
+      candidates.sort((a, b) => a.residual - b.residual);
+      // ⚠️ Eight branches that walked to one optimum are one candidate, not eight —
+      // and the radius has to scale with the PART rather than be a pixel count.
+      // Narrowing by residual alone lets near-copies of the best hill fill the
+      // budget and crowd the SECOND hill out, which is exactly the answer this
+      // instrument exists to keep: with a fixed one-pixel radius the fixture lost
+      // one of its two identical arms.
+      candidates = dedupe(candidates, Math.max(1, (0.2 * span * scaleReference) / level.reduction), 5, 1.03);
+      if (trace !== undefined && levelTrace !== undefined) {
+        const ou = part.width / 2 - anchorX;
+        const ov = part.height / 2 - anchorY;
+        const said = (c: Candidate): PoseTraceCandidate => {
+          const cos = Math.cos(c.rotDeg * DEG) * c.scale;
+          const sin = Math.sin(c.rotDeg * DEG) * c.scale;
+          return {
+            x: c.cx * level.reduction + ou * cos - ov * sin,
+            y: c.cy * level.reduction + ou * sin + ov * cos,
+            rotationDeg: normaliseDegrees(c.rotDeg),
+            scale: c.scale,
+            residual: c.residual,
+          };
         };
-        probeResidual = residualAt(level, plate, s, at, smooth);
+        let probeResidual: number | null = null;
+        if (trace.probe !== undefined) {
+          const q = trace.probe;
+          const cos = Math.cos(q.rotationDeg * DEG) * q.scale;
+          const sin = Math.sin(q.rotationDeg * DEG) * q.scale;
+          const at: Candidate = {
+            cx: (q.x - (ou * cos - ov * sin)) / level.reduction,
+            cy: (q.y - (ou * sin + ov * cos)) / level.reduction,
+            rotDeg: q.rotationDeg,
+            scale: q.scale,
+            residual: 0,
+          };
+          probeResidual = residualAt(level, plate, s, at, smooth);
+        }
+        levelTrace.push({
+          part: name,
+          level: li,
+          reduction: level.reduction,
+          keep,
+          seeds: seeds.map(said),
+          starts: paths.map((p) => p.start),
+          paths: paths.map((p) => p.steps),
+          polished: polished.map(said),
+          out: candidates.map(said),
+          probeResidual,
+          coarseRotations:
+            li === coarseIndex
+              ? {
+                  ladder: searchRotations.slice(),
+                  residuals: seeds.map((seed) =>
+                    searchRotations.map((rotDeg) => coarseCellResidual(level, coarseSamples, seed.scale, rotDeg, seed.cx, seed.cy)),
+                  ),
+                }
+              : null,
+        });
+      }
+      if (li > 0) {
+        candidates = candidates.map((c) => ({ ...c, cx: c.cx * 2, cy: c.cy * 2 }));
+        // A rotation-free part keeps its step at zero all the way down, so the
+        // polish never touches an angle that means nothing and the report's 0° is
+        // the placeholder it says it is rather than a wandered-to number.
+        if (!rotationFree) rotStep = Math.max(1, rotStep / 2);
       }
-      trace.levels.push({
-        part: name,
-        level: li,
-        reduction: level.reduction,
-        keep,
-        seeds: seeds.map(said),
-        starts: paths.map((p) => p.start),
-        paths: paths.map((p) => p.steps),
-        polished: polished.map(said),
-        out: candidates.map(said),
-        probeResidual,
-        coarseRotations:
-          li === coarseIndex
-            ? {
-                ladder: searchRotations.slice(),
-                residuals: seeds.map((seed) =>
-                  searchRotations.map((rotDeg) => coarseCellResidual(level, coarseSamples, seed.scale, rotDeg, seed.cx, seed.cy)),
-                ),
-              }
-            : null,
-      });
-    }
-    if (li > 0) {
-      candidates = candidates.map((c) => ({ ...c, cx: c.cx * 2, cy: c.cy * 2 }));
-      // A rotation-free part keeps its step at zero all the way down, so the
-      // polish never touches an angle that means nothing and the report's 0° is
-      // the placeholder it says it is rather than a wandered-to number.
-      if (!rotationFree) rotStep = Math.max(1, rotStep / 2);
     }
-  }
 
-  // The one rotation family the translation scan cannot see: a part that is its
-  // own mirror after a quarter or a half turn sits in the SAME place at more than
-  // one angle, so the field records only whichever won. Probe them explicitly.
-  //
-  // 🚨 Only the turns the window contains, and this is the other half of #719's
-  // measurement. A quarter turn off is a SEED, not a ladder rung — so under
-  // `--rotation -5,5` it entered the answer from outside a window the report was
-  // calling the search, and the candidate who ran the exam read `rot=91.2°`
-  // under `rotation -5°–5°`. A caller who bounds the rotation has said the part
-  // is not a quarter turn over; the honest response is not to look there rather
-  // than to look and report it.
-  if (!rotationFree && candidates.length > 0) {
-    const primary = candidates[0];
-    const s = samplesFor(1, POLISH_SAMPLES);
-    for (const turn of [90, 180, 270]) {
-      const turned = primary.rotDeg + turn;
-      if (!rotationBounds.wraps && (turned < rotationBounds.min - 1e-9 || turned > rotationBounds.max + 1e-9)) continue;
-      candidates.push(
-        polish(
-          levels[0],
-          plates[0],
-          s,
-          { ...primary, rotDeg: turned },
-          { translate: 1.5, rotate: 4, scale: 0.04 },
-          { translate: 0.05, rotate: 0.1, scale: 0.001 },
-          true,
-          scaleBounds,
-          rotationBounds,
-          [],
-        ),
-      );
+    // The one rotation family the translation scan cannot see: a part that is its
+    // own mirror after a quarter or a half turn sits in the SAME place at more than
+    // one angle, so the field records only whichever won. Probe them explicitly.
+    //
+    // 🚨 Only the turns the window contains, and this is the other half of #719's
+    // measurement. A quarter turn off is a SEED, not a ladder rung — so under
+    // `--rotation -5,5` it entered the answer from outside a window the report was
+    // calling the search, and the candidate who ran the exam read `rot=91.2°`
+    // under `rotation -5°–5°`. A caller who bounds the rotation has said the part
+    // is not a quarter turn over; the honest response is not to look there rather
+    // than to look and report it.
+    if (!rotationFree && candidates.length > 0) {
+      const primary = candidates[0];
+      const s = samplesFor(1, POLISH_SAMPLES);
+      for (const turn of [90, 180, 270]) {
+        const turned = primary.rotDeg + turn;
+        if (!rotationBounds.wraps && (turned < rotationBounds.min - 1e-9 || turned > rotationBounds.max + 1e-9)) continue;
+        candidates.push(
+          polish(
+            levels[0],
+            plates[0],
+            s,
+            { ...primary, rotDeg: turned },
+            { translate: 1.5, rotate: 4, scale: 0.04 },
+            { translate: 0.05, rotate: 0.1, scale: 0.001 },
+            true,
+            scaleBounds,
+            rotationBounds,
+            [],
+          ),
+        );
+      }
+      candidates.sort((a, b) => a.residual - b.residual);
     }
-    candidates.sort((a, b) => a.residual - b.residual);
-  }
+
+    return candidates;
+  };
+  const baselineCandidates = refineLane(candidates, false, trace?.levels);
+  supplementalSeeds.sort((a, b) => a.residual - b.residual);
+  const extraTrace: PoseTraceLevel[] | undefined = trace === undefined ? undefined : [];
+  if (trace !== undefined && extraTrace !== undefined) (trace.supplemental ??= []).push({ part: name, levels: extraTrace });
+  candidates = [...baselineCandidates, ...refineLane(supplementalSeeds, true, extraTrace)];
 
   // Measured at full resolution over every pixel, then de-duplicated: two
   // candidates that walked to the same optimum are one answer, not two.