spine-rigc 2.20.0 → 2.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.20.0",
+  "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

@@ -54,26 +54,22 @@
  * `MeshReductionError` is defined in `src/mesh.ts` for exactly that reason.
  */
 import {
-  artOf,
   checkHullOrder,
   distanceToSegment,
-  fillEnclosed,
   findSelfIntersection,
-  labelIslands,
   MeshError,
   MeshReductionError,
   meshEdges,
-  prunePolygon,
   r6,
   rasteriseTriangles,
   segmentsMeet,
   squaredDistanceToSet,
-  traceAlphaOutline,
   traceOutline,
   type AlphaMask,
   type MeshOutline,
 } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
+import { artRastersOf, type ArtRasters, type CoverageReading, type OutlineMemo, type SilhouetteReading, type StepRasters } from './meshrasters.ts';
 import { cropToSpineY } from './transform.ts';
 
 // ---------------------------------------------------------------------------
@@ -856,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]);
@@ -909,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
 // ---------------------------------------------------------------------------
@@ -1012,6 +1133,120 @@ function compareRows(a: MeasureRow, b: MeasureRow): number {
  */
 export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
   validateInput(input);
+  return measureValidated(input, artRastersOf(input.art), null);
+}
+
+/**
+ * `measureMeshQuality` over art rasters the caller already holds
+ * (`src/meshrasters.ts`) — what `reduceMesh` calls for every measurement of
+ * one call, so the quantities of the art alone are computed once per call
+ * rather than once per step (issue #1240). The report is the one
+ * `measureMeshQuality` returns for the same input, byte for byte; rasters
+ * taken from another art are refused (`REDUCE_ART_RASTERS_MISMATCH`), never
+ * read.
+ *
+ * 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 measureMeshQualityWith(input: MeshMeasureInput, rasters: ArtRasters): MeshQualityReport {
+  validateInput(input);
+  checkArtRasters(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 };
+}
+
+/**
+ * Rasters are read only for the art they were taken from: the same mask
+ * array, mask size, threshold and frame. The first field that differs is
+ * refused by name, with the value the rasters were taken at and the value the
+ * input requires.
+ */
+function checkArtRasters(input: MeshMeasureInput, rasters: ArtRasters): void {
+  const want = input.art;
+  const got = rasters.art;
+  if (got === want) return;
+  const who = `attachment ${nameOf(input.attachment)}`;
+  const differs = (field: string, found: string, required: string): never =>
+    refuse('REDUCE_ART_RASTERS_MISMATCH', `${who}: the art rasters were taken at ${field} ${found}; required ${field} ${required}, the input's — rasters are read only for the art they were taken from`);
+  const size = (m: AlphaMask | undefined): string => (m === undefined ? 'undefined' : `${m.width}x${m.height}`);
+  if (size(got.mask) !== size(want.mask)) differs('art.mask size', size(got.mask), size(want.mask));
+  if (got.threshold !== want.threshold) differs('art.threshold', JSON.stringify(got.threshold), JSON.stringify(want.threshold));
+  for (const field of ['pageScale', 'width', 'height'] as const) {
+    if (got.frame?.[field] !== want.frame[field]) differs(`art.frame.${field}`, JSON.stringify(got.frame?.[field]), JSON.stringify(want.frame[field]));
+  }
+  if (got.mask.alpha !== want.mask.alpha) differs('art.mask.alpha', 'another array', 'the input\'s own array (the same object)');
+}
+
+/** The measurement proper, over an input `validateInput` accepted and rasters taken from its art. */
+function measureValidated(input: MeshMeasureInput, rasters: ArtRasters, steps: StepRasters | null): MeshQualityReport {
+  rasters.tally.uses++;
   const { attachment, art, source, targets } = input;
   const { mask, threshold, frame } = art;
   const scale = frame.pageScale;
@@ -1053,11 +1288,9 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
   const w = mask.width;
   const h = mask.height;
   const grid = { width: w, height: h, pageScale: scale };
-  const artBits = artOf(mask, threshold);
-  let artCount = 0;
-  for (const bit of artBits) artCount += bit;
+  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 });
@@ -1070,21 +1303,12 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
     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(
@@ -1108,33 +1332,9 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
 
     // 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 = fillEnclosed(artBits, w, h, 8).filled;
-    const fill4 = fillEnclosed(artBits, w, h, 4).filled;
-    let fillsDiffer = false;
-    for (let i = 0; i < fill8.length; i++) {
-      if (fill8[i] !== fill4[i]) {
-        fillsDiffer = true;
-        break;
-      }
-    }
-    const silhouetteRows = (filled: Uint8Array, connectivity: 4 | 8, gated: boolean): void => {
-      const toFilled = squaredDistanceToSet(filled, w, h);
-      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(
@@ -1146,21 +1346,15 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
       );
       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 } = labelIslands(artBits, w, h);
-    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 { label } = rasters.islands();
+    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,
@@ -1174,19 +1368,19 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
   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');
-  try {
-    const traced = traceAlphaOutline(mask, threshold);
-    const outlinePx = prunePolygon(traced.outline.map(([x, y]): [number, number] => [x / scale, y / scale]));
-    const hd = hausdorff(hullPolygon, outlinePx);
+  const traced = rasters.traced();
+  if ('outline' in traced) {
+    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));
-  } catch (err) {
-    if (!(err instanceof MeshError)) throw err;
-    rows.push(unmeasuredRow(traceSpec, 'not-measurable', `attachment ${nameOf(attachment)}: the tracer refused the art at alpha >= ${threshold}: ${err.message}`, false));
+  } else {
+    rows.push(unmeasuredRow(traceSpec, 'not-measurable', `attachment ${nameOf(attachment)}: the tracer refused the art at alpha >= ${threshold}: ${traced.refused}`, false));
   }
 
   // --- triangles: sign, degeneracy, angle --------------------------------------------------
@@ -1233,7 +1427,7 @@ export function measureMeshQuality(input: MeshMeasureInput): MeshQualityReport {
   );
 
   // --- regions (§5) ------------------------------------------------------------------------
-  rows.push(...regionRows(input, outline, hullPolygon));
+  rows.push(...regionRows(input, outline, hullPolygon, rasters));
 
   const ordered = rows.slice().sort((a, b) => compareRows(a.row, b.row));
   const geometry = sectionOf(ordered);
@@ -1331,7 +1525,7 @@ interface Edge {
  * length most exceeds its own bound — so the row fails exactly when some edge
  * it covers is over — and the row names that edge and that bound.
  */
-function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon: readonly Pt[]): Built[] {
+function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon: readonly Pt[], rasters: ArtRasters): Built[] {
   const { attachment, source, art } = input;
   const who = `attachment ${nameOf(attachment)}`;
   const scale = art.frame.pageScale;
@@ -1407,7 +1601,7 @@ function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon:
 
   const floorOf = (name: string): number => input.regionArtSamples.find((f) => f.region === name)!.minArtSamples;
   const { mask, threshold } = art;
-  const artBits = artOf(mask, threshold);
+  const artBits = rasters.artBits();
 
   for (const region of input.targets.regions) {
     const refused = refusals.get(region.name);