spine-rigc 2.20.1 → 2.20.2

package/package.json

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

package/src/mesh.ts

@@ -1319,23 +1319,60 @@ export function rasteriseTriangles(points: Array<[number, number]>, triangles: n
     const a = points[triangles[t]];
     const b = points[triangles[t + 1]];
     const c = points[triangles[t + 2]];
-    const twice = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
-    if (Math.abs(twice) < 1e-12) continue;
-    const orient = twice > 0 ? 1 : -1;
-    const minX = Math.max(0, Math.floor(Math.min(a[0], b[0], c[0]) - 1));
-    const maxX = Math.min(w - 1, Math.ceil(Math.max(a[0], b[0], c[0]) + 1));
-    const minY = Math.max(0, Math.floor(Math.min(a[1], b[1], c[1]) - 1));
-    const maxY = Math.min(h - 1, Math.ceil(Math.max(a[1], b[1], c[1]) + 1));
-    for (let y = minY; y <= maxY; y++) {
-      for (let x = minX; x <= maxX; x++) {
+    const box = triangleRasterBox(a, b, c, w, h);
+    if (box === null) continue;
+    for (let y = box.minY; y <= box.maxY; y++) {
+      for (let x = box.minX; x <= box.maxX; x++) {
         if (covered[y * w + x]) continue;
-        if (pointInTriangle([x + 0.5, y + 0.5], a, b, c, orient)) covered[y * w + x] = 1;
+        if (pixelCentreInTriangle(x, y, a, b, c, box.orient)) covered[y * w + x] = 1;
       }
     }
   }
   return covered;
 }
 
+/**
+ * The pixels of a `w`x`h` grid one triangle can cover under `rasteriseTriangles`'s
+ * rule — the box of its corners widened by a pixel and clamped to the grid —
+ * and the orientation its centre test reads; null for a degenerate triangle
+ * (zero doubled area), which covers nothing. `rasteriseTriangles` and the
+ * per-step coverage of `src/meshrasters.ts` both read the rule from here and
+ * from `pixelCentreInTriangle`, so the two cannot drift apart.
+ */
+export function triangleRasterBox(
+  a: readonly [number, number],
+  b: readonly [number, number],
+  c: readonly [number, number],
+  w: number,
+  h: number,
+): { orient: number; minX: number; maxX: number; minY: number; maxY: number } | null {
+  const twice = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  if (Math.abs(twice) < 1e-12) return null;
+  return {
+    orient: twice > 0 ? 1 : -1,
+    minX: Math.max(0, Math.floor(Math.min(a[0], b[0], c[0]) - 1)),
+    maxX: Math.min(w - 1, Math.ceil(Math.max(a[0], b[0], c[0]) + 1)),
+    minY: Math.max(0, Math.floor(Math.min(a[1], b[1], c[1]) - 1)),
+    maxY: Math.min(h - 1, Math.ceil(Math.max(a[1], b[1], c[1]) + 1)),
+  };
+}
+
+/**
+ * Is the centre of pixel (`x`, `y`) in or on the triangle — `rasteriseTriangles`'s
+ * test, with the orientation `triangleRasterBox` gave. `pointInTriangle` at
+ * `[x + 0.5, y + 0.5]`, written out without the point array: the same three
+ * products, in the same order, against the same tolerance.
+ */
+export function pixelCentreInTriangle(x: number, y: number, a: readonly [number, number], b: readonly [number, number], c: readonly [number, number], orient: number): boolean {
+  const px = x + 0.5;
+  const py = y + 0.5;
+  return (
+    ((b[0] - a[0]) * (py - a[1]) - (b[1] - a[1]) * (px - a[0])) * orient >= -1e-9 &&
+    ((c[0] - b[0]) * (py - b[1]) - (c[1] - b[1]) * (px - b[0])) * orient >= -1e-9 &&
+    ((a[0] - c[0]) * (py - c[1]) - (a[1] - c[1]) * (px - c[0])) * orient >= -1e-9
+  );
+}
+
 /**
  * Rasterise a triangle set over the part's pixel grid and measure two things the
  * skeleton file cannot say: how much of the art the mesh covers, and how far past
@@ -1492,10 +1529,33 @@ export function measureAuthoredMeshFit(
  * never asks (a mask with no art has no covered-outside pixel to ask about).
  */
 export function squaredDistanceToSet(inside: Uint8Array, w: number, h: number): Float64Array {
-  const INF = w * w + h * h + 1;
+  const passes = distancePassesOf(w, h);
   const dist = new Float64Array(w * h);
-  for (let i = 0; i < dist.length; i++) dist[i] = inside[i] ? 0 : INF;
+  for (let x = 0; x < w; x++) {
+    const out = passes.column(inside, x);
+    for (let y = 0; y < h; y++) dist[y * w + x] = out[y];
+  }
+  for (let y = 0; y < h; y++) {
+    const out = passes.row(dist, y);
+    for (let x = 0; x < w; x++) dist[y * w + x] = out[x];
+  }
+  return dist;
+}
 
+/**
+ * `squaredDistanceToSet`'s two passes over one `w`x`h` grid, one column or one
+ * row per call, so a caller holding the previous grid's passes can redo only
+ * the columns whose set changed and the rows whose column values changed.
+ * `column(inside, x)` is column `x`'s pass over the set (`INF` where the
+ * column has no set pixel); `row(columns, y)` is row `y`'s pass over the
+ * column results. Each returns a scratch array whose first `h` (column) or
+ * `w` (row) entries are the result, valid until the next call. A column's
+ * result depends on that column of `inside` alone and a row's on that row of
+ * `columns` alone, which is what makes redoing a subset exact: every output
+ * is this one function of the same input.
+ */
+export function distancePassesOf(w: number, h: number): { column(inside: Uint8Array, x: number): Float64Array; row(columns: Float64Array, y: number): Float64Array } {
+  const INF = w * w + h * h + 1;
   const span = Math.max(w, h);
   const f = new Float64Array(span);
   const out = new Float64Array(span);
@@ -1526,17 +1586,18 @@ export function squaredDistanceToSet(inside: Uint8Array, w: number, h: number):
     }
   };
 
-  for (let x = 0; x < w; x++) {
-    for (let y = 0; y < h; y++) f[y] = dist[y * w + x];
-    envelope(h);
-    for (let y = 0; y < h; y++) dist[y * w + x] = out[y];
-  }
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) f[x] = dist[y * w + x];
-    envelope(w);
-    for (let x = 0; x < w; x++) dist[y * w + x] = out[x];
-  }
-  return dist;
+  return {
+    column: (inside, x) => {
+      for (let y = 0; y < h; y++) f[y] = inside[y * w + x] ? 0 : INF;
+      envelope(h);
+      return out;
+    },
+    row: (columns, y) => {
+      for (let x = 0; x < w; x++) f[x] = columns[y * w + x];
+      envelope(w);
+      return out;
+    },
+  };
 }
 
 /**

package/src/meshquality.ts

@@ -69,7 +69,7 @@ import {
   type MeshOutline,
 } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
-import { artRastersOf, type ArtRasters } from './meshrasters.ts';
+import { artRastersOf, type ArtRasters, type CoverageReading, type OutlineMemo, type SilhouetteReading, type StepRasters } from './meshrasters.ts';
 import { cropToSpineY } from './transform.ts';
 
 // ---------------------------------------------------------------------------
@@ -852,13 +852,15 @@ function pointToBoundary(p: Pt, poly: readonly Pt[]): { d: number; edge: number
  * value already found is dropped; the rest are halved. No sampling density is
  * chosen, so nothing here can miss a maximum between two samples.
  */
-function directedHausdorff(a: readonly Pt[], b: readonly Pt[]): { d: number; edge: number; at: Pt } {
+function directedHausdorff(a: readonly Pt[], b: readonly Pt[], carried: ((p: Pt) => Float64Array) | null = null): { d: number; edge: number; at: Pt } {
   const m = b.length;
-  const toEach = (p: Pt): Float64Array => {
-    const out = new Float64Array(m);
-    for (let j = 0; j < m; j++) out[j] = distanceToSegment(p, b[j], b[(j + 1) % m]);
-    return out;
-  };
+  const toEach =
+    carried ??
+    ((p: Pt): Float64Array => {
+      const out = new Float64Array(m);
+      for (let j = 0; j < m; j++) out[j] = distanceToSegment(p, b[j], b[(j + 1) % m]);
+      return out;
+    });
   const minOf = (g: Float64Array): number => {
     let v = Infinity;
     for (let j = 0; j < m; j++) v = Math.min(v, g[j]);
@@ -905,13 +907,136 @@ function directedHausdorff(a: readonly Pt[], b: readonly Pt[]): { d: number; edg
  * taken on when the worst point is the candidate's, else the candidate edge
  * nearest the reference's worst point.
  */
-function hausdorff(candidate: readonly Pt[], reference: readonly Pt[]): { d: number; candidateEdge: number } {
-  const forward = directedHausdorff(candidate, reference);
-  const backward = directedHausdorff(reference, candidate);
+function hausdorff(candidate: readonly Pt[], reference: readonly Pt[], carried: { forward: (p: Pt) => Float64Array; backward: (p: Pt) => Float64Array } | null = null): { d: number; candidateEdge: number } {
+  const forward = directedHausdorff(candidate, reference, carried?.forward ?? null);
+  const backward = directedHausdorff(reference, candidate, carried?.backward ?? null);
   if (forward.d >= backward.d) return { d: forward.d, candidateEdge: forward.edge };
   return { d: backward.d, candidateEdge: pointToBoundary(backward.at, candidate).edge };
 }
 
+/** A point as a key: both coordinates' shortest round-trip decimals, a negative zero told from a positive one. */
+function pointKey(p: Pt): string {
+  const k = (v: number): string => (v === 0 && 1 / v < 0 ? '-0' : String(v));
+  return `${k(p[0])},${k(p[1])}`;
+}
+
+/**
+ * `hausdorff`'s point-to-edge distance lists for one outline slot of a
+ * reduction, carried from the slot's last reading (`OutlineMemo`, issue #1246).
+ * Every list is the one `directedHausdorff` computes — `distanceToSegment(p,
+ * b[j], b[(j + 1) % m])` for every edge `j` — had in one of three ways, each
+ * the same function of the same input:
+ *
+ * - **toward the polygon read against** (fixed in a reduction): the list
+ *   kept for the same point, handed back whole while that polygon is equal;
+ * - **toward the outline**, which a step changes: the last reading's list for
+ *   the same point, each distance copied when its edge — both ends, exactly —
+ *   is an edge of the last outline, and computed when it is not;
+ * - anything else: computed.
+ */
+function carriedDistances(
+  memo: OutlineMemo,
+  outline: readonly Pt[],
+  against: readonly Pt[],
+  steps: StepRasters,
+): { forward: (p: Pt) => Float64Array; backward: (p: Pt) => Float64Array; commit: () => void } {
+  const { tally, plant } = steps;
+  memo.readings++;
+  const reading = memo.readings;
+  // The polygon read against: keep the lists while it is equal, coordinate by coordinate.
+  const againstFlat = new Float64Array(against.length * 2);
+  against.forEach((p, i) => {
+    againstFlat[i * 2] = p[0];
+    againstFlat[i * 2 + 1] = p[1];
+  });
+  const sameAgainst = memo.against !== null && memo.against.length === againstFlat.length && memo.against.every((v, i) => Object.is(v, againstFlat[i]));
+  if (!sameAgainst) {
+    memo.toAgainst.clear();
+    memo.against = againstFlat;
+  }
+  const ma = against.length;
+  const forward = (p: Pt): Float64Array => {
+    tally.distanceLists++;
+    const key = pointKey(p);
+    const kept = memo.toAgainst.get(key);
+    if (kept !== undefined) {
+      kept.used = reading;
+      tally.distanceListsReused++;
+      return kept.list;
+    }
+    const list = new Float64Array(ma);
+    for (let j = 0; j < ma; j++) list[j] = distanceToSegment(p, against[j], against[(j + 1) % ma]);
+    tally.edgesComputed += ma;
+    memo.toAgainst.set(key, { list, used: reading });
+    return list;
+  };
+  // The outline's edges, and where each sat in the last outline.
+  const mo = outline.length;
+  const edges = new Map<string, number>();
+  const from = new Int32Array(mo);
+  const lastEdges = memo.outlineEdges;
+  let plantPending = plant === 'skip-an-edge';
+  for (let j = 0; j < mo; j++) {
+    const key = `${pointKey(outline[j])};${pointKey(outline[(j + 1) % mo])}`;
+    edges.set(key, j);
+    const was = lastEdges?.get(key);
+    from[j] = was ?? -1;
+    if (was === undefined && plantPending && lastEdges !== null && j < lastEdges.size) {
+      // The plant: one new edge read as if it were the last outline's edge at the same index.
+      plantPending = false;
+      from[j] = j;
+    }
+  }
+  const last = memo.toOutline;
+  const next = new Map<string, Float64Array>();
+  const backward = (p: Pt): Float64Array => {
+    tally.distanceLists++;
+    const key = pointKey(p);
+    const done = next.get(key);
+    if (done !== undefined) {
+      tally.distanceListsReused++;
+      return done;
+    }
+    const before = last.get(key);
+    const list = new Float64Array(mo);
+    if (before === undefined) {
+      for (let j = 0; j < mo; j++) list[j] = distanceToSegment(p, outline[j], outline[(j + 1) % mo]);
+      tally.edgesComputed += mo;
+    } else {
+      tally.distanceListsCarried++;
+      for (let j = 0; j < mo; j++) {
+        if (from[j] >= 0) {
+          list[j] = before[from[j]];
+          tally.edgesCarried++;
+        } else {
+          list[j] = distanceToSegment(p, outline[j], outline[(j + 1) % mo]);
+          tally.edgesComputed++;
+        }
+      }
+    }
+    next.set(key, list);
+    return list;
+  };
+  return {
+    forward,
+    backward,
+    commit: () => {
+      // Keep this reading's outline lists for the next one; drop the lists toward the fixed polygon the last two readings did not ask for.
+      memo.toOutline = next;
+      memo.outlineEdges = edges;
+      for (const [key, entry] of memo.toAgainst) if (entry.used < reading - 1) memo.toAgainst.delete(key);
+    },
+  };
+}
+
+/** `hausdorff` through a reduction's carried distances (`carriedDistances`), dropping what the last two readings of the slot did not ask for. */
+function hausdorffCarried(memo: OutlineMemo, candidate: readonly Pt[], reference: readonly Pt[], steps: StepRasters): { d: number; candidateEdge: number } {
+  const carried = carriedDistances(memo, candidate, reference, steps);
+  const value = hausdorff(candidate, reference, carried);
+  carried.commit();
+  return value;
+}
+
 // ---------------------------------------------------------------------------
 // rows
 // ---------------------------------------------------------------------------
@@ -1008,7 +1133,7 @@ function compareRows(a: MeasureRow, b: MeasureRow): number {
  */
 export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
   validateInput(input);
-  return measureValidated(input, artRastersOf(input.art));
+  return measureValidated(input, artRastersOf(input.art), null);
 }
 
 /**
@@ -1027,7 +1152,74 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
 export function measureMeshQualityWith(input: MeshMeasureInput, rasters: ArtRasters): MeshQualityReport {
   validateInput(input);
   checkArtRasters(input, rasters);
-  return measureValidated(input, rasters);
+  return measureValidated(input, rasters, null);
+}
+
+/**
+ * `measureMeshQualityWith` carried from the last measurement the same
+ * `StepRasters` made (`src/meshrasters.ts`, issue #1246) — what `reduceMesh`
+ * calls for each step, so a step redraws only the triangles its removal
+ * changed, redoes the distance transform only where the coverage flipped, and
+ * reads the outline rows again only when the outline moved. The report is the
+ * one `measureMeshQuality` returns for the same input, byte for byte; rasters
+ * taken from another art are refused as `measureMeshQualityWith` refuses them.
+ *
+ * Internal, as `measureMeshQualityWith` is.
+ */
+export function measureMeshQualityStep(input: MeshMeasureInput, steps: StepRasters): MeshQualityReport {
+  validateInput(input);
+  checkArtRasters(input, steps.rasters);
+  return measureValidated(input, steps.rasters, steps);
+}
+
+/**
+ * The coverage reading of a triangle set measured on its own — the full path:
+ * every triangle drawn (`rasteriseTriangles`), the whole distance transform,
+ * and the covered art and islands counted over every pixel.
+ */
+function coverageOf(onGrid: Array<[number, number]>, triangles: number[], w: number, h: number, rasters: ArtRasters): CoverageReading {
+  const artBits = rasters.artBits();
+  const covered = rasteriseTriangles(onGrid, triangles, w, h);
+  let coveredArt = 0;
+  for (let i = 0; i < artBits.length; i++) if (artBits[i] && covered[i]) coveredArt++;
+  const toCovered = squaredDistanceToSet(covered, w, h);
+  const anyCovered = covered.some((c) => c === 1);
+  let undercutAt = -1;
+  let undercutSq = 0;
+  for (let i = 0; i < artBits.length; i++) {
+    if (!artBits[i] || covered[i]) continue;
+    if (undercutAt === -1 || toCovered[i] > undercutSq) {
+      undercutAt = i;
+      undercutSq = toCovered[i];
+    }
+  }
+  const { label } = rasters.islands();
+  const touched = new Set<number>();
+  for (let i = 0; i < label.length; i++) if (label[i] && covered[i]) touched.add(label[i]);
+  const secondIsland = touched.size >= 2 ? [...touched].sort((p, q) => p - q)[1] : 0;
+  const silhouette = (connectivity: 4 | 8): SilhouetteReading => {
+    const fills = rasters.fills();
+    const filled = connectivity === 8 ? fills.fill8 : fills.fill4;
+    const toFilled = rasters.toFilled(connectivity);
+    let overAt = -1;
+    let overSq = 0;
+    let holes = 0;
+    let holeAt = -1;
+    for (let i = 0; i < covered.length; i++) {
+      if (!covered[i]) continue;
+      if (!filled[i]) {
+        if (overAt === -1 || toFilled[i] > overSq) {
+          overAt = i;
+          overSq = toFilled[i];
+        }
+      } else if (!artBits[i]) {
+        holes++;
+        if (holeAt === -1) holeAt = i;
+      }
+    }
+    return { overAt, overSq, holes, holeAt };
+  };
+  return { covered, toCovered, coveredArt, anyCovered, undercut: { at: undercutAt, sq: undercutSq }, silhouette, islandsTouched: touched.size, secondIsland };
 }
 
 /**
@@ -1053,7 +1245,7 @@ function checkArtRasters(input: MeshMeasureInput, rasters: ArtRasters): void {
 }
 
 /** The measurement proper, over an input `validateInput` accepted and rasters taken from its art. */
-function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQualityReport {
+function measureValidated(input: MeshMeasureInput, rasters: ArtRasters, steps: StepRasters | null): MeshQualityReport {
   rasters.tally.uses++;
   const { attachment, art, source, targets } = input;
   const { mask, threshold, frame } = art;
@@ -1099,7 +1291,6 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQua
   const artBits = rasters.artBits();
   const artCount = rasters.artCount();
   const onGrid: Array<[number, number]> = source.points.map(([x, y]) => [x * scale, y * scale]);
-  const covered = rasteriseTriangles(onGrid, source.triangles, w, h);
   const fit = targets.artFit;
   const pxIncrement = 1 / scale;
   const rasterArt = (connectivity: 4 | 8 | null): NonNullable<MeasureRow['art']> => ({ threshold, connectivity, samples: artCount });
@@ -1112,21 +1303,12 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQua
     rows.push(withRaster(unmeasuredRow(spec('MQ_HOLES', 'count'), 'not-measurable', why, false), rasterArt(8), grid, 1));
     rows.push(withRaster(unmeasuredRow(spec('MQ_ISLANDS', 'count'), 'not-measurable', why, false), rasterArt(4), grid, 1));
   } else {
-    // Coverage — `measureAuthoredMeshFit`'s, unchanged: art pixel centres a triangle covers.
-    let coveredArt = 0;
-    for (let i = 0; i < artBits.length; i++) if (artBits[i] && covered[i]) coveredArt++;
-    const toCovered = squaredDistanceToSet(covered, w, h);
-    const anyCovered = covered.some((c) => c === 1);
+    // Coverage — `measureAuthoredMeshFit`'s, unchanged: art pixel centres a triangle covers. A reduction step
+    // carries it from its last measurement (`StepRasters`), which reads the same values.
+    const reading = steps === null ? coverageOf(onGrid, source.triangles, w, h, rasters) : steps.coverage(onGrid, source.triangles);
+    const { coveredArt, anyCovered } = reading;
     // Undercut: the furthest uncovered art pixel from the covered set. Its pixel is coverage's worst too.
-    let undercutAt = -1;
-    let undercutSq = 0;
-    for (let i = 0; i < artBits.length; i++) {
-      if (!artBits[i] || covered[i]) continue;
-      if (undercutAt === -1 || toCovered[i] > undercutSq) {
-        undercutAt = i;
-        undercutSq = toCovered[i];
-      }
-    }
+    const { at: undercutAt, sq: undercutSq } = reading.undercut;
     const missingWorst: WorstSample = undercutAt === -1 ? NOTHING_WORSE : { at: { pixel: pixelOf(undercutAt) } };
     rows.push(
       withRaster(
@@ -1150,25 +1332,9 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQua
 
     // Overshoot and holes against the filled silhouette: 8-connected background over ALL art (P12) — and,
     // where the legacy 4-connected fill differs (a diagonal pinch), the labelled 4-connected reading beside it.
-    const { fill8, fill4, differ: fillsDiffer } = rasters.fills();
-    const silhouetteRows = (filled: Uint8Array, connectivity: 4 | 8, gated: boolean): void => {
-      const toFilled = rasters.toFilled(connectivity);
-      let overAt = -1;
-      let overSq = 0;
-      let holes = 0;
-      let holeAt = -1;
-      for (let i = 0; i < covered.length; i++) {
-        if (!covered[i]) continue;
-        if (!filled[i]) {
-          if (overAt === -1 || toFilled[i] > overSq) {
-            overAt = i;
-            overSq = toFilled[i];
-          }
-        } else if (!artBits[i]) {
-          holes++;
-          if (holeAt === -1) holeAt = i;
-        }
-      }
+    const fillsDiffer = rasters.fills().differ;
+    const silhouetteRows = (connectivity: 4 | 8, gated: boolean): void => {
+      const { overAt, overSq, holes, holeAt } = reading.silhouette(connectivity);
       const bound = gated && fit !== null ? { op: '<=' as const, value: fit.maxOvershoot } : null;
       rows.push(
         withRaster(
@@ -1180,21 +1346,15 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQua
       );
       rows.push(withRaster(measuredRow(spec('MQ_HOLES', 'count'), holes, null, holeAt === -1 ? NOTHING_WORSE : { at: { pixel: pixelOf(holeAt) } }, false), rasterArt(connectivity), grid, 1));
     };
-    silhouetteRows(fill8, 8, true);
-    if (fillsDiffer) silhouetteRows(fill4, 4, false);
+    silhouetteRows(8, true);
+    if (fillsDiffer) silhouetteRows(4, false);
 
     // Islands: the 4-connected art islands (the tracer's, `labelIslands`) the triangles cover a pixel of.
     const { label } = rasters.islands();
-    const touched = new Set<number>();
-    for (let i = 0; i < label.length; i++) if (label[i] && covered[i]) touched.add(label[i]);
-    let joinedAt = -1;
-    if (touched.size >= 2) {
-      const second = [...touched].sort((p, q) => p - q)[1];
-      joinedAt = label.indexOf(second);
-    }
+    const joinedAt = reading.islandsTouched >= 2 ? label.indexOf(reading.secondIsland) : -1;
     rows.push(
       withRaster(
-        measuredRow(spec('MQ_ISLANDS', 'count'), touched.size, null, joinedAt === -1 ? NOTHING_WORSE : { at: { pixel: pixelOf(joinedAt) } }, false),
+        measuredRow(spec('MQ_ISLANDS', 'count'), reading.islandsTouched, null, joinedAt === -1 ? NOTHING_WORSE : { at: { pixel: pixelOf(joinedAt) } }, false),
         { threshold, connectivity: 4, samples: artCount },
         grid,
         1,
@@ -1208,14 +1368,16 @@ function measureValidated(input: MeshMeasureInput, rasters: ArtRasters): MeshQua
   if (input.referenceHull === null) {
     rows.push(unmeasuredRow(boundarySpec, 'not-measurable', `attachment ${nameOf(attachment)}: no referenceHull was given, so there is no polygon to measure the hull's deviation from`, targets.maxBoundaryDeviation !== null));
   } else {
-    const hd = hausdorff(hullPolygon, input.referenceHull);
+    const reference = input.referenceHull;
+    const hd = steps === null ? hausdorff(hullPolygon, reference) : steps.outline('reference', hullPolygon, reference, (memo) => hausdorffCarried(memo, hullPolygon, reference, steps));
     const bound = targets.maxBoundaryDeviation === null ? null : { op: '<=' as const, value: targets.maxBoundaryDeviation };
     rows.push(measuredRow(boundarySpec, r6(hd.d), bound, hd.d === 0 ? NOTHING_WORSE : { at: { edge: edgeOfHull(hd.candidateEdge) } }, true));
   }
   const traceSpec = spec('MQ_TRACE_DEVIATION', 'px');
   const traced = rasters.traced();
   if ('outline' in traced) {
-    const hd = hausdorff(hullPolygon, traced.outline);
+    const tracedOutline = traced.outline;
+    const hd = steps === null ? hausdorff(hullPolygon, tracedOutline) : steps.outline('traced', hullPolygon, tracedOutline, (memo) => hausdorffCarried(memo, hullPolygon, tracedOutline, steps));
     rows.push(measuredRow(traceSpec, r6(hd.d), null, hd.d === 0 ? NOTHING_WORSE : { at: { edge: edgeOfHull(hd.candidateEdge) } }, false));
   } else {
     rows.push(unmeasuredRow(traceSpec, 'not-measurable', `attachment ${nameOf(attachment)}: the tracer refused the art at alpha >= ${threshold}: ${traced.refused}`, false));

package/src/meshrasters.ts

@@ -33,7 +33,7 @@
  *
  * Not re-exported by `src/mesh.ts`: nothing here is on `spine-rigc/mesh`.
  */
-import { artOf, fillEnclosed, labelIslands, MeshError, prunePolygon, squaredDistanceToSet, traceAlphaOutline } from './mesh.ts';
+import { artOf, distancePassesOf, fillEnclosed, labelIslands, MeshError, pixelCentreInTriangle, prunePolygon, squaredDistanceToSet, traceAlphaOutline, triangleRasterBox } from './mesh.ts';
 import type { ArtInput } from './meshquality.ts';
 
 /** How many times each quantity was computed, and how many measurements were handed the object. */
@@ -154,3 +154,468 @@ export function artRastersOf(art: ArtInput): ArtRasters {
     },
   };
 }
+
+/**
+ * Overshoot and holes against one filled silhouette: the covered centre
+ * outside it furthest from it (the first in pixel order among equals; −1 when
+ * none) with its squared distance, and the covered centres inside it that are
+ * not art — how many, and the first in pixel order (−1 when none).
+ */
+export interface SilhouetteReading {
+  overAt: number;
+  overSq: number;
+  holes: number;
+  holeAt: number;
+}
+
+/**
+ * What one step's coverage reads, from either path: the covered pixel centres,
+ * their distance transform, the covered art pixels, whether any centre is
+ * covered, the uncovered art pixel furthest from the covered set (the first in
+ * pixel order among equals; −1 when none) with its squared distance, the
+ * silhouette reading at either connectivity, and the 4-connected art islands
+ * the coverage touches — how many, and the second-smallest label among them
+ * (0 when fewer than two).
+ */
+export interface CoverageReading {
+  covered: Uint8Array;
+  toCovered: Float64Array;
+  coveredArt: number;
+  anyCovered: boolean;
+  undercut: { at: number; sq: number };
+  silhouette(connectivity: 4 | 8): SilhouetteReading;
+  islandsTouched: number;
+  secondIsland: number;
+}
+
+/** How a step-rasters object came by each reading, and what it redid. */
+export interface StepRasterTally {
+  /** Coverage readings handed out. */
+  readings: number;
+  /** Readings built from nothing: the first, and any whose triangles differ from the last in more than they share. */
+  rebuilt: number;
+  /** Readings carried from the last one by the triangles that differ. */
+  carried: number;
+  /** Triangles drawn (taken away or added) by carried readings. */
+  trianglesDrawn: number;
+  /** Triangles a carried reading did not draw because the last reading held them already. */
+  trianglesKept: number;
+  /** Pixel centres whose coverage changed between readings. */
+  pixelsFlipped: number;
+  /** Columns and rows of the distance transform carried readings redid. */
+  columnsRedone: number;
+  rowsRedone: number;
+  /** Outline deviations measured, and handed back because the outline and the polygon it is read against equal the last ones. */
+  outlinesMeasured: number;
+  outlinesReused: number;
+  /** Point-to-edge distance lists an outline measurement asked for, and how each was had: handed back whole, carried edge by edge from the last list of the same point, or computed. */
+  distanceLists: number;
+  distanceListsReused: number;
+  distanceListsCarried: number;
+  /** Edges a carried list took from the last list of its point, and edges it computed because the edge is new. */
+  edgesCarried: number;
+  edgesComputed: number;
+}
+
+/**
+ * A fault planted on purpose in the carried path, for the mesh-quality
+ * controls to show they catch it: one added triangle not drawn, one changed
+ * column or row of the distance transform not redone, or an outline reading
+ * reused when only the vertex counts match. `reduceMesh` plants none.
+ */
+export type StepRasterPlant = 'skip-a-triangle' | 'skip-a-column' | 'skip-a-row' | 'stale-outline' | 'skip-an-edge';
+
+/**
+ * One outline slot's carried distances (`src/meshquality.ts`, `hausdorff`): a
+ * directed Hausdorff reading asks, for points along one polygon, the distance
+ * to every edge of the other, and those lists are kept from the last reading
+ * of the slot by the point they were asked for, keyed by its exact
+ * coordinates.
+ *
+ * - `toAgainst` — lists of distances to the edges of the polygon the outline
+ *   is read against (fixed for a reduction). Kept while that polygon is equal;
+ *   an entry not asked for by the last two readings is dropped.
+ * - `toOutline` — lists of distances to the outline's own edges, which a step
+ *   changes. Kept for the last reading's outline only, with its edges
+ *   (`outlineEdges`, keyed by both ends), so the next reading copies each
+ *   distance whose edge it still has and computes the rest.
+ */
+export interface OutlineMemo {
+  against: Float64Array | null;
+  toAgainst: Map<string, { list: Float64Array; used: number }>;
+  outlineEdges: Map<string, number> | null;
+  toOutline: Map<string, Float64Array>;
+  readings: number;
+}
+
+/**
+ * The per-step state of one reduction (issue #1246): the last coverage
+ * reading and the last outline deviations, so the next measurement redoes only
+ * what its mesh changed. Like `ArtRasters` it is a value made by the caller,
+ * passed explicitly and dropped with the call; nothing is kept at module level.
+ *
+ * ## Why every reading equals the full one
+ *
+ * A reduction step changes the triangles of one vertex's link and nothing
+ * else, yet the full measurement redraws every triangle and redoes the whole
+ * distance transform. Here each quantity is carried from the last reading by a
+ * rule under which it is the same function of the same input:
+ *
+ * - **Coverage** is held as a count per pixel centre of the triangles whose
+ *   centre test (`triangleRasterBox`, `pixelCentreInTriangle` — the rule
+ *   `rasteriseTriangles` reads) holds there. The triangles are compared with
+ *   the last reading's as a multiset keyed by their three corners' exact
+ *   coordinates in the order given (a zero's sign included); a triangle taken
+ *   away is drawn with −1 and one added with +1, so every count is the exact
+ *   number of triangles covering that centre, and a centre is covered exactly
+ *   when its count is positive — `rasteriseTriangles`'s union.
+ * - **The distance transform** is `squaredDistanceToSet`'s two passes
+ *   (`distancePassesOf`). A column's pass reads that column of the coverage
+ *   alone, so only columns holding a flipped centre are redone; a row's pass
+ *   reads that row of the column results alone, so only rows where a redone
+ *   column's value changed are redone. Every other value is the output of the
+ *   same pass over the same input.
+ * - **Covered art and islands** are integer counts updated at each flipped
+ *   centre: art pixels covered, centres covered, and covered pixels per island
+ *   label; the islands touched are the labels whose count is positive.
+ * - **Outline deviations** (`outline`) are handed back only when the outline
+ *   and the polygon it is read against are equal, coordinate by coordinate
+ *   with a zero's sign, to the last ones of that slot — the same pure function
+ *   of the same input.
+ *
+ * A reading whose triangles differ from the last in more triangles than they
+ * share is built from nothing, as the first one is; which way a reading is
+ * built changes its cost and never its values.
+ */
+export interface StepRasters {
+  readonly rasters: ArtRasters;
+  readonly tally: StepRasterTally;
+  /** The coverage reading of these triangles over the drawing-pixel `points`; its arrays are valid until the next reading. */
+  coverage(points: Array<[number, number]>, triangles: number[]): CoverageReading;
+  /** The fault planted for a control, or null. */
+  readonly plant: StepRasterPlant | null;
+  /**
+   * `measure(memo)`'s value, or the last one of `slot` when `outline` and
+   * `against` equal the last ones exactly; `memo` is the slot's carried
+   * distances, which `measure` reads and keeps current.
+   */
+  outline<T>(slot: string, outline: ReadonlyArray<readonly [number, number]>, against: ReadonlyArray<readonly [number, number]>, measure: (memo: OutlineMemo) => T): T;
+}
+
+/** A coordinate as a key: its shortest round-trip decimal, with a negative zero told from a positive one. */
+function coordKey(v: number): string {
+  return v === 0 && 1 / v < 0 ? '-0' : String(v);
+}
+
+/** Equal coordinate by coordinate, a zero's sign included. */
+function samePolygon(a: ReadonlyArray<readonly [number, number]>, b: Float64Array): boolean {
+  if (a.length * 2 !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (!Object.is(a[i][0], b[i * 2]) || !Object.is(a[i][1], b[i * 2 + 1])) return false;
+  return true;
+}
+
+function flat(p: ReadonlyArray<readonly [number, number]>): Float64Array {
+  const out = new Float64Array(p.length * 2);
+  for (let i = 0; i < p.length; i++) {
+    out[i * 2] = p[i][0];
+    out[i * 2 + 1] = p[i][1];
+  }
+  return out;
+}
+
+type Corners = [readonly [number, number], readonly [number, number], readonly [number, number]];
+
+interface HeldTriangles {
+  corners: Corners;
+  n: number;
+}
+
+interface CoverageState {
+  held: Map<string, HeldTriangles>;
+  /** Triangles covering each pixel centre. */
+  count: Int32Array;
+  covered: Uint8Array;
+  /** The column pass of the distance transform, and the transform. */
+  columns: Float64Array;
+  dist: Float64Array;
+  coveredArt: number;
+  coveredTotal: number;
+  /** Covered pixels per island label (index 0 unused). */
+  islandHits: Int32Array;
+  islandsTouched: number;
+  /** Art pixels not covered. */
+  uncoveredArt: Set<number>;
+  /** Per connectivity, once read: covered centres outside the filled silhouette, and covered centres inside it that are not art. */
+  silhouettes: Map<4 | 8, { outside: Set<number>; holes: Set<number> }>;
+}
+
+/** Step rasters over `rasters`' art. Reads nothing until the first reading. */
+export function stepRastersOf(rasters: ArtRasters, plant: StepRasterPlant | null = null): StepRasters {
+  const tally: StepRasterTally = {
+    readings: 0,
+    rebuilt: 0,
+    carried: 0,
+    trianglesDrawn: 0,
+    trianglesKept: 0,
+    pixelsFlipped: 0,
+    columnsRedone: 0,
+    rowsRedone: 0,
+    outlinesMeasured: 0,
+    outlinesReused: 0,
+    distanceLists: 0,
+    distanceListsReused: 0,
+    distanceListsCarried: 0,
+    edgesCarried: 0,
+    edgesComputed: 0,
+  };
+  const { width: w, height: h } = rasters.art.mask;
+  let state: CoverageState | null = null;
+  const outlines = new Map<string, { outline: Float64Array; against: Float64Array; value: unknown }>();
+  const memos = new Map<string, OutlineMemo>();
+
+  /** Add `sign` to the count of every centre the triangle covers, pushing each such centre to `touched`. */
+  const draw = (count: Int32Array, corners: Corners, sign: number, touched: number[] | null): void => {
+    const [a, b, c] = corners;
+    const box = triangleRasterBox(a, b, c, w, h);
+    if (box === null) return;
+    for (let y = box.minY; y <= box.maxY; y++) {
+      for (let x = box.minX; x <= box.maxX; x++) {
+        if (!pixelCentreInTriangle(x, y, a, b, c, box.orient)) continue;
+        count[y * w + x] += sign;
+        if (touched !== null) touched.push(y * w + x);
+      }
+    }
+  };
+
+  const readingOf = (s: CoverageState): CoverageReading => {
+    let second = 0;
+    if (s.islandsTouched >= 2) {
+      let seen = 0;
+      for (let l = 1; l < s.islandHits.length; l++) {
+        if (s.islandHits[l] > 0 && ++seen === 2) {
+          second = l;
+          break;
+        }
+      }
+    }
+    // The worst of a set by the full scan's rule: the largest value, the smallest index among equals.
+    const worstOf = (set: Set<number>, value: Float64Array): { at: number; sq: number } => {
+      let at = -1;
+      let sq = 0;
+      for (const i of set) {
+        const v = value[i];
+        if (at === -1 || v > sq || (v === sq && i < at)) {
+          at = i;
+          sq = v;
+        }
+      }
+      return { at, sq };
+    };
+    const silhouette = (connectivity: 4 | 8): SilhouetteReading => {
+      let sets = s.silhouettes.get(connectivity);
+      if (sets === undefined) {
+        const fills = rasters.fills();
+        const filled = connectivity === 8 ? fills.fill8 : fills.fill4;
+        const artBits = rasters.artBits();
+        sets = { outside: new Set(), holes: new Set() };
+        for (let i = 0; i < s.covered.length; i++) {
+          if (!s.covered[i]) continue;
+          if (!filled[i]) sets.outside.add(i);
+          else if (!artBits[i]) sets.holes.add(i);
+        }
+        s.silhouettes.set(connectivity, sets);
+      }
+      const over = worstOf(sets.outside, rasters.toFilled(connectivity));
+      let holeAt = -1;
+      for (const i of sets.holes) if (holeAt === -1 || i < holeAt) holeAt = i;
+      return { overAt: over.at, overSq: over.sq, holes: sets.holes.size, holeAt };
+    };
+    return {
+      covered: s.covered,
+      toCovered: s.dist,
+      coveredArt: s.coveredArt,
+      anyCovered: s.coveredTotal > 0,
+      undercut: worstOf(s.uncoveredArt, s.dist),
+      silhouette,
+      islandsTouched: s.islandsTouched,
+      secondIsland: second,
+    };
+  };
+
+  const rebuild = (held: Map<string, HeldTriangles>): CoverageState => {
+    tally.rebuilt++;
+    const artBits = rasters.artBits();
+    const { label, sizes } = rasters.islands();
+    const count = new Int32Array(w * h);
+    for (const { corners, n } of held.values()) for (let k = 0; k < n; k++) draw(count, corners, 1, null);
+    const covered = new Uint8Array(w * h);
+    const islandHits = new Int32Array(sizes.length + 1);
+    let coveredArt = 0;
+    let coveredTotal = 0;
+    let islandsTouched = 0;
+    const uncoveredArt = new Set<number>();
+    for (let i = 0; i < covered.length; i++) {
+      if (count[i] <= 0) {
+        if (artBits[i]) uncoveredArt.add(i);
+        continue;
+      }
+      covered[i] = 1;
+      coveredTotal++;
+      if (artBits[i]) coveredArt++;
+      if (label[i] && islandHits[label[i]]++ === 0) islandsTouched++;
+    }
+    const passes = distancePassesOf(w, h);
+    const columns = new Float64Array(w * h);
+    for (let x = 0; x < w; x++) {
+      const out = passes.column(covered, x);
+      for (let y = 0; y < h; y++) columns[y * w + x] = out[y];
+    }
+    const dist = new Float64Array(w * h);
+    for (let y = 0; y < h; y++) {
+      const out = passes.row(columns, y);
+      for (let x = 0; x < w; x++) dist[y * w + x] = out[x];
+    }
+    return { held, count, covered, columns, dist, coveredArt, coveredTotal, islandHits, islandsTouched, uncoveredArt, silhouettes: new Map() };
+  };
+
+  /** Carry `s` to the triangles `held` by drawing the ones that differ, then redo the distance transform where it changed. */
+  const carry = (s: CoverageState, held: Map<string, HeldTriangles>, removed: Corners[], added: Corners[]): void => {
+    tally.carried++;
+    tally.trianglesDrawn += removed.length + added.length;
+    const touched: number[] = [];
+    for (const corners of removed) draw(s.count, corners, -1, touched);
+    added.forEach((corners, k) => {
+      if (plant === 'skip-a-triangle' && k === 0) return;
+      draw(s.count, corners, 1, touched);
+    });
+    s.held = held;
+    // Flip the centres whose count crossed zero, keeping the integer counts with them.
+    const artBits = rasters.artBits();
+    const { label } = rasters.islands();
+    const fills = s.silhouettes.size > 0 ? rasters.fills() : null;
+    const dirtyColumns = new Uint8Array(w);
+    for (const i of touched) {
+      const now = s.count[i] > 0 ? 1 : 0;
+      if (now === s.covered[i]) continue;
+      s.covered[i] = now;
+      tally.pixelsFlipped++;
+      dirtyColumns[i % w] = 1;
+      const d = now === 1 ? 1 : -1;
+      s.coveredTotal += d;
+      if (artBits[i]) {
+        s.coveredArt += d;
+        if (now === 1) s.uncoveredArt.delete(i);
+        else s.uncoveredArt.add(i);
+      }
+      for (const [connectivity, sets] of s.silhouettes) {
+        if (now === 0) {
+          sets.outside.delete(i);
+          sets.holes.delete(i);
+          continue;
+        }
+        const filled = connectivity === 8 ? fills!.fill8 : fills!.fill4;
+        if (!filled[i]) sets.outside.add(i);
+        else if (!artBits[i]) sets.holes.add(i);
+      }
+      const l = label[i];
+      if (l) {
+        const before = s.islandHits[l];
+        s.islandHits[l] += d;
+        if (before === 0) s.islandsTouched++;
+        else if (s.islandHits[l] === 0) s.islandsTouched--;
+      }
+    }
+    // Redo the columns holding a flipped centre, then the rows where a column value changed.
+    const passes = distancePassesOf(w, h);
+    const dirtyRows = new Uint8Array(h);
+    let skipColumn = plant === 'skip-a-column';
+    for (let x = 0; x < w; x++) {
+      if (!dirtyColumns[x]) continue;
+      if (skipColumn) {
+        skipColumn = false;
+        continue;
+      }
+      tally.columnsRedone++;
+      const out = passes.column(s.covered, x);
+      for (let y = 0; y < h; y++) {
+        if (Object.is(s.columns[y * w + x], out[y])) continue;
+        s.columns[y * w + x] = out[y];
+        dirtyRows[y] = 1;
+      }
+    }
+    let skipRow = plant === 'skip-a-row';
+    for (let y = 0; y < h; y++) {
+      if (!dirtyRows[y]) continue;
+      if (skipRow) {
+        skipRow = false;
+        continue;
+      }
+      tally.rowsRedone++;
+      const out = passes.row(s.columns, y);
+      for (let x = 0; x < w; x++) s.dist[y * w + x] = out[x];
+    }
+  };
+
+  return {
+    rasters,
+    tally,
+    coverage: (points, triangles) => {
+      tally.readings++;
+      const held = new Map<string, HeldTriangles>();
+      for (let t = 0; t + 2 < triangles.length; t += 3) {
+        const corners: Corners = [points[triangles[t]], points[triangles[t + 1]], points[triangles[t + 2]]];
+        const key = `${coordKey(corners[0][0])},${coordKey(corners[0][1])},${coordKey(corners[1][0])},${coordKey(corners[1][1])},${coordKey(corners[2][0])},${coordKey(corners[2][1])}`;
+        const entry = held.get(key);
+        if (entry === undefined) held.set(key, { corners, n: 1 });
+        else entry.n++;
+      }
+      if (state === null) {
+        state = rebuild(held);
+        return readingOf(state);
+      }
+      // The multiset difference against the last reading's triangles.
+      const removed: Corners[] = [];
+      const added: Corners[] = [];
+      let kept = 0;
+      for (const [key, { corners, n }] of held) {
+        const was = state.held.get(key)?.n ?? 0;
+        kept += Math.min(was, n);
+        for (let k = was; k < n; k++) added.push(corners);
+      }
+      for (const [key, { corners, n }] of state.held) {
+        const now = held.get(key)?.n ?? 0;
+        for (let k = now; k < n; k++) removed.push(corners);
+      }
+      if (removed.length + added.length > kept) {
+        state = rebuild(held);
+        return readingOf(state);
+      }
+      tally.trianglesKept += kept;
+      carry(state, held, removed, added);
+      return readingOf(state);
+    },
+    plant,
+    outline: <T>(slot: string, outline: ReadonlyArray<readonly [number, number]>, against: ReadonlyArray<readonly [number, number]>, measure: (memo: OutlineMemo) => T): T => {
+      const last = outlines.get(slot);
+      if (last !== undefined) {
+        const same =
+          plant === 'stale-outline'
+            ? last.outline.length === outline.length * 2 && last.against.length === against.length * 2
+            : samePolygon(outline, last.outline) && samePolygon(against, last.against);
+        if (same) {
+          tally.outlinesReused++;
+          return last.value as T;
+        }
+      }
+      tally.outlinesMeasured++;
+      let memo = memos.get(slot);
+      if (memo === undefined) {
+        memo = { against: null, toAgainst: new Map(), outlineEdges: null, toOutline: new Map(), readings: 0 };
+        memos.set(slot, memo);
+      }
+      const value = measure(memo);
+      outlines.set(slot, { outline: flat(outline), against: flat(against), value });
+      return value;
+    },
+  };
+}

package/src/meshreduce.ts

@@ -26,7 +26,9 @@
  * Each candidate step is measured by `measureMeshQuality` (`src/meshquality.ts`)
  * — no row is re-implemented here; the call reads it as `measureMeshQualityWith`
  * over the art's rasters taken once at admission (`src/meshrasters.ts`, issue
- * #1240), which returns the same report — and taken only when every row the caller's
+ * #1240), and as `measureMeshQualityStep` carried from the last step's
+ * measurement (`StepRasters`, issue #1246), each of which returns the same
+ * report — and taken only when every row the caller's
  * contract requires is `pass`: the art fit at `targets.artFit`, the boundary
  * deviation from the source hull at `targets.maxBoundaryDeviation`, the minimum
  * angle when declared, orientation and degeneracy at 0, and every region's
@@ -87,6 +89,7 @@ import {
 import {
   BAND_CONTACT_TOLERANCE,
   edgeIsHeldByRegion,
+  measureMeshQualityStep,
   measureMeshQualityWith,
   type AttachmentRef,
   type ArtFitBounds,
@@ -103,7 +106,7 @@ import {
   type SourceMesh,
   type Termination,
 } from './meshquality.ts';
-import { artRastersOf, type ArtRasters } from './meshrasters.ts';
+import { artRastersOf, stepRastersOf, type ArtRasters, type StepRasters } from './meshrasters.ts';
 
 // ---------------------------------------------------------------------------
 // the result
@@ -716,6 +719,8 @@ interface Run {
   sourceEdges: Set<string>;
   /** The art's rasters, taken once for the call and read by every measurement in it (issue #1240). */
   rasters: ArtRasters;
+  /** The step state each removal and insertion is measured through, carried from the last measurement (issue #1246); null measures every step in full. */
+  stepRasters: StepRasters | null;
 }
 
 /** A measurement of a canonical mesh against the result's full contract. */
@@ -736,7 +741,7 @@ function measureAgainstTargets(run: Run, mesh: SourceMesh, id: string): MeshQual
     boneOrder: input.boneOrder,
     preset: input.preset,
   };
-  return measureMeshQualityWith(measureInput, run.rasters);
+  return run.stepRasters === null ? measureMeshQualityWith(measureInput, run.rasters) : measureMeshQualityStep(measureInput, run.stepRasters);
 }
 
 /** The order constraints are named in when several fail on one step: structure, then shape, then art, then density. */
@@ -1172,7 +1177,8 @@ function tryRemoval(run: Run, v: number): string | null {
  */
 export function reduceMesh(input: MeshReductionInput): MeshReductionResult {
   validateReduction(input);
-  return reduceValidated(input, artRastersOf(input.art));
+  const rasters = artRastersOf(input.art);
+  return reduceValidated(input, rasters, stepRastersOf(rasters));
 }
 
 /**
@@ -1180,19 +1186,29 @@ export function reduceMesh(input: MeshReductionInput): MeshReductionResult {
  * `src/meshrasters.ts`) — the result is `reduceMesh`'s for the same input, byte
  * for byte, and every measurement of the call reads the one object, so its
  * `tally` is the count of what the call computed. Rasters taken from another
- * art are refused at admission (`REDUCE_ART_RASTERS_MISMATCH`).
+ * art are refused at admission (`REDUCE_ART_RASTERS_MISMATCH`). Each step is
+ * measured through `steps` (`stepRastersOf(rasters)` unless given), carried
+ * from the last measurement (issue #1246); `null` measures every step in full,
+ * which is the path the carried one is held equal to. Step rasters made over
+ * another rasters object are refused by the same code.
  *
  * Internal: it is on `spine-rigc/mesh` only because that entry re-exports this
  * module with `export *`, and a symbol that is merely exported is not promised
  * (RELEASING.md, *The import surface*).
  */
-export function reduceMeshWith(input: MeshReductionInput, rasters: ArtRasters): MeshReductionResult {
+export function reduceMeshWith(input: MeshReductionInput, rasters: ArtRasters, steps: StepRasters | null = stepRastersOf(rasters)): MeshReductionResult {
   validateReduction(input);
-  return reduceValidated(input, rasters);
+  if (steps !== null && steps.rasters !== rasters) {
+    refuse('REDUCE_ART_RASTERS_MISMATCH', `attachment ${nameOf(input.attachment)}: the step rasters were made over another rasters object; required step rasters made over the rasters passed beside them (stepRastersOf(rasters))`);
+  }
+  return reduceValidated(input, rasters, steps);
 }
 
-/** The operation, over an input `validateReduction` accepted; the art's rasters are computed at most once, in `rasters`. */
-function reduceValidated(input: MeshReductionInput, rasters: ArtRasters): MeshReductionResult {
+/**
+ * The operation, over an input `validateReduction` accepted; the art's rasters are computed at most once, in
+ * `rasters`, and every refinement and removal step is measured through `steps` when it is given (issue #1246).
+ */
+function reduceValidated(input: MeshReductionInput, rasters: ArtRasters, steps: StepRasters | null): MeshReductionResult {
   const who = `attachment ${nameOf(input.attachment)}`;
   const src = input.source;
   const sourceHull: Array<[number, number]> = src.points.slice(0, Math.max(0, src.hull)).map(([x, y]): [number, number] => [x, y]);
@@ -1273,6 +1289,7 @@ function reduceValidated(input: MeshReductionInput, rasters: ArtRasters): MeshRe
       ...protectionOf(input, work, sourceEdges),
       sourceEdges,
       rasters,
+      stepRasters: steps,
     };
 
     const refined = refineRegions(run);