rig-c 2.31.0 → 2.31.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.31.0",
+  "version": "2.31.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/meshreduce.ts

@@ -430,6 +430,98 @@ function edgeKey(a: number, b: number): string {
   return a < b ? `${a},${b}` : `${b},${a}`;
 }
 
+/**
+ * Issue #1307: an undirected edge as one number, `min * n + max`, for ids below `n` — the key every edge set on the
+ * removal and boundary-run paths is held in, where `edgeKey` built a string per edge. Exact below 2^53, so for any
+ * `n` up to 94,906,265.
+ */
+function pairKey(a: number, b: number, n: number): number {
+  return a < b ? a * n + b : b * n + a;
+}
+
+/**
+ * Issue #1307: the edges `fresh`'s triangles hold that no triangle of `old` holds, each once, in the order `fresh`
+ * holds them (triangle by triangle, corner k to k + 1) — the order condition (b) reads them in and names the first
+ * over `weightJump`. Keyed by number over ids below `n`, and only the keys `fresh` holds are looked for in `old`.
+ * `addedEdgesByString` is the construction it replaced, kept as the one it is held equal to.
+ */
+function addedEdges(old: ReadonlyArray<readonly number[]>, fresh: ReadonlyArray<readonly number[]>, n: number): Array<[number, number]> {
+  const wanted = new Set<number>();
+  for (const t of fresh) for (let k = 0; k < 3; k++) wanted.add(pairKey(t[k], t[(k + 1) % 3], n));
+  const held = new Set<number>();
+  for (const t of old) {
+    for (let k = 0; k < 3; k++) {
+      const key = pairKey(t[k], t[(k + 1) % 3], n);
+      if (wanted.has(key)) held.add(key);
+    }
+  }
+  const added: Array<[number, number]> = [];
+  const seen = new Set<number>();
+  for (const t of fresh) {
+    for (let k = 0; k < 3; k++) {
+      const key = pairKey(t[k], t[(k + 1) % 3], n);
+      if (held.has(key) || seen.has(key)) continue;
+      seen.add(key);
+      added.push([t[k], t[(k + 1) % 3]]);
+    }
+  }
+  return added;
+}
+
+/** The string-keyed construction `addedEdges` replaced (issue #1307), run only by the edge-set audit. */
+function addedEdgesByString(old: ReadonlyArray<readonly number[]>, fresh: ReadonlyArray<readonly number[]>): Array<[number, number]> {
+  const had = new Set<string>();
+  for (const t of old) for (let k = 0; k < 3; k++) had.add(edgeKey(t[k], t[(k + 1) % 3]));
+  const added: Array<[number, number]> = [];
+  const seen = new Set<string>();
+  for (const t of fresh) {
+    for (let k = 0; k < 3; k++) {
+      const key = edgeKey(t[k], t[(k + 1) % 3]);
+      if (had.has(key) || seen.has(key)) continue;
+      seen.add(key);
+      added.push([t[k], t[(k + 1) % 3]]);
+    }
+  }
+  return added;
+}
+
+/**
+ * Issue #1307's audit, for the `mesh-compare` suite's control: every edge set the removal and boundary-run paths
+ * build is built a second time the string-keyed way it was before the issue and compared — the added edges as a list
+ * (membership and order, the order condition (b) reads), the triangulation's edge set the protected edges are looked
+ * up in as a set (its order is never read). A difference is recorded, not thrown, so the control reads every one.
+ * `plant` is the fault applied to the numeric construction before the comparison: one edge dropped from each list
+ * and each set, or each added list of two or more reversed. With the audit and no plant, the call's result is the
+ * call's without it.
+ */
+export interface EdgeSetAudit {
+  plant?: 'drop-one' | 'reorder';
+  /** Added-edge lists compared, and the edges in them. */
+  addedLists: number;
+  addedEdges: number;
+  /** Lists among them whose order a difference could move — two edges or more. */
+  orderedLists: number;
+  /** Triangulation edge sets compared (one per operation reaching the protected-edge check), and the edges in them. */
+  edgeSets: number;
+  edgeSetEdges: number;
+  /** Each difference found, named; the first few in full. */
+  differences: string[];
+}
+
+/** One added-edge list read, through the audit when there is one: the plant applied, then the string construction compared. */
+function auditedAdded(audit: EdgeSetAudit | null, where: string, added: Array<[number, number]>, byString: () => Array<[number, number]>): Array<[number, number]> {
+  if (audit === null) return added;
+  let read = added;
+  if (audit.plant === 'drop-one' && read.length > 0) read = read.slice(0, -1);
+  if (audit.plant === 'reorder' && read.length > 1) read = [...read].reverse();
+  const want = byString();
+  audit.addedLists++;
+  audit.addedEdges += want.length;
+  if (want.length > 1) audit.orderedLists++;
+  if (JSON.stringify(read) !== JSON.stringify(want)) audit.differences.push(`${where}: added edges ${JSON.stringify(read)} against the string construction's ${JSON.stringify(want)}`);
+  return read;
+}
+
 // ---------------------------------------------------------------------------
 // the working mesh — vertices by stable id: source index, then insertion order
 // ---------------------------------------------------------------------------
@@ -467,18 +559,7 @@ interface Canonical {
  * 5. bindings strongest first, ties by the bone's position in `boneOrder`.
  */
 function canonicalise(work: Work, sourceTurn: number, boneRank: Map<string, number>): Canonical {
-  const ids: number[] = [];
-  for (let id = 0; id < work.alive.length; id++) if (work.alive[id]) ids.push(id);
-  const compact = new Map<number, number>();
-  ids.forEach((id, i) => compact.set(id, i));
-  const flat: number[] = [];
-  for (const tri of work.triangles) for (const id of tri) flat.push(compact.get(id)!);
-  const outline = traceOutline(ids.length, flat);
-  let walk = outline.walk.map((i) => ids[i]);
-  const start = walk.indexOf(Math.min(...walk));
-  walk = [...walk.slice(start), ...walk.slice(0, start)];
-  const turn = Math.sign(signedArea(walk.map((id) => [work.pos[id][0], work.pos[id][1]])));
-  if (turn !== sourceTurn) walk = [walk[0], ...walk.slice(1).reverse()];
+  const { ids, walk } = canonicalWalk(work, sourceTurn);
   const onHull = new Set(walk);
   const interiorSource = ids.filter((id) => !onHull.has(id) && id < work.nSource);
   const interiorInserted = ids
@@ -504,6 +585,34 @@ function canonicalise(work: Work, sourceTurn: number, boneRank: Map<string, numb
   return { mesh, order, indexOf };
 }
 
+/**
+ * Step 1 of the canonical order alone: the surviving ids, and the outline walked from its smallest id the way the
+ * source's own hull listing turns — `canonicalise`'s hull, and the walk the early deviation floor (issue #1309) reads
+ * the current outline as. A `MeshError` when the triangles are not one closed outline.
+ */
+function canonicalWalk(work: Work, sourceTurn: number): { ids: number[]; walk: number[] } {
+  const ids: number[] = [];
+  for (let id = 0; id < work.alive.length; id++) if (work.alive[id]) ids.push(id);
+  const compact = new Map<number, number>();
+  ids.forEach((id, i) => compact.set(id, i));
+  const flat: number[] = [];
+  for (const tri of work.triangles) for (const id of tri) flat.push(compact.get(id)!);
+  const outline = traceOutline(ids.length, flat);
+  return { ids, walk: turnedFromSmallest(work, outline.walk.map((i) => ids[i]), sourceTurn) };
+}
+
+/**
+ * A closed walk of working ids rotated to start at its smallest id and, when its signed area does not turn the way
+ * `sourceTurn` does, walked the other way from that id — the one rule `canonicalise` orders its hull by, and the one
+ * the early deviation floor turns its predicted outline by (issue #1309), so the two read one polygon.
+ */
+function turnedFromSmallest(work: Work, loop: readonly number[], sourceTurn: number): number[] {
+  const start = loop.indexOf(Math.min(...loop));
+  const walk = [...loop.slice(start), ...loop.slice(0, start)];
+  const turn = Math.sign(signedArea(walk.map((id) => [work.pos[id][0], work.pos[id][1]])));
+  return turn !== sourceTurn ? [walk[0], ...walk.slice(1).reverse()] : walk;
+}
+
 /** Strongest first, ties by the bone's place in `boneOrder` — the values themselves untouched. */
 function sortBindings(list: readonly Binding[], boneRank: Map<string, number>): Binding[] {
   return list.map((b) => ({ bone: b.bone, weight: b.weight })).sort((p, q) => q.weight - p.weight || (boneRank.get(p.bone) ?? 0) - (boneRank.get(q.bone) ?? 0));
@@ -823,7 +932,14 @@ interface Run {
   keyed: Map<number, { animation: string; ref: AttachmentRef; key: number; time: number }>;
   protectedVertices: Set<number>;
   protectedEdges: Array<[number, number]>;
-  sourceEdges: Set<string>;
+  /** The source's edges, `pairKey` over `work.nSource` (issue #1307). */
+  sourceEdges: Set<number>;
+  /** Issue #1307's audit of the edge sets, or null. */
+  edgeAudit: EdgeSetAudit | null;
+  /** Issue #1309's audit of the early deviation floor against the late one, or null. */
+  floorAudit: FloorAudit | null;
+  /** The current outline's canonical walk, for the working triangles it was read off (issue #1309); null until read. */
+  walk: { triangles: Array<[number, number, number]>; walk: number[] } | null;
   /** 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. */
@@ -1356,8 +1472,17 @@ function refineRegions(run: Run): PhaseEnd {
 // reduction (§1, §6)
 // ---------------------------------------------------------------------------
 
-/** One removal tried: the working triangles after it and the edges it added, or the structural reason it cannot be made. */
-function removalOf(work: Work, v: number): { triangles: Array<[number, number, number]>; added: Array<[number, number]> } | { blocked: string } {
+/**
+ * One removal tried: the working triangles after it and the edges it added — read through `added()`, built only when
+ * read (issue #1307) — or the structural reason it cannot be made.
+ */
+type Removal = { triangles: Array<[number, number, number]>; added: () => Array<[number, number]> } | { blocked: string };
+
+/**
+ * One removal made on `work`'s triangles: the triangles after it — every triangle not touching `v` as it was, the
+ * same tuple, then the hole's new ones, `fresh` — or the structural reason it cannot be made.
+ */
+function removalStep(work: Work, v: number): { triangles: Array<[number, number, number]>; fresh: Array<[number, number, number]> } | { blocked: string } {
   const star = work.triangles.filter((t) => t.includes(v));
   const next = new Map<number, number>();
   const incoming = new Set<number>();
@@ -1398,19 +1523,16 @@ function removalOf(work: Work, v: number): { triangles: Array<[number, number, n
   } else if (!boundary) {
     return { blocked: `retriangulation: vertex ${v} has fewer than three neighbours` };
   }
-  const old = new Set<string>();
-  for (const t of work.triangles) for (let k = 0; k < 3; k++) old.add(edgeKey(t[k], t[(k + 1) % 3]));
-  const added: Array<[number, number]> = [];
-  const seen = new Set<string>();
-  for (const t of fresh) {
-    for (let k = 0; k < 3; k++) {
-      const key = edgeKey(t[k], t[(k + 1) % 3]);
-      if (old.has(key) || seen.has(key)) continue;
-      seen.add(key);
-      added.push([t[k], t[(k + 1) % 3]]);
-    }
-  }
-  return { triangles: [...rest, ...fresh], added };
+  return { triangles: [...rest, ...fresh], fresh };
+}
+
+/** `removalStep` with the edges it adds: those of the hole's new triangles no triangle before it holds, in their order. */
+function removalOf(work: Work, v: number, audit: EdgeSetAudit | null = null): Removal {
+  const step = removalStep(work, v);
+  if ('blocked' in step) return step;
+  const old = work.triangles;
+  const n = work.alive.length;
+  return { triangles: step.triangles, added: () => auditedAdded(audit, `removing ${v}`, addedEdges(old, step.fresh, n), () => addedEdgesByString(old, step.fresh)) };
 }
 
 /** L1 difference of two weight vectors over the bones they name. */
@@ -1447,10 +1569,10 @@ function loadOrder(run: Run): { order: number[]; load: Map<number, number> } {
   const order: number[] = [];
   for (let v = 0; v < work.nSource; v++) {
     if (!work.alive[v] || run.protectedVertices.has(v)) continue;
-    const step = removalOf(work, v);
+    const step = removalOf(work, v, run.edgeAudit);
     let most = 0;
     if ('blocked' in step) most = Infinity;
-    else for (const [a, b] of step.added) most = Math.max(most, edgeLoad(work, a, b));
+    else for (const [a, b] of step.added()) most = Math.max(most, edgeLoad(work, a, b));
     load.set(v, most);
     order.push(v);
   }
@@ -1470,32 +1592,27 @@ function loadOrder(run: Run): { order: number[]; load: Map<number, number> } {
  * structural reason one of the removals cannot be made. The outline loses the run and gains the chord from the
  * vertex before it to the vertex after it; nothing is measured in between.
  */
-function runRemovalOf(work: Work, vertices: readonly number[]): { triangles: Array<[number, number, number]>; added: Array<[number, number]> } | { blocked: string } {
+function runRemovalOf(work: Work, vertices: readonly number[], audit: EdgeSetAudit | null = null): Removal {
   const was = work.triangles;
+  // Issue #1307: each removal's own added edges are never read here, so none is built; what the run adds is read off
+  // the triangles its removals made. A triangle of `after` that no removal made is the same tuple as one of `was`
+  // (`removalStep` keeps every untouched triangle as it was), so every edge it holds is old and it adds nothing.
+  const made = new Set<readonly number[]>();
   let after: Array<[number, number, number]>;
   try {
     for (const v of vertices) {
-      const step = removalOf(work, v);
+      const step = removalStep(work, v);
       if ('blocked' in step) return step;
+      for (const t of step.fresh) made.add(t);
       work.triangles = step.triangles;
     }
     after = work.triangles;
   } finally {
     work.triangles = was;
   }
-  const old = new Set<string>();
-  for (const t of was) for (let k = 0; k < 3; k++) old.add(edgeKey(t[k], t[(k + 1) % 3]));
-  const added: Array<[number, number]> = [];
-  const seen = new Set<string>();
-  for (const t of after) {
-    for (let k = 0; k < 3; k++) {
-      const key = edgeKey(t[k], t[(k + 1) % 3]);
-      if (old.has(key) || seen.has(key)) continue;
-      seen.add(key);
-      added.push([t[k], t[(k + 1) % 3]]);
-    }
-  }
-  return { triangles: after, added };
+  const n = work.alive.length;
+  const label = `removing ${vertices.join(', ')} as one boundary run`;
+  return { triangles: after, added: () => auditedAdded(audit, label, addedEdges(was, after.filter((t) => made.has(t)), n), () => addedEdgesByString(was, after)) };
 }
 
 /**
@@ -1503,7 +1620,20 @@ function runRemovalOf(work: Work, vertices: readonly number[]): { triangles: Arr
  * measurement — a thunk that measures the attempt in full and returns the name the measurement gives, so whatever
  * reads it reads what an unfloored run would have written.
  */
-type Refusal = string | (() => string);
+type Refusal = string | FloorRefusal;
+
+/**
+ * A refusal the deviation floor decided (issue #1279), read since issue #1309 before any structure is built for the
+ * attempt. Reading it names the attempt as the full path does — its structural reason when the structure refuses
+ * it, else the rows' — in the state it was tried in. `decidedByFloor` is what the observer reads: whether the path
+ * before #1309, which read the floor after every structural check, would have been decided by it — so an attempt
+ * the structure refuses reads false, as it did. It is computed only when an observer or the floor audit is attached;
+ * with neither it reads true and nothing reads it.
+ */
+interface FloorRefusal {
+  (): string;
+  decidedByFloor: boolean;
+}
 
 function refusalText(refusal: Refusal): string {
   return typeof refusal === 'string' ? refusal : refusal();
@@ -1563,7 +1693,7 @@ function removeVertices(run: Run): PhaseEnd {
           run.steps++;
           tried++;
           const block = tryOperation(run, members, false);
-          if (run.observe !== null) run.observe({ step: run.steps, kind: 'boundary-run', sourceVertices: [...members], refusedBy: block === null ? null : () => refusalText(block), decidedByFloor: typeof block === 'function', pass, predictedLoad: null });
+          if (run.observe !== null) run.observe({ step: run.steps, kind: 'boundary-run', sourceVertices: [...members], refusedBy: block === null ? null : () => refusalText(block), decidedByFloor: typeof block === 'function' && block.decidedByFloor, pass, predictedLoad: null });
           if (block === null) {
             taken++;
             walk = null;
@@ -1585,7 +1715,7 @@ function removeVertices(run: Run): PhaseEnd {
       run.steps++;
       tried++;
       const block = tryOperation(run, [v], false);
-      if (run.observe !== null) run.observe({ step: run.steps, kind: 'removal', sourceVertices: [v], refusedBy: block === null ? null : () => refusalText(block), decidedByFloor: typeof block === 'function', pass, predictedLoad: ranked === null ? null : ranked.load.get(v)! });
+      if (run.observe !== null) run.observe({ step: run.steps, kind: 'removal', sourceVertices: [v], refusedBy: block === null ? null : () => refusalText(block), decidedByFloor: typeof block === 'function' && block.decidedByFloor, pass, predictedLoad: ranked === null ? null : ranked.load.get(v)! });
       if (block === null) {
         taken++;
         if (accept(run, 'removal', [v])) return { kind: 'replayed' };
@@ -1603,6 +1733,34 @@ function removeVertices(run: Run): PhaseEnd {
   }
 }
 
+/**
+ * Issue #1309: the current outline's canonical walk (`canonicalWalk`), read once per working mesh — the triangles are
+ * replaced, never edited in place, whenever the mesh changes, so the array read off is what the cache is keyed by.
+ */
+function currentWalk(run: Run): number[] {
+  if (run.walk === null || run.walk.triangles !== run.work.triangles) run.walk = { triangles: run.work.triangles, walk: canonicalWalk(run.work, run.sourceTurn).walk };
+  return run.walk.walk;
+}
+
+/**
+ * The deviation floor read before any structure is built for the attempt (issue #1309): `deviationFloor` over the
+ * outline the candidate would have — the current walk less the removed vertices, turned as `canonicalise` turns it
+ * (`turnedFromSmallest`) — rather than over the canonical candidate. Whenever the structure passes, the candidate's
+ * outline is that walk, so the two are the same polygon in the same order and the same number; when it does not, the
+ * attempt is refused whatever the floor reads, and the reader is shown the structure's reason (`floorRefusal`). 0, the
+ * floor of nothing, when no removed vertex is a source-hull vertex (the walk is then not read) or when fewer than three
+ * would remain, which no passing structure leaves. `turned` reports whether the walk was walked the other way.
+ */
+function earlyFloor(run: Run, vertices: readonly number[]): { floor: number; turned: boolean } {
+  const hull = run.input.source.hull;
+  if (!vertices.some((v) => v < hull)) return { floor: 0, turned: false };
+  const rest = currentWalk(run).filter((id) => !vertices.includes(id));
+  if (rest.length < 3) return { floor: 0, turned: false };
+  const outline = turnedFromSmallest(run.work, rest, run.sourceTurn);
+  const turned = outline.length > 2 && outline[1] !== rest[(rest.indexOf(outline[0]) + 1) % rest.length];
+  return { floor: floorOver(run, outline.map((id) => run.work.pos[id]), vertices), turned };
+}
+
 /**
  * The deviation floor (issue #1279): the furthest any removed source-hull vertex lies from the candidate's outline.
  * `MQ_BOUNDARY_DEVIATION` is the symmetric Hausdorff distance between that outline and the source hull, and its
@@ -1611,7 +1769,11 @@ function removeVertices(run: Run): PhaseEnd {
  * `distanceToSegment` over the candidate's hull edges, the function and polygon the row reads.
  */
 function deviationFloor(run: Run, mesh: SourceMesh, vertices: readonly number[]): number {
-  const poly = mesh.points.slice(0, mesh.hull);
+  return floorOver(run, mesh.points.slice(0, mesh.hull), vertices);
+}
+
+/** `deviationFloor` over an outline given as its points in walk order — the one loop both floors read. */
+function floorOver(run: Run, poly: readonly Pt[], vertices: readonly number[]): number {
   let floor = 0;
   for (const v of vertices) {
     if (v >= run.input.source.hull) continue;
@@ -1630,19 +1792,66 @@ function deviationFloor(run: Run, mesh: SourceMesh, vertices: readonly number[])
 const FLOOR_MARGIN = 1e-5;
 
 /**
- * One operation — a single removal, or a boundary run of two or more — tried: null when it was taken (the working
- * mesh then holds it), else what refused it (the working mesh as it was). `full` measures every candidate that
- * reaches the rows; otherwise a candidate whose deviation floor is over the bound by `FLOOR_MARGIN` is refused
- * without the measurement, by a thunk that measures it when its name is read.
+ * Issue #1307's audit of the triangulation's edge set (`EdgeSetAudit`): the plant applied to `edges` in place — so
+ * the decision reads the planted set — then the set held to the string-keyed one, member for member.
  */
-function tryOperation(run: Run, vertices: readonly number[], full: boolean): Refusal | null {
+function auditEdgeSet(audit: EdgeSetAudit, edges: Set<number>, triangles: ReadonlyArray<readonly number[]>, n: number, vertices: readonly number[]): void {
+  if (audit.plant === 'drop-one') {
+    const first = edges.values().next();
+    if (first.done !== true) edges.delete(first.value);
+  }
+  const want = new Set<string>();
+  for (const t of triangles) for (let k = 0; k < 3; k++) want.add(edgeKey(t[k], t[(k + 1) % 3]));
+  audit.edgeSets++;
+  audit.edgeSetEdges += want.size;
+  const missing = [...want].filter((key) => {
+    const [a, b] = key.split(',').map(Number);
+    return !edges.has(pairKey(a, b, n));
+  });
+  if (missing.length > 0 || edges.size !== want.size) {
+    audit.differences.push(`removing ${vertices.join(', ')}: the triangulation's edge set holds ${edges.size} edge(s) against the string construction's ${want.size}${missing.length > 0 ? `, missing ${missing.slice(0, 3).join(' ')}` : ''}`);
+  }
+}
+
+/**
+ * Issue #1309's audit, for the `mesh-compare` suite's control and the population run: on every attempt the floor is
+ * read on, the path before the issue is run beside the early floor — every structural check, then the floor read off
+ * the canonical candidate, decided at `FLOOR_MARGIN` — and compared. Where the structure passes, the two floors are
+ * held equal bit for bit and their decisions equal; where the early floor refuses and the structure would have refused
+ * first, the name a reader of the refusal is shown is held to the structure's, and the observer's `decidedByFloor` to
+ * false. A difference is recorded, not thrown. `plant` is the fault applied to the early refusal: its name read off
+ * the floor (`MQ_BOUNDARY_DEVIATION`), never reaching the structural check that would have refused first. With the
+ * audit and no plant, the call's result is the call's without it.
+ */
+export interface FloorAudit {
+  plant?: 'refusal-named-by-the-floor';
+  /** Attempts the floor was read on. */
+  attempts: number;
+  /** Among them, those whose structure passes — where the early floor and the late one are compared. */
+  compared: number;
+  /** Among those, the ones whose predicted outline `canonicalise` walks the other way from the current walk. */
+  turned: number;
+  /** Attempts the early floor refused, and among them those whose structure refuses them first. */
+  refused: number;
+  refusedStructurally: number;
+  /** Each difference found, named. */
+  differences: string[];
+}
+
+/**
+ * The structure of one operation, as every attempt builds it: the removal or run made (or its structural reason),
+ * condition (b) over the edges it adds, the working mesh set to it, the protected edges looked up, and the canonical
+ * candidate. Null-free: either the reason the structure refuses the operation — the working mesh as it was — or the
+ * canonical candidate with the working mesh holding it and the `undo` that restores it.
+ */
+function structureOf(run: Run, vertices: readonly number[]): string | { canon: Canonical; undo: () => void } {
   const { work, input } = run;
-  const step = vertices.length === 1 ? removalOf(work, vertices[0]) : runRemovalOf(work, vertices);
+  const step = vertices.length === 1 ? removalOf(work, vertices[0], run.edgeAudit) : runRemovalOf(work, vertices, run.edgeAudit);
   if ('blocked' in step) return step.blocked;
   const jump = input.protect.weightJump;
   if (jump !== null) {
-    for (const [a, b] of step.added) {
-      if (a < work.nSource && b < work.nSource && run.sourceEdges.has(edgeKey(a, b))) continue;
+    for (const [a, b] of step.added()) {
+      if (a < work.nSource && b < work.nSource && run.sourceEdges.has(pairKey(a, b, work.nSource))) continue;
       const d = weightJump(work, a, b);
       if (d > jump) return `weightJump (b): the new edge ${a}–${b} joins weight vectors ${r6(d)} apart, over ${jump}`;
     }
@@ -1654,43 +1863,116 @@ function tryOperation(run: Run, vertices: readonly number[], full: boolean): Ref
     work.triangles = was.triangles;
     for (const v of vertices) work.alive[v] = true;
   };
-  const edges = new Set<string>();
-  for (const t of work.triangles) for (let k = 0; k < 3; k++) edges.add(edgeKey(t[k], t[(k + 1) % 3]));
-  for (const [a, b] of run.protectedEdges) {
-    if (!edges.has(edgeKey(a, b))) {
-      undo();
-      return `protect (a): the protected source edge ${a}–${b} is no longer an edge`;
+  // Issue #1307: the triangulation's edge set is built only when a protected edge is looked up in it, keyed by number.
+  if (run.protectedEdges.length > 0) {
+    const n = work.alive.length;
+    const edges = new Set<number>();
+    for (const t of work.triangles) for (let k = 0; k < 3; k++) edges.add(pairKey(t[k], t[(k + 1) % 3], n));
+    if (run.edgeAudit !== null) auditEdgeSet(run.edgeAudit, edges, work.triangles, n, vertices);
+    for (const [a, b] of run.protectedEdges) {
+      if (!edges.has(pairKey(a, b, n))) {
+        undo();
+        return `protect (a): the protected source edge ${a}–${b} is no longer an edge`;
+      }
     }
   }
-  let canon: Canonical;
   try {
-    canon = canonicalise(work, run.sourceTurn, run.boneRank);
+    return { canon: canonicalise(work, run.sourceTurn, run.boneRank), undo };
   } catch (err) {
     if (!(err instanceof MeshError)) throw err;
     undo();
     return `outline: ${err.message}`;
   }
+}
+
+/**
+ * The refusal the early floor makes (issue #1309), through #1279's thunk: read, it measures the attempt in full in the
+ * state it was tried in and returns that path's name — the structure's reason when the structure refuses it, else the
+ * rows'. `late`, when an observer or the floor audit asked for it, is what the structure and the floor read off the
+ * canonical candidate gave: it decides `decidedByFloor` as the path before the issue decided it, and — with an
+ * observer and no floor audit — its structural reason is the name returned, built once rather than twice (the edge
+ * audit counts every list it builds). Under the floor audit the thunk always runs the full path, which is what the
+ * audit holds equal to the structure's reason.
+ */
+function floorRefusal(run: Run, vertices: readonly number[], floor: number, limit: number, late: { structural: string } | { floor: number } | null): FloorRefusal {
+  const members = [...vertices];
+  const said = late !== null && 'structural' in late && run.floorAudit === null ? late.structural : null;
+  const refusal = (() => {
+    if (run.floorAudit?.plant === 'refusal-named-by-the-floor') return `MQ_BOUNDARY_DEVIATION: the deviation floor ${r6(floor)} is over ${run.input.targets.maxBoundaryDeviation}`;
+    if (said !== null) return said;
+    const measured = tryOperation(run, members, true);
+    if (measured === null) {
+      // Unreachable while the floor is a floor: the step was refused on a bound its own rows then pass. Loud,
+      // because the run already went on as if it had been refused.
+      throw new Error(`the deviation floor refused removing ${members.join(', ')}, which the rows accept`);
+    }
+    return refusalText(measured);
+  }) as FloorRefusal;
+  refusal.decidedByFloor = late === null || ('floor' in late && late.floor > limit);
+  return refusal;
+}
+
+/** The path before issue #1309 for one attempt, read beside the early floor: the structure's reason, or the floor read off the canonical candidate. The working mesh is left as it was. */
+function lateOf(run: Run, vertices: readonly number[]): { structural: string } | { floor: number } {
+  const built = structureOf(run, vertices);
+  if (typeof built === 'string') return { structural: built };
+  const floor = deviationFloor(run, built.canon.mesh, vertices);
+  built.undo();
+  return { floor };
+}
+
+/** The floor audit's comparison where the structure passes: the two floors bit for bit, and the decision at `FLOOR_MARGIN`. */
+function auditFloors(audit: FloorAudit, run: Run, vertices: readonly number[], early: { floor: number; turned: boolean }, late: number, refusedEarly: boolean): void {
+  audit.compared++;
+  if (early.turned) audit.turned++;
+  const lateRefuses = late > run.input.targets.maxBoundaryDeviation + FLOOR_MARGIN;
+  if (!Object.is(early.floor, late)) audit.differences.push(`removing ${vertices.join(', ')}: the early floor reads ${early.floor} and the floor off the canonical candidate ${late}`);
+  else if (refusedEarly !== lateRefuses) audit.differences.push(`removing ${vertices.join(', ')}: the early floor ${refusedEarly ? 'refused' : 'passed'} at ${early.floor}, which the floor off the canonical candidate ${lateRefuses ? 'refuses' : 'passes'} at the bound ${run.input.targets.maxBoundaryDeviation} + FLOOR_MARGIN`);
+}
+
+/**
+ * One operation — a single removal, or a boundary run of two or more — tried: null when it was taken (the working
+ * mesh then holds it), else what refused it (the working mesh as it was). `full` measures every candidate that
+ * reaches the rows; otherwise a candidate whose deviation floor is over the bound by `FLOOR_MARGIN` is refused
+ * without the measurement, by a thunk that measures it when its name is read. Since issue #1309 the floor is read
+ * before the structure is built (`earlyFloor`); an attempt it refuses is not built at all unless an observer or the
+ * floor audit asks what the path before would have decided.
+ */
+function tryOperation(run: Run, vertices: readonly number[], full: boolean): Refusal | null {
+  const { input } = run;
+  const floored = !full && run.plant !== 'measure-every-candidate' && !(vertices.length > 1 && run.plant === 'run-skips-rows');
+  const audit = run.floorAudit;
+  let early: { floor: number; turned: boolean } | null = null;
+  if (floored) {
+    const limit = input.targets.maxBoundaryDeviation + (run.plant === 'floor-half-a-pixel-short' ? -0.5 : FLOOR_MARGIN);
+    early = earlyFloor(run, vertices);
+    if (audit !== null) audit.attempts++;
+    if (early.floor > limit) {
+      const late = run.observe !== null || audit !== null ? lateOf(run, vertices) : null;
+      const refusal = floorRefusal(run, vertices, early.floor, limit, late);
+      if (audit !== null && late !== null) {
+        audit.refused++;
+        if ('structural' in late) {
+          audit.refusedStructurally++;
+          const said = refusal();
+          if (said !== late.structural) audit.differences.push(`removing ${vertices.join(', ')}: the early refusal reads "${said.slice(0, 80)}" where the structure refuses first with "${late.structural.slice(0, 80)}"`);
+          if (refusal.decidedByFloor) audit.differences.push(`removing ${vertices.join(', ')}: refused by the structure first, yet the observer would read decidedByFloor`);
+        } else {
+          auditFloors(audit, run, vertices, early, late.floor, true);
+        }
+      }
+      return refusal;
+    }
+  }
+  const built = structureOf(run, vertices);
+  if (typeof built === 'string') return built;
+  const { canon, undo } = built;
+  if (audit !== null && early !== null) auditFloors(audit, run, vertices, early, deviationFloor(run, canon.mesh, vertices), false);
   const phase: SkinningInspection['phase'] = vertices.length > 1 ? 'boundary-run' : 'removal';
   if (vertices.length > 1 && run.plant === 'run-skips-rows') {
     followSkinning(run, phase);
     return null;
   }
-  if (!full && run.plant !== 'measure-every-candidate') {
-    const margin = run.plant === 'floor-half-a-pixel-short' ? -0.5 : FLOOR_MARGIN;
-    if (deviationFloor(run, canon.mesh, vertices) > input.targets.maxBoundaryDeviation + margin) {
-      undo();
-      const members = [...vertices];
-      return () => {
-        const measured = tryOperation(run, members, true);
-        if (measured === null) {
-          // Unreachable while the floor is a floor: the step was refused on a bound its own rows then pass. Loud,
-          // because the run already went on as if it had been refused.
-          throw new Error(`the deviation floor refused removing ${members.join(', ')}, which the rows accept`);
-        }
-        return refusalText(measured);
-      };
-    }
-  }
   const measured = measureAgainstTargets(run, canon.mesh, 'candidate');
   const blocking =
     firstBlockingRow(measured, run.input.targets.artFit) ??
@@ -1841,7 +2123,7 @@ function delaunayFlips(run: Run, plant: ReductionPlant | null): FlipResult {
       const sine = oppositeAngleSine(P[a], P[b], P[c], P[d]);
       if (against ? !(sine > FLIP_MARGIN) : !(sine < -FLIP_MARGIN)) continue;
       if (held(a, b) || held(c, d)) continue;
-      if (jump !== null && !(c < work.nSource && d < work.nSource && run.sourceEdges.has(edgeKey(c, d))) && weightJump(work, c, d) > jump) continue;
+      if (jump !== null && !(c < work.nSource && d < work.nSource && run.sourceEdges.has(pairKey(c, d, work.nSource))) && weightJump(work, c, d) > jump) continue;
       if (flips >= maxFlips) return { bound: `the flip bound n(n - 1)/2 = ${maxFlips} over ${alive} vertices was reached`, flips, sweeps };
       tris[i] = [a, d, c];
       tris[j] = [d, b, c];
@@ -1961,12 +2243,14 @@ export function reduceMeshWith(
   plant: ReductionPlant | null = null,
   observe: AttemptObserver | null = null,
   skinning: SkinningHooks | null = null,
+  edgeAudit: EdgeSetAudit | null = null,
+  floorAudit: FloorAudit | null = null,
 ): MeshReductionResult {
   validateReduction(input, plant);
   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, plant, observe, skinning);
+  return reduceValidated(input, rasters, steps, plant, observe, skinning, edgeAudit, floorAudit);
 }
 
 /**
@@ -1980,6 +2264,8 @@ function reduceValidated(
   plant: ReductionPlant | null = null,
   observe: AttemptObserver | null = null,
   hooks: SkinningHooks | null = null,
+  edgeAudit: EdgeSetAudit | null = null,
+  floorAudit: FloorAudit | null = null,
 ): MeshReductionResult {
   const who = `attachment ${nameOf(input.attachment)}`;
   const src = input.source;
@@ -2047,8 +2333,12 @@ function reduceValidated(
       sourceTriangle: new Map(),
     };
     for (let i = 0; i + 2 < src.triangles.length; i += 3) work.triangles.push([src.triangles[i], src.triangles[i + 1], src.triangles[i + 2]]);
-    const sourceEdges = new Set<string>();
-    for (const t of work.triangles) for (let k = 0; k < 3; k++) sourceEdges.add(edgeKey(t[k], t[(k + 1) % 3]));
+    // The string-keyed set is read once, by `protectionOf`, whose weightJump edges follow its sorted keys; every step
+    // reads the numeric one (issue #1307).
+    const sourceEdgeNames = new Set<string>();
+    for (const t of work.triangles) for (let k = 0; k < 3; k++) sourceEdgeNames.add(edgeKey(t[k], t[(k + 1) % 3]));
+    const sourceEdges = new Set<number>();
+    for (const t of work.triangles) for (let k = 0; k < 3; k++) sourceEdges.add(pairKey(t[k], t[(k + 1) % 3], work.nSource));
     const run: Run = {
       input,
       who,
@@ -2062,8 +2352,11 @@ function reduceValidated(
       observe,
       tally: { sharesDroppedOnGrid: 0, sharesPruned: 0 },
       keyed: keyedSourceVertices(input),
-      ...protectionOf(input, work, sourceEdges),
+      ...protectionOf(input, work, sourceEdgeNames),
       sourceEdges,
+      edgeAudit,
+      floorAudit,
+      walk: null,
       rasters,
       stepRasters: steps,
       skinning: null,