spine-rigc 2.22.0 → 2.24.0

package/package.json

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

@@ -1253,8 +1253,9 @@ export function traceAlphaOutline(
  * `background` is how the flood steps: 4 through edges, 8 through corners too.
  * The trace floods 8 — the dual of its 4-connected island, so background that
  * meets the outside at a corner is outside — and says why where it calls this.
- * The authored-mesh measurement floods 4, as it always has; the two agree on
- * every mask the trace accepts.
+ * The authored-mesh measurement floods 4 by default, as it always has, and 8
+ * when its caller asks (issue #1262); the two agree on every mask the trace
+ * accepts.
  */
 export function fillEnclosed(
   inside: Uint8Array,
@@ -1479,16 +1480,57 @@ export interface MeshFitReport {
  * is never refused, so every figure needs a number — hence the exact distance
  * transform below rather than a neighbourhood search that would have to stop
  * somewhere.
+ *
+ * ## Which background is enclosed — `connectivity` (issue #1262)
+ *
+ * The background is flooded 4-connected by default, as it always has been, so
+ * every call that passes four arguments reads exactly what it read before.
+ * `8` floods through corners too — the fill `measureMeshQuality`'s
+ * `MQ_OVERSHOOT` and `MQ_HOLES` rows are taken against (P12), by the same
+ * `fillEnclosed` call — so a background pocket joined to the outside only
+ * diagonally is read as outside, and a caller gating with this figure reads
+ * the number the rows read. The two fills agree on every mask without such a
+ * pocket. Any other value is refused by name: a silent fallback to one of the
+ * two would answer a question the caller did not ask.
  */
 export function measureAuthoredMeshFit(
   mask: AlphaMask,
   threshold: number,
   points: Array<[number, number]>,
   triangles: number[],
+  connectivity: 4 | 8 = 4,
 ): MeshFitReport {
+  return authoredMeshFitOf(mask, threshold, points, triangles, connectivity, null).report;
+}
+
+/**
+ * A fault planted on purpose in `authoredMeshFitOf`, for the mesh-quality
+ * suite's negative control: `'fill-4-under-8'` takes the connectivity it is
+ * passed and floods 4 whatever it was. `measureAuthoredMeshFit` plants none.
+ */
+export type AuthoredFitPlant = 'fill-4-under-8';
+
+/**
+ * `measureAuthoredMeshFit`'s measurement, with the pixel its overshoot is
+ * read at — the first covered pixel outside the filled silhouette at the
+ * largest distance, by the tie rule `MQ_OVERSHOOT` names its pixel with, or
+ * -1 when no covered pixel lies outside — so a control can name where two
+ * readings part.
+ */
+export function authoredMeshFitOf(
+  mask: AlphaMask,
+  threshold: number,
+  points: Array<[number, number]>,
+  triangles: number[],
+  connectivity: 4 | 8,
+  plant: AuthoredFitPlant | null,
+): { report: MeshFitReport; overshootAt: number } {
+  if (connectivity !== 4 && connectivity !== 8) {
+    throw new MeshError(`measureAuthoredMeshFit: connectivity is ${JSON.stringify(connectivity)}; required 4 (the default, the legacy fill) or 8 (the fill MQ_OVERSHOOT reads, P12)`);
+  }
   const { width: w, height: h } = mask;
   const art = artOf(mask, threshold);
-  const { filled } = fillEnclosed(art, w, h, 4);
+  const { filled } = fillEnclosed(art, w, h, plant === 'fill-4-under-8' ? 4 : connectivity);
   const covered = rasteriseTriangles(points, triangles, w, h);
   let artPixels = 0;
   let coveredArt = 0;
@@ -1499,15 +1541,22 @@ export function measureAuthoredMeshFit(
   }
   const squared = squaredDistanceToSet(filled, w, h);
   let worst = 0;
+  let overshootAt = -1;
   for (let i = 0; i < covered.length; i++) {
     if (!covered[i] || filled[i]) continue;
-    if (squared[i] > worst) worst = squared[i];
+    if (overshootAt === -1 || squared[i] > worst) {
+      overshootAt = i;
+      worst = squared[i];
+    }
   }
   return {
-    artPixels,
-    coveredArt,
-    coverage: artPixels === 0 ? 0 : coveredArt / artPixels,
-    overshoot: r6(Math.sqrt(worst)),
+    report: {
+      artPixels,
+      coveredArt,
+      coverage: artPixels === 0 ? 0 : coveredArt / artPixels,
+      overshoot: r6(Math.sqrt(worst)),
+    },
+    overshootAt,
   };
 }
 

package/src/meshquality.ts

@@ -32,7 +32,8 @@
  *   taken at (`MeasureRow.art.threshold`); a measurement claims nothing at any
  *   other.
  * - **Change the legacy fit.** `measureAuthoredMeshFit` (`src/mesh.ts`) keeps
- *   its 4-connected fill for every existing caller. The rows here fill with the
+ *   its 4-connected fill for every existing caller (its `connectivity: 8`,
+ *   issue #1262, is the fill the rows read). The rows here fill with the
  *   tracer's 8-connected background flood over all art (P12), and where the two
  *   fills differ — a diagonal pinch — both labelled results are rows.
  * - **Pose, or link the runtime.** Pure: no clock, no randomness, no network,
@@ -234,6 +235,14 @@ export interface MeshReductionInput {
   deform: DeformTimelineInput[];
   /** Every linked mesh of the source (they inherit the new topology); empty when none. */
   linkedMeshes: AttachmentRef[];
+  /**
+   * Replay (issue #1268, §7 mechanism 2): stop after the n-th accepted step — a refinement insertion or a removal
+   * taken, counted as `ReductionChanges.acceptedAt` counts them — and return the mesh the same call without this field
+   * had at that step, byte for byte, terminated `replayed-to-accepted-step`. Left out = today's behaviour. A whole
+   * number, 0 or more: 0 takes no step. A number the run never reaches leaves the run to end as it would have, and
+   * that termination says so (`stopAfterAccepted` on it).
+   */
+  stopAfterAccepted?: number;
 }
 
 /**
@@ -401,6 +410,12 @@ export interface ReductionChanges {
   deformReevaluated: Array<{ animation: string; attachment: AttachmentRef; key: number }>;
   /** Every linked mesh of the source: each inherits the new topology. */
   linkedMeshes: AttachmentRef[];
+  /**
+   * Issue #1268: the attempt number — `candidatesTried` as it stood when the step was taken, 1-based — of every
+   * accepted step, ascending: each refinement insertion and each removal, so its length is
+   * `insertedVertices + removedVertices`. `stopAfterAccepted: k` replays to the step at `acceptedAt[k - 1]`.
+   */
+  acceptedAt: number[];
 }
 
 export interface MeshQualityReport {
@@ -444,6 +459,8 @@ export interface EffectiveSettings {
   boneOrder: string[] | null;
   schedule: MotionSchedule | null;
   budget: { maxCandidates: number } | null;
+  /** A reduction's `stopAfterAccepted`, echoed when the input set it (issue #1268); absent otherwise. */
+  stopAfterAccepted?: number;
 }
 
 export interface MeshCounts {
@@ -456,10 +473,20 @@ export interface MeshCounts {
   maxInfluences: number;
 }
 
+/**
+ * Issue #1268: carried by a run's own termination when the input asked for `stopAfterAccepted` and the run ended
+ * before that many steps were accepted — `requested` the input's n, `acceptedSteps` how many the run took.
+ */
+export interface StopNotReached {
+  requested: number;
+  acceptedSteps: number;
+}
+
 /** *Termination reasons*. Every `reduce` report carries exactly one; a `measure` carries one only when it could not read the mesh. */
 export type Termination =
-  | { reason: 'no-further-valid-reduction'; candidatesTried: number; blockingConstraint: string }
-  | { reason: 'budget-exhausted'; candidatesTried: number; budget: number; result: 'best-meeting-every-bound' | 'none-met-the-targets' }
+  | { reason: 'no-further-valid-reduction'; candidatesTried: number; blockingConstraint: string; stopAfterAccepted?: StopNotReached }
+  | { reason: 'budget-exhausted'; candidatesTried: number; budget: number; result: 'best-meeting-every-bound' | 'none-met-the-targets'; stopAfterAccepted?: StopNotReached }
+  | { reason: 'replayed-to-accepted-step'; acceptedSteps: number; candidatesTried: number }
   | { reason: 'invalid-input'; code: string; detail: string }
   | { reason: 'unsupported-topology'; code: string; detail: string };
 
@@ -694,8 +721,21 @@ function validateInput(input: MeshMeasureInput): void {
 
 type Pt = readonly [number, number];
 
-/** Is `p` inside or on the closed polygon? On the boundary within `ON_BOUNDARY` counts as inside. */
-function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
+/**
+ * Is `p` inside or on the closed polygon? On the boundary within `ON_BOUNDARY` counts as inside.
+ *
+ * The rule, exactly, because `closedPolygonCentres` reproduces it bit for bit:
+ * `p` is in when its `distanceToSegment` to some side `poly[i]`–`poly[i+1]`
+ * is at most `ON_BOUNDARY` (1e-9 px) — a point on an edge or at a vertex is in,
+ * whatever the ray says; otherwise by **even-odd** parity of a ray towards +x,
+ * where the side from `poly[j]` to `poly[i]` (`j` the one before `i`) crosses
+ * when exactly one of its ends has a y strictly greater than `p`'s — `yi > py`
+ * differs from `yj > py`, so the half-open rule counts a vertex at `p`'s height
+ * once and a horizontal side never — at
+ * `xc = ((xj − xi)·(py − yi)) / (yj − yi) + xi`, and the crossing counts when
+ * `px < xc` strictly.
+ */
+export function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
   const n = poly.length;
   for (let i = 0; i < n; i++) if (distanceToSegment(p, poly[i], poly[(i + 1) % n]) <= ON_BOUNDARY) return true;
   let inside = false;
@@ -707,6 +747,112 @@ function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
   return inside;
 }
 
+/**
+ * A fault planted on purpose in `closedPolygonCentres`, for the mesh-quality
+ * suite's negative control: `'crossing-half-pixel'` moves every ray crossing
+ * half a pixel towards +x. `regionRows` plants none.
+ */
+export type ScanlinePlant = 'crossing-half-pixel';
+
+/**
+ * Which pixel centres of a `w`×`h` grid lie in or on a closed polygon given
+ * in drawing px — `inClosedPolygon` of every centre `((x + 0.5) / scale,
+ * (y + 0.5) / scale)`, 1 where it is true, by scanline (issue #1263).
+ *
+ * The same decision, not a cleaner one: each row's crossings are the sides
+ * `inClosedPolygon` counts for that row's centre height, by its own
+ * half-open test, at the `xc` it computes with the same expression in the same
+ * order, so they are the same doubles; sorted, the number of them a centre
+ * lies strictly left of is the number its ray counts, and its parity is the
+ * answer. The boundary band is then added side by side, each centre near a
+ * side tested with `distanceToSegment` against `ON_BOUNDARY` — the predicate's
+ * own test — so a centre on an edge or at a vertex is in exactly when the
+ * predicate says so. The rows and columns visited around a side are widened by
+ * a pixel past where it can reach, and only the exact tests decide.
+ *
+ * O(rows × sides + pixels) where testing every centre against every side is
+ * O(pixels × sides).
+ */
+export function closedPolygonCentres(poly: readonly Pt[], w: number, h: number, scale: number, plant: ScanlinePlant | null = null): Uint8Array {
+  const marks = new Uint8Array(w * h);
+  const n = poly.length;
+  if (n === 0 || w <= 0 || h <= 0) return marks;
+  const cx = (x: number): number => (x + 0.5) / scale;
+  const cy = (y: number): number => (y + 0.5) / scale;
+  const shift = plant === 'crossing-half-pixel' ? 0.5 / scale : 0;
+  /** The grid row or column of a drawing coordinate, rounded one way and widened by `slack`; NaN visits nothing. */
+  const cellOf = (v: number, round: (u: number) => number, slack: number, size: number): number => {
+    const c = round(v * scale - 0.5) + slack;
+    if (Number.isNaN(c)) return slack < 0 ? size : -1;
+    return c;
+  };
+
+  // Even-odd: per row, the crossings of a ray towards +x from the row's centre height.
+  const crossings: Array<number[] | undefined> = new Array<number[] | undefined>(h);
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    const y0 = Math.max(0, cellOf(Math.min(yi, yj), Math.floor, -1, h));
+    const y1 = Math.min(h - 1, cellOf(Math.max(yi, yj), Math.ceil, 1, h));
+    for (let y = y0; y <= y1; y++) {
+      const py = cy(y);
+      if (yi > py !== yj > py) {
+        let row = crossings[y];
+        if (row === undefined) {
+          row = [];
+          crossings[y] = row;
+        }
+        row.push(((xj - xi) * (py - yi)) / (yj - yi) + xi + shift);
+      }
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    const row = crossings[y];
+    if (row === undefined) continue;
+    row.sort((a, b) => a - b);
+    const x0 = Math.max(0, cellOf(row[0], Math.floor, -1, w));
+    const x1 = Math.min(w - 1, cellOf(row[row.length - 1], Math.ceil, 1, w));
+    let left = 0;
+    for (let x = x0; x <= x1; x++) {
+      const px = cx(x);
+      while (left < row.length && !(px < row[left])) left++;
+      if ((row.length - left) & 1) marks[y * w + x] = 1;
+    }
+  }
+
+  // On the boundary: within ON_BOUNDARY of a side. Per side, the rows its ends span and, per row, the columns
+  // the side passes within a pixel of that row's centre height, each widened by a pixel; the exact test decides.
+  const unit = 1 / scale;
+  for (let i = 0; i < n; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % n];
+    const y0 = Math.max(0, cellOf(Math.min(a[1], b[1]), Math.floor, -1, h));
+    const y1 = Math.min(h - 1, cellOf(Math.max(a[1], b[1]), Math.ceil, 1, h));
+    const dy = b[1] - a[1];
+    for (let y = y0; y <= y1; y++) {
+      let lo = Math.min(a[0], b[0]);
+      let hi = Math.max(a[0], b[0]);
+      if (dy !== 0) {
+        const py = cy(y);
+        const t0 = Math.max(0, Math.min(1, (py - unit - a[1]) / dy));
+        const t1 = Math.max(0, Math.min(1, (py + unit - a[1]) / dy));
+        const xa = a[0] + (b[0] - a[0]) * t0;
+        const xb = a[0] + (b[0] - a[0]) * t1;
+        lo = Math.min(xa, xb);
+        hi = Math.max(xa, xb);
+      }
+      const x0 = Math.max(0, cellOf(lo, Math.floor, -1, w));
+      const x1 = Math.min(w - 1, cellOf(hi, Math.ceil, 1, w));
+      for (let x = x0; x <= x1; x++) {
+        const k = y * w + x;
+        if (marks[k]) continue;
+        if (distanceToSegment([cx(x), cy(y)], a, b) <= ON_BOUNDARY) marks[k] = 1;
+      }
+    }
+  }
+  return marks;
+}
+
 /** Does the segment `a`–`b` meet the closed polygon — an endpoint inside or on it, or any crossing or touch? */
 function segmentMeetsPolygon(a: Pt, b: Pt, poly: readonly Pt[]): boolean {
   if (inClosedPolygon(a, poly) || inClosedPolygon(b, poly)) return true;
@@ -1673,8 +1819,10 @@ function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon:
     // would keep, in the same order.
     const centreOf = (i: number): Pt => [((i % mask.width) + 0.5) / scale, (Math.floor(i / mask.width) + 0.5) / scale];
     const inRegion = (): Int32Array => {
+      // `inClosedPolygon` of every art pixel centre, by scanline (`closedPolygonCentres`, issue #1263).
+      const inside = closedPolygonCentres(poly, mask.width, mask.height, scale);
       const kept: number[] = [];
-      for (let i = 0; i < artBits.length; i++) if (artBits[i] && inClosedPolygon(centreOf(i), poly)) kept.push(i);
+      for (let i = 0; i < artBits.length; i++) if (artBits[i] && inside[i]) kept.push(i);
       return Int32Array.from(kept);
     };
     const regionPixels = steps === null ? inRegion() : steps.regionPixels(poly, inRegion);
@@ -1841,6 +1989,7 @@ function effectiveJson(e: EffectiveSettings): Json {
     boneOrder: e.boneOrder === null ? null : [...e.boneOrder],
     schedule: scheduleJson(e.schedule),
     budget: e.budget === null ? null : { maxCandidates: e.budget.maxCandidates },
+    ...(e.stopAfterAccepted === undefined ? {} : { stopAfterAccepted: e.stopAfterAccepted }),
   };
 }
 
@@ -1918,18 +2067,24 @@ function candidateJson(c: CandidateReport): Json {
       deformRemapped: k.deformRemapped.map((d) => ({ animation: d.animation, attachment: attachmentJson(d.attachment), key: d.key, droppedVertices: [...d.droppedVertices] })),
       deformReevaluated: k.deformReevaluated.map((d) => ({ animation: d.animation, attachment: attachmentJson(d.attachment), key: d.key })),
       linkedMeshes: k.linkedMeshes.map(attachmentJson),
+      acceptedAt: [...k.acceptedAt],
     };
   }
   return out;
 }
 
+const notReachedJson = (s: StopNotReached | undefined): { [key: string]: Json } =>
+  s === undefined ? {} : { stopAfterAccepted: { requested: s.requested, acceptedSteps: s.acceptedSteps } };
+
 function terminationJson(t: Termination | null): Json {
   if (t === null) return null;
   switch (t.reason) {
     case 'no-further-valid-reduction':
-      return { reason: t.reason, candidatesTried: t.candidatesTried, blockingConstraint: t.blockingConstraint };
+      return { reason: t.reason, candidatesTried: t.candidatesTried, blockingConstraint: t.blockingConstraint, ...notReachedJson(t.stopAfterAccepted) };
     case 'budget-exhausted':
-      return { reason: t.reason, candidatesTried: t.candidatesTried, budget: t.budget, result: t.result };
+      return { reason: t.reason, candidatesTried: t.candidatesTried, budget: t.budget, result: t.result, ...notReachedJson(t.stopAfterAccepted) };
+    case 'replayed-to-accepted-step':
+      return { reason: t.reason, acceptedSteps: t.acceptedSteps, candidatesTried: t.candidatesTried };
     case 'invalid-input':
     case 'unsupported-topology':
       return { reason: t.reason, code: t.code, detail: t.detail };

package/src/meshreduce.ts

@@ -105,6 +105,7 @@ import {
   type RefinementRegion,
   type ReductionChanges,
   type SourceMesh,
+  type StopNotReached,
   type Termination,
 } from './meshquality.ts';
 import { artRastersOf, stepRastersOf, type ArtRasters, type StepRasters } from './meshrasters.ts';
@@ -260,6 +261,9 @@ function validateReduction(input: MeshReductionInput): void {
   if (!isObject(b) || !Number.isInteger(b.maxCandidates) || (b.maxCandidates as number) < 0) {
     refuse('REDUCE_INPUT_MISSING', `${who}: budget is ${JSON.stringify(b)}; required { maxCandidates: a whole number, 0 or more } — the work bound has no default`);
   }
+  if ('stopAfterAccepted' in input && input.stopAfterAccepted !== undefined && (!Number.isInteger(input.stopAfterAccepted) || input.stopAfterAccepted < 0)) {
+    refuse('REDUCE_INPUT_MISSING', `${who}: stopAfterAccepted is ${JSON.stringify(input.stopAfterAccepted)}; required a whole number of accepted steps, 0 or more, or the field left out (issue #1268: replay to that step)`);
+  }
   const src = input.source;
   if (!isObject(src) || !Array.isArray(src.points)) refuse('REDUCE_INPUT_MISSING', `${who}: source is not { points, uvs, triangles, hull, weights }`);
   const n = src.points.length;
@@ -729,6 +733,10 @@ interface Run {
   sourceHull: Array<[number, number]>;
   /** Steps tried so far, refinement insertions and removal attempts alike. */
   steps: number;
+  /** Issue #1268: `steps` as it stood at each accepted step — every insertion made and every removal taken — in order. */
+  acceptedAt: number[];
+  /** The replay fault planted for a control, or null. */
+  plant: ReplayPlant | null;
   tally: Tally;
   keyed: Map<number, { animation: string; ref: AttachmentRef; key: number; time: number }>;
   protectedVertices: Set<number>;
@@ -959,7 +967,27 @@ function insertPoint(run: Run, p: Pt): boolean {
 type PhaseEnd =
   | { kind: 'done' }
   | { kind: 'budget' }
-  | { kind: 'stuck'; constraint: string };
+  | { kind: 'stuck'; constraint: string }
+  | { kind: 'replayed' };
+
+/**
+ * Record an accepted step (issue #1268) and say whether the call's `stopAfterAccepted` is now reached — checked
+ * straight after the step, before the budget is read again, so the replay stops in exactly the state the
+ * unreplayed run held after that step.
+ */
+function accept(run: Run): boolean {
+  run.acceptedAt.push(run.steps);
+  const stop = run.input.stopAfterAccepted;
+  if (stop === undefined) return false;
+  const at = run.plant === 'stop-one-early' ? stop - 1 : run.plant === 'stop-one-late' ? stop + 1 : stop;
+  return run.acceptedAt.length >= at;
+}
+
+/**
+ * A fault planted on purpose in the replay, for the mesh-quality suite's controls (issue #1268): the stop taken
+ * one accepted step before or after the one asked for. `reduceMesh` plants none.
+ */
+export type ReplayPlant = 'stop-one-early' | 'stop-one-late';
 
 /**
  * Refine the working mesh until every region's `MQ_MAX_EDGE` and
@@ -983,6 +1011,7 @@ function refineRegions(run: Run): PhaseEnd {
     if (target.state === 'not-measurable') {
       const p: Pt = [r6(region.polygon[0][0]), r6(region.polygon[0][1])];
       if (!insertPoint(run, p)) return { kind: 'stuck', constraint: `${rowName(target)} (the refinement found no triangle holding the region's first vertex)` };
+      if (accept(run)) return { kind: 'replayed' };
       continue;
     }
     const [ra, rb] = target.worst!.at.edge!;
@@ -1000,7 +1029,10 @@ function refineRegions(run: Run): PhaseEnd {
       exited = true;
       break;
     }
-    if (exited) continue;
+    if (exited) {
+      if (accept(run)) return { kind: 'replayed' };
+      continue;
+    }
     // An end outside the region and its band further beyond it than the edge's own bound, with no split on
     // the band's outer boundary that frees the piece to it — always so with transition 0, where a contact
     // with the authored boundary stays held: every split keeps a held edge from a vertex inside the region
@@ -1023,6 +1055,7 @@ function refineRegions(run: Run): PhaseEnd {
     const p = splitPoint(run.work.pos[a], run.work.pos[b], region);
     if (p === null) return { kind: 'stuck', constraint: `${rowName(target)} (the refinement found no point of edge ${ra}–${rb} strictly between its ends inside region "${region.name}" or its band)` };
     splitEdge(run, a, b, p);
+    if (accept(run)) return { kind: 'replayed' };
   }
 }
 
@@ -1115,8 +1148,10 @@ function removeVertices(run: Run): PhaseEnd {
       run.steps++;
       tried++;
       const block = tryRemoval(run, v);
-      if (block === null) taken++;
-      else lastBlock = `${block}, removing source vertex ${v}`;
+      if (block === null) {
+        taken++;
+        if (accept(run)) return { kind: 'replayed' };
+      } else lastBlock = `${block}, removing source vertex ${v}`;
     }
     if (taken === 0) {
       if (tried === 0) lastBlock = 'protect: every surviving source vertex is protected (protect.hull, protect.vertices, protect.edges, protect.regionBoundaries or a weightJump edge)';
@@ -1193,6 +1228,11 @@ function tryRemoval(run: Run, v: number): string | null {
  *   returned when it meets every required bound, and none is when it does not;
  * - `no-further-valid-reduction`: a pass took no step, naming what blocked the
  *   last one. A local stop: nothing here says the result is the smallest.
+ * - `replayed-to-accepted-step`: the input's `stopAfterAccepted` was reached —
+ *   the mesh is the one the same call without it held after that many accepted
+ *   steps, byte for byte (issue #1268). Never reported as an exhausted budget; a
+ *   stop the run does not reach leaves the run's own termination, which then
+ *   carries `stopAfterAccepted: { requested, acceptedSteps }`.
  */
 export function reduceMesh(input: MeshReductionInput): MeshReductionResult {
   validateReduction(input);
@@ -1215,19 +1255,19 @@ export function reduceMesh(input: MeshReductionInput): MeshReductionResult {
  * 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, steps: StepRasters | null = stepRastersOf(rasters)): MeshReductionResult {
+export function reduceMeshWith(input: MeshReductionInput, rasters: ArtRasters, steps: StepRasters | null = stepRastersOf(rasters), plant: ReplayPlant | null = null): MeshReductionResult {
   validateReduction(input);
   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);
+  return reduceValidated(input, rasters, steps, plant);
 }
 
 /**
  * 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 {
+function reduceValidated(input: MeshReductionInput, rasters: ArtRasters, steps: StepRasters | null, plant: ReplayPlant | null = 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]);
@@ -1302,6 +1342,8 @@ function reduceValidated(input: MeshReductionInput, rasters: ArtRasters, steps:
       sourceTurn: Math.sign(signedArea(sourceHull)),
       sourceHull,
       steps: 0,
+      acceptedAt: [],
+      plant,
       tally: { sharesDroppedOnGrid: 0, sharesPruned: 0 },
       keyed: keyedSourceVertices(input),
       ...protectionOf(input, work, sourceEdges),
@@ -1310,20 +1352,28 @@ function reduceValidated(input: MeshReductionInput, rasters: ArtRasters, steps:
       stepRasters: steps,
     };
 
+    // Issue #1268: a replay ends in its own termination, never as an exhausted budget; a stop the run never reaches
+    // leaves the run's own termination, which then carries `stopAfterAccepted` saying so.
+    const replayed = (): Termination => ({ reason: 'replayed-to-accepted-step', acceptedSteps: run.acceptedAt.length, candidatesTried: run.steps });
+    const stop = input.stopAfterAccepted;
+    const notReached = (): { stopAfterAccepted?: StopNotReached } => (stop === undefined ? {} : { stopAfterAccepted: { requested: stop, acceptedSteps: run.acceptedAt.length } });
+    if (stop === 0) return finish(run, effective, sourceCounts, replayed());
     const refined = refineRegions(run);
-    if (refined.kind === 'budget') return noMesh({ reason: 'budget-exhausted', candidatesTried: run.steps, budget: input.budget.maxCandidates, result: 'none-met-the-targets' });
+    if (refined.kind === 'replayed') return finish(run, effective, sourceCounts, replayed());
+    if (refined.kind === 'budget') return noMesh({ reason: 'budget-exhausted', candidatesTried: run.steps, budget: input.budget.maxCandidates, result: 'none-met-the-targets', ...notReached() });
     const startCanon = canonicalise(work, run.sourceTurn, boneRank);
     const startBlock = firstBlockingRow(measureAgainstTargets(run, startCanon.mesh, 'start'), input.targets.artFit);
     let termination: Termination;
     if (startBlock !== null) {
       const constraint = refined.kind === 'stuck' ? refined.constraint : rowName(startBlock);
-      termination = { reason: 'no-further-valid-reduction', candidatesTried: run.steps, blockingConstraint: `${constraint} — before any removal: the refined source does not meet its targets, so no step from it can` };
+      termination = { reason: 'no-further-valid-reduction', candidatesTried: run.steps, blockingConstraint: `${constraint} — before any removal: the refined source does not meet its targets, so no step from it can`, ...notReached() };
     } else {
       const reduced = removeVertices(run);
+      if (reduced.kind === 'replayed') return finish(run, effective, sourceCounts, replayed());
       termination =
         reduced.kind === 'budget'
-          ? { reason: 'budget-exhausted', candidatesTried: run.steps, budget: input.budget.maxCandidates, result: 'best-meeting-every-bound' }
-          : { reason: 'no-further-valid-reduction', candidatesTried: run.steps, blockingConstraint: reduced.kind === 'stuck' ? reduced.constraint : '' };
+          ? { reason: 'budget-exhausted', candidatesTried: run.steps, budget: input.budget.maxCandidates, result: 'best-meeting-every-bound', ...notReached() }
+          : { reason: 'no-further-valid-reduction', candidatesTried: run.steps, blockingConstraint: reduced.kind === 'stuck' ? reduced.constraint : '', ...notReached() };
     }
     return finish(run, effective, sourceCounts, termination);
   } catch (err) {
@@ -1403,6 +1453,7 @@ function finish(run: Run, effective: EffectiveSettings, sourceCounts: MeshCounts
     deformRemapped: deform.remapped.map((d) => ({ animation: d.animation, attachment: d.attachment, key: d.key, droppedVertices: d.droppedVertices })),
     deformReevaluated: deform.reevaluated.map((d) => ({ animation: d.animation, attachment: d.attachment, key: d.key })),
     linkedMeshes: input.linkedMeshes,
+    acceptedAt: [...run.acceptedAt],
   };
   const counts = candidate.counts!;
   const mesh: ReducedMesh = {
@@ -1440,5 +1491,6 @@ function effectiveOf(input: MeshReductionInput, measured: EffectiveSettings, sou
     targets: input.targets,
     referenceHull: sourceHull,
     budget: { maxCandidates: input.budget.maxCandidates },
+    ...(input.stopAfterAccepted === undefined ? {} : { stopAfterAccepted: input.stopAfterAccepted }),
   };
 }