@rig-c/core 2.65.0 → 2.65.2

package/docs/AUTHORING.md

@@ -299,9 +299,12 @@ and it never counts a slot whose bone the posed skin leaves unposed (a `"skin":
 bone the skin does not name, or any bone below one, §3.4.8), which draws no pixel;
 when every drawn slot is such a slot, the render is refused by name (§3.4). Three commands take `--out`: a directory for `render`
 (default `render/`), the `.html` file for `preview` (default `preview.html`) and
-for `vote` (default `ballot.html`). Under `render`'s `--out` each animation is a set
-directory named by the rate (the `--fps` row): `<anim>/` at the default,
-`<anim>@<fps>fps/` at any other — `--fps 24` writes `<anim>@24fps/`, and the default 12 writes `<anim>/`. The line `render` prints for
+for `vote` (default `ballot.html`). Under `render`'s `--out` each render set is a
+directory named by the rate (the `--fps` row): one per animation, `<anim>/` at the default,
+`<anim>@<fps>fps/` at any other — `--fps 24` writes `<anim>@24fps/`, and the default 12 writes `<anim>/`;
+a rig with no animation writes one setup-pose set, `setup/` at the default and
+`setup@<fps>fps/` at any other — `--fps 24` writes `setup@24fps/` — which `frames.json`
+records with `animation: null`. The line `render` prints for
 each set ends in the directory it wrote, and `frames.json` beside the sets names
 each under `sets[].dir` — read the folder from there, not from the animation's name.
 
@@ -5000,7 +5003,10 @@ consumer's, decided by dressing the skeleton rather than by the animation.
   the keys before it, says so. Generate each cycle without its closing key and
   keep that key on the last cycle only: a looping player takes `time % duration`
   and nothing interpolates across the wrap, so a track that stops short of its
-  period holds its last key until it (issue #1506).
+  period holds its last key until it (issue #1506). Two times written within two
+  float32 steps of each other — `1` and `1.00000005` — can be stored as one float,
+  and that refusal says so and names the step rather than calling it a cycle
+  (issue #1525).
 - **Key times are emitted as float32s like every other number, and never stored
   LATER than you wrote them.** Every emitted number is the shortest decimal naming
   its float32 — the text the editor writes, and the precision the runtime keeps,
@@ -7221,7 +7227,7 @@ retain the minimal inputs and report that code rather than inventing author data
 | <a id="CE_COMPILE_CURVE_VALUE_NONFINITE"></a>`CE_COMPILE_CURVE_VALUE_NONFINITE` | “&lt;value&gt; (t=&lt;value&gt;): raw curve holds a non-finite value &lt;value&gt;” | Supply finite numbers in the raw curve array. |
 | <a id="CE_COMPILE_VALUE_TIMELINE_PROPERTY_UNKNOWN"></a>`CE_COMPILE_VALUE_TIMELINE_PROPERTY_UNKNOWN` | “animation "&lt;value&gt;": &lt;value&gt; "&lt;value&gt;" has no property "&lt;value&gt;"” | Use a property present on the named target's timeline family. |
 | <a id="CE_COMPILE_TIMELINE_KEYS_EMPTY"></a>`CE_COMPILE_TIMELINE_KEYS_EMPTY` | “&lt;value&gt;: no keys”<br>Also: “animation "&lt;value&gt;" deform &lt;value&gt;/&lt;value&gt;/&lt;value&gt;”<br>“animation "&lt;value&gt;" events”<br>“animation "&lt;value&gt;" drawOrder”<br>“animation "&lt;value&gt;" slot "&lt;value&gt;" &lt;value&gt;”<br>“animation "&lt;value&gt;" &lt;value&gt; constraint "&lt;value&gt;"”<br>Here the values named in the message include: “default”. | Supply at least one key in the timeline. |
-| <a id="CE_COMPILE_KEY_TIMES_NOT_INCREASING"></a>`CE_COMPILE_KEY_TIMES_NOT_INCREASING` | “&lt;value&gt;: key times must strictly increase — key &lt;value&gt; at t=&lt;value&gt; does not come after key &lt;value&gt; at t=&lt;value&gt; (keys counted from 0)”, and when the two keys share a time and the keys after them repeat the spacing of the keys before them: “. The keys from t=&lt;value&gt; repeat every &lt;value&gt;s, so key &lt;value&gt; closes one cycle and key &lt;value&gt; opens the next at the same time: a phrase that repeats every &lt;value&gt;s ends one key before its period. Generate each cycle without its closing key and keep that key on the last cycle only — a looping player wraps from it to t=0, and a track that stops short holds its last key until the wrap”<br>Also: “animation "&lt;value&gt;" deform &lt;value&gt;/&lt;value&gt;/&lt;value&gt;”<br>“animation "&lt;value&gt;" drawOrder”<br>“animation "&lt;value&gt;" slot "&lt;value&gt;" &lt;value&gt;”<br>“animation "&lt;value&gt;" &lt;value&gt; constraint "&lt;value&gt;"”<br>Here the values named in the message include: “default”. | Order keys by strictly increasing time; the message names both keys of the pair. A phrase generated cycle by cycle with each cycle written from its start to its end repeats every boundary key — drop each cycle's closing key and keep it on the last cycle only (§4.5). |
+| <a id="CE_COMPILE_KEY_TIMES_NOT_INCREASING"></a>`CE_COMPILE_KEY_TIMES_NOT_INCREASING` | “&lt;value&gt;: key times must strictly increase — key &lt;value&gt; at t=&lt;value&gt; does not come after key &lt;value&gt; at t=&lt;value&gt; (keys counted from 0)”, and when the two keys share a time and the keys after them repeat the spacing of the keys before them: “. The keys from t=&lt;value&gt; repeat every &lt;value&gt;s, so key &lt;value&gt; closes one cycle and key &lt;value&gt; opens the next at the same time: a phrase that repeats every &lt;value&gt;s ends one key before its period. Generate each cycle without its closing key and keep that key on the last cycle only — a looping player wraps from it to t=0, and a track that stops short holds its last key until the wrap”; and when the two keys were written at different times that are stored at one float32, or in the wrong order: “. The two were written &lt;value&gt;s apart, within two float32 steps of each other (one step at t=&lt;value&gt; is &lt;value&gt;s), and a key's time is stored as a float32 — the float a written value already names when it is that float's shortest decimal (which can sit above it, as 0.1's does), otherwise the float just below the time written: both are stored at t=&lt;value&gt;” or “key &lt;value&gt; is stored at t=&lt;value&gt;, before key &lt;value&gt; at t=&lt;value&gt;”, then “. Separate them by at least &lt;value&gt;s”<br>Also: “animation "&lt;value&gt;" deform &lt;value&gt;/&lt;value&gt;/&lt;value&gt;”<br>“animation "&lt;value&gt;" drawOrder”<br>“animation "&lt;value&gt;" slot "&lt;value&gt;" &lt;value&gt;”<br>“animation "&lt;value&gt;" &lt;value&gt; constraint "&lt;value&gt;"”<br>Here the values named in the message include: “default”. | Order keys by strictly increasing time; the message names both keys of the pair. A phrase generated cycle by cycle with each cycle written from its start to its end repeats every boundary key — drop each cycle's closing key and keep it on the last cycle only (§4.5). Two times written closer than two float32 steps are stored as one key time — the message says so and names the step; move them apart. |
 | <a id="CE_COMPILE_STEPPED_TIMELINE_EASING"></a>`CE_COMPILE_STEPPED_TIMELINE_EASING` | “&lt;value&gt; key at t=&lt;value&gt; carries [an easing ("&lt;value&gt;") / a curve], and this timeline is stepped by the format — its reader builds no curve, so the mode changes AT the key and holds until the next one. Remove it”<br>Also: “animation "&lt;value&gt;" &lt;value&gt; "&lt;value&gt;" &lt;value&gt;” | Remove easing/curve from the stepped mode timeline. |
 | <a id="CE_COMPILE_TIMELINE_MODE_UNKNOWN"></a>`CE_COMPILE_TIMELINE_MODE_UNKNOWN` | “&lt;value&gt; key at t=&lt;value&gt; names mode &lt;value&gt;; &lt;value&gt;”<br>“known: &lt;value&gt; — the runtime folds the case of the first letter and of nothing else”<br>Also: “animation "&lt;value&gt;" &lt;value&gt; "&lt;value&gt;" &lt;value&gt;”<br>“, ”<br>Here the values named in the message include: “noScaleOrReflection”, “normal”, “onlyTranslation”, “noRotationOrReflection”. | Use a mode named in the timeline's allowed mode list. |
 | <a id="CE_COMPILE_VALUELESS_TIMELINE_VALUE"></a>`CE_COMPILE_VALUELESS_TIMELINE_VALUE` | “&lt;value&gt;: this timeline takes no value; use null”<br>Also: “animation "&lt;value&gt;" &lt;value&gt; "&lt;value&gt;" &lt;value&gt;” | Use null for a timeline that takes no value. |
@@ -11365,10 +11371,27 @@ ambiguous one ends with a sentence saying which reading its figures support:
 
   > loud.png: the best placement found has residual 0.5000, above --max-residual 0.25; part is 200x150 px (span 200 frame px, opaque 1) with texture 0.2473, detail 49.455; 2 candidate(s), best 0.5000, next 0.5000, spread 0.0000 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; the cut (or the search window) is the suspect
 
+- **above the floor, one size in two places** — two copies of an 18x34 checker 0.6 of its span and 6° apart, the shape a left/right pair cut from one drawing reads as:
+
+  > part is 18x34 px (span 36.2 frame px, opaque 1) with texture 0.0221, detail 0.752; 14 candidate(s), best 0.0160, next 0.0162, spread 0.0002 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; every placement in the margin is at the best's scale (within 0.30%, bar 2%) and in another place (the nearest 0.62 span(s) away, bar 0.45), which is the part — or a near-copy, such as a left/right pair cut from one drawing — drawn more than once: read the placements as an unordered set and order it across frames (MOTION.md §2.2 🔀); a --rotation window that excludes one place chooses the answer rather than measuring it
+
 Read the figures, not only the verdict. *Below* says plainness alone explains the
 failure: the cut may be right, and `pose` cannot tell. *Above* says it does not,
 so look at the cut, the `--scale`/`--rotation` window, or — for an ambiguity — at
-whether the frame really holds the part twice. ⚠️ Above the floor is **not** a
+whether the frame really holds the part twice. 🔀 When **every** other place inside
+the margin holds the part at the best's scale — the two bars the sentence prints
+beside the figures it measured — the reading says the frame does hold it more than once and
+names MOTION.md §2.2's unordered set instead of a window: no `--scale` window
+separates two copies of one size, and a `--rotation` window that excludes one place
+*chooses* the answer — both files then place on the other copy, one of them off its
+truth and printed clean. Both bars sit at the geometric middle of the gap measured
+between such repeats and every other ambiguity on the floor's grid (the constants
+`REPEAT_SCALE_RATIO` and `REPEAT_DISTANCE_SPANS` in `src/pose.ts` carry the figures);
+any other ambiguity above the floor keeps the window sentence. A *place* is counted
+once: placements whose centres are closer than the distance bar to a better-scoring
+one — a quarter- or half-turn fit the search keeps at a copy's own centre, or a
+second size read at one spot — are that one's place, and the sentence says how
+many it set aside that way. ⚠️ Above the floor is **not** a
 promise that `pose` will place the part (see the rates below).
 
 **The texture figure.** `legibility.texture` is the mean colour step between
@@ -11513,7 +11536,12 @@ cutoff, and `PO26` holds every polish to strictly descending residuals, read thr
 the same trace. `PO31` places §6's post at the old placement from the page's own
 input bytes, and `PO32` holds it to taking the quarter-rung escape and reading the same twice.
 `PO33` holds the coarse row the tool reads rotations from to the field each seed was
-picked from.
+picked from. `PO34` holds two copies of one part 0.6 span apart to both coming back — and is
+seen red on the quarter-span grid releases before 1.4.0 searched on, which put them on
+one placement — and `PO35` holds the two readings of an ambiguity above the floor to
+their own shapes, each with a forged alternate that moves it to the other — and twins
+a half-turn maps onto themselves to the route, which the window takes back when the
+grouping into places is planted out.
 
 ## 12. Reading the half of that picture `pose` refuses — `rigc chainfit`
 

package/docs/MOTION.md

@@ -234,7 +234,11 @@ frames is your job.** `alternates` non-empty means the answer was not unique;
 `ambiguous` means at least one alternate is inside the margin. Two identical limbs
 look exactly like that, and so does a shape whose silhouette fits itself at more than
 one angle. The instrument has run out — it sees one frame and has no notion of which
-limb is which. A method that works:
+limb is which. A left/right pair cut from one drawing is two files that each fit both
+places, so each comes back with both, and narrowing `--scale` or `--rotation` until one
+place is left picks the answer — it does not read it; the `ambiguous:` reading names
+this route instead of a window when every placement in the margin is one size in
+another place (AUTHORING §11.5). A method that works:
 
 1. **Enumerate the assignments, not the placements.** With k interchangeable
    placements of one part in frame A and k in frame B, there are k! ways to pair them.

package/package.json

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

package/src/cli/shared.ts

@@ -59,6 +59,7 @@ import {
   FRAMES_SIDECAR,
   type PoserName,
   PROTOCOL_FPS,
+  SETUP_POSE_DIR,
   UnframeablePoseError,
 } from '../render_shared.ts';
 import { BallotError } from '../ballot.ts';
@@ -1758,9 +1759,12 @@ export const COMMANDS: CommandDoc[] = [
       out: {
         value: '<dir>',
         meaning:
-          'directory to write the frame series into (default `render/`). Each animation is a set directory under it, named by the rate (see --fps): ' +
+          'directory to write the frame series into (default `render/`). Each render set is a directory under it, named by the rate (see --fps): one per animation, ' +
           `\`${frameSetDir('<anim>', PROTOCOL_FPS)}/\` at the default, \`${frameSetDir('<anim>', 24).split('24').join('<fps>')}/\` at any other — ` +
-          `\`--fps 24\` writes \`${frameSetDir('<anim>', 24)}/\`, and the default ${PROTOCOL_FPS} writes \`${frameSetDir('<anim>', PROTOCOL_FPS)}/\`. ` +
+          `\`--fps 24\` writes \`${frameSetDir('<anim>', 24)}/\`, and the default ${PROTOCOL_FPS} writes \`${frameSetDir('<anim>', PROTOCOL_FPS)}/\`; ` +
+          `a rig with no animation writes one setup-pose set, \`${frameSetDir(SETUP_POSE_DIR, PROTOCOL_FPS)}/\` at the default and ` +
+          `\`${frameSetDir(SETUP_POSE_DIR, 24).split('24').join('<fps>')}/\` at any other — \`--fps 24\` writes \`${frameSetDir(SETUP_POSE_DIR, 24)}/\` — ` +
+          `which ${FRAMES_SIDECAR} records with \`animation: null\`. ` +
           `The line printed for each set ends in the directory it wrote, and ${FRAMES_SIDECAR} beside the sets names each under \`sets[].dir\``,
       },
       fps: {

package/src/compile.ts

@@ -1170,15 +1170,44 @@ function checkKeyTime(where: string, time: number, authored: number, duration: n
  * ⚠️ The repetition is compared in authored seconds within one float32 step of
  * the later key (`float32Step`) — `lag`/`stagger` shift every key of a track by
  * the same amount, so the spacing is the same before and after them.
+ *
+ * 🔒 **Every key after the pair is held to its periodic position, not a window
+ * of them** (issue #1525). The cycle is the `i` keys before the opening key —
+ * key 0 through the closing key `i − 1` — and the key `j` places after the
+ * opening one must sit at `keys[j mod i].t + period × (1 + floor(j / i))`. A
+ * window of `min(i − 1, keys.length − 1 − i)` keys read a phrase of two keys,
+ * a duplicate, then one key on the spacing and one off it — the shape
+ * `0, a, a, 2a, 2a + b` with `b` not `a` — as a cycle, because the key off the
+ * spacing sat past the window. The exam's shape — four cycles of five keys,
+ * each written from its start to its end, so the boundary key repeats at keys
+ * 4/5, 9/10 and 14/15 — still reads as one: the duplicates further on are the
+ * same rule at `j mod i = 0`.
+ *
+ * 🔒 **The cycle sentence needs the two keys to share an AUTHORED time** (issue
+ * #1525), not a stored one: `keyTime` puts a key on the largest float32 not
+ * above its time, so two times the author wrote apart can be stored as the
+ * same float, or the later one below the earlier. That pair is not a boundary
+ * the author repeated, so it gets the clause that says what did happen — the
+ * two authored values, the stored ones, and the float32 step there — and never
+ * the cycle sentence. "Within two steps" rather than one is measured, not
+ * rounded: a time that names its own float (`0.2`) is stored at that float,
+ * which can sit up to half a step above it, so a later time up to one and a
+ * half steps after it is stored at the same float.
  */
-function refuseKeyOrder(where: string, keys: ReadonlyArray<{ t: number }>, i: number, duplicate: boolean): never {
+function refuseKeyOrder(
+  where: string,
+  keys: ReadonlyArray<{ t: number }>,
+  i: number,
+  stored: number,
+  storedBefore: number,
+): never {
   const at = keys[i].t;
   const before = keys[i - 1].t;
   const period = at - keys[0].t;
-  const following = Math.min(i - 1, keys.length - 1 - i);
-  let repeats = duplicate && period > 0 && following >= 1;
-  for (let j = 1; repeats && j <= following; j++) {
-    if (Math.abs(keys[i + j].t - keys[j].t - period) > float32Step(keys[i + j].t)) repeats = false;
+  let repeats = at === before && period > 0 && i + 1 < keys.length;
+  for (let j = 1; repeats && i + j < keys.length; j++) {
+    const expected = keys[j % i].t + period * (1 + Math.floor(j / i));
+    if (Math.abs(keys[i + j].t - expected) > float32Step(keys[i + j].t)) repeats = false;
   }
   const boundary = repeats
     ? `. The keys from t=${keys[0].t} repeat every ${period}s, so key ${i - 1} closes one cycle and key ${i} opens ` +
@@ -1186,9 +1215,17 @@ function refuseKeyOrder(where: string, keys: ReadonlyArray<{ t: number }>, i: nu
       'each cycle without its closing key and keep that key on the last cycle only — a looping player wraps from ' +
       'it to t=0, and a track that stops short holds its last key until the wrap'
     : '';
+  const step = float32Step(stored);
+  const quantised =
+    at > before
+      ? `. The two were written ${at - before}s apart, within two float32 steps of each other (one step at ` +
+        `t=${stored} is ${step}s), and a key's time is stored as a float32 — the float a written value already names when it is that float's shortest decimal (which can sit above it, as 0.1's does), otherwise the float just below the time written: ` +
+        (stored === storedBefore ? `both are stored at t=${stored}` : `key ${i} is stored at t=${stored}, before key ${i - 1} at t=${storedBefore}`) +
+        `. Separate them by at least ${2 * step}s`
+      : '';
   throw new CompileError(
     `${where}: key times must strictly increase — key ${i} at t=${at} does not come after key ${i - 1} at ` +
-      `t=${before} (keys counted from 0)${boundary}`,
+      `t=${before} (keys counted from 0)${boundary}${quantised}`,
     'CE_COMPILE_KEY_TIMES_NOT_INCREASING',
   );
 }
@@ -8151,7 +8188,7 @@ function compileValueTrack(
     const key = track.keys[i];
     const next = track.keys[i + 1];
     const time = keyTime(key.t + shift);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
     // A named-value timeline (`inherit`): the key's `v` is one name, stepped by
     // the format. The name is resolved rather than copied, and what is WRITTEN
@@ -8280,7 +8317,7 @@ function compileDrawOrder(
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     const time = keyTime(key.t);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
     // No offsets = "back to the setup draw order", which is the parser's own
     // encoding for it. An empty array means the same thing and is written the
@@ -8519,7 +8556,7 @@ function compileConstraintTrack(
     const key = keys[i];
     const next = keys[i + 1];
     const time = keyTime(key.t);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
 
     const entry: ModelKey = { time };
@@ -8945,7 +8982,7 @@ function compileSequenceTrack(
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const time = keyTime(key.t);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
     if (key.index !== undefined && key.index >= series.count) {
       throw new CompileError(
@@ -8983,7 +9020,7 @@ function compileDeformTrack(
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     const time = keyTime(key.t);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
     // -- a key that states a MODEL rather than a run (issue #294) ------------
     //
@@ -9695,7 +9732,7 @@ function compileTrack(
     const key = track.keys[i];
     const next = track.keys[i + 1];
     const time = keyTime(key.t + shift);
-    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time === out[i - 1].time);
+    if (i > 0 && time <= (out[i - 1].time as number)) refuseKeyOrder(where, track.keys, i, time, out[i - 1].time as number);
     checkKeyTime(where, time, key.t, duration);
 
     if (shape === 'attachment') {

package/src/core/clipping.ts

@@ -297,13 +297,17 @@ export type TriangleClipper = (polygon: readonly number[], vertices: readonly nu
 /** One step of the draw walk: a slot, what its bone's activity is, and what it shows as the walk reads it. */
 export type DrawStep =
   | { slot: string; kind: 'clip'; attachment: string; active: boolean; end: string | null; polygon: number[]; inverse: boolean; convex: boolean }
-  | { slot: string; kind: 'draw'; attachment: string; vertices: number[]; triangles: number[]; uvs: number[] }
+  | { slot: string; kind: 'draw'; attachment: string; vertices: readonly number[]; triangles: readonly number[]; uvs: readonly number[] }
   | { slot: string; kind: 'none' };
 
-/** The local UVs the oracle hands a region's four corners to the clipper with, in the corner order (bottom-left, upper-left, upper-right, bottom-right). */
-export const REGION_UVS: readonly number[] = [0, 1, 0, 0, 1, 0, 1, 1];
-/** A region's two triangles over its four corners — the runtime's quad triangulation (`src/render.ts`'s `QUAD_TRIANGLES`). */
-export const REGION_TRIANGLES: readonly number[] = [0, 1, 2, 2, 3, 0];
+/**
+ * The local UVs the oracle hands a region's four corners to the clipper with, in the corner order (bottom-left, upper-left, upper-right, bottom-right).
+ * Frozen (issue #1530): every drawn region of every pose hands out this one array (`rawDrawn` in `./raw.ts`), so a write to it would reach every
+ * frame a consumer holds — frozen, the write throws instead.
+ */
+export const REGION_UVS: readonly number[] = Object.freeze([0, 1, 0, 0, 1, 0, 1, 1]);
+/** A region's two triangles over its four corners — the runtime's quad triangulation (`src/render.ts`'s `QUAD_TRIANGLES`). Frozen, as `REGION_UVS` is and for its reason. */
+export const REGION_TRIANGLES: readonly number[] = Object.freeze([0, 1, 2, 2, 3, 0]);
 
 /** `clipThrough`'s shape, replaceable by the render suite's plants (`RC08`'s dropped region). */
 export type ShapeClipper = (shape: ClipShape, vertices: readonly number[], triangles: readonly number[], uvs: readonly number[]) => ClipResult | null;

package/src/core/index.ts

@@ -176,7 +176,7 @@ import type { ModelAtlasRect, ModelBone, ModelEditorOrder, ModelPage, ModelPageR
 import { worldTransforms, type CoreWorld } from './world.ts';
 import { readAnimationTimelines, type CoreAnimationTimelines } from './animation.ts';
 import { readEventDefs, type CoreEventDef } from './events.ts';
-import { poseGeometry, readGeometry, type CoreAttachmentRow, type CoreClipRow, type CoreGeometry, type DrawWalk, type RegionPoser, type ShownGeometry, type VertexPoser } from './vertices.ts';
+import { poseGeometry, readGeometry, type CoreAttachmentRow, type CoreClipRow, type CoreGeometry, type DrawWalk, type MeshArraysOf, type RegionPoser, type ShownGeometry, type VertexPoser } from './vertices.ts';
 import type { CoreClippedRow, ShapeClipper, TriangleClipper } from './clipping.ts';
 import { applyConstraints, constraintsAbsentWhy, readConstraintRecord, readConstraintTimelines, solverRules, type ConstraintPlant, type CoreConstraintRecord, type CoreConstraintTimelines, type SolverRules } from './constraints.ts';
 import { readPathRecord } from './constraints_path.ts';
@@ -1077,6 +1077,8 @@ export interface CorePlant {
   region?: RegionPoser;
   /** A vertex array's world positions (`worldVertices` in `./vertices.ts`). */
   vertices?: VertexPoser;
+  /** A drawn mesh's read-only UVs and triangles (`meshArraysOf` in `./vertices.ts`) — the raw entry's `drawn`; nothing but a control passes one. */
+  meshArrays?: MeshArraysOf;
   /** The ik, transform and path constraints as posed, rewritten before they are applied (`./constraints.ts`). */
   constraints?: ConstraintPlant;
   /** Issue #979's solver rules, one planted back to the reading before it (`RUNTIME_SOLVER_RULES` in `./constraints.ts`). */

package/src/core/raw.ts

@@ -121,7 +121,7 @@ import { attachmentStates } from './deform.ts';
 import { drawOrderAt, type CoreDrawOrderKey } from './draw_order.ts';
 import { eventsFired, type CoreEventRow } from './events.ts';
 import { REGION_TRIANGLES, REGION_UVS, type CoreClippedRow, type ShapeClipper } from './clipping.ts';
-import { poseGeometry, type CoreAttachmentRow, type CoreClipRow, type ShownGeometry } from './vertices.ts';
+import { meshArraysOf, poseGeometry, type CoreAttachmentRow, type CoreClipRow, type ShownGeometry } from './vertices.ts';
 import { RUNTIME_DEG, type CoreWorld } from './world.ts';
 import type { SliderApplication } from './constraints_slider.ts';
 
@@ -148,8 +148,10 @@ export interface RawDrawn {
   attachment: string;
   kind: 'region' | 'mesh';
   vertices: number[];
-  uvs: number[];
-  triangles: number[];
+  /** Frozen, and the same array on every pose of the document view (issue #1530): `REGION_UVS` for a region, `meshArraysOf` for a mesh. */
+  uvs: readonly number[];
+  /** Frozen and identity-stable, as `uvs` is. */
+  triangles: readonly number[];
   hull: number | null;
   sequenceIndex: number;
   colour: [number, number, number, number];
@@ -363,11 +365,11 @@ function drawnGeometry(doc: CompiledDocument, shown: readonly ShownGeometry[], w
  * maps it as before where it does, so A10 reads the same values either way.
  * What makes the row's array safe to keep past the step — A10 collects an
  * animation's 120 frames before it scans one — is that it is the pose's own:
- * `poseGeometry` (`./vertices.ts`) builds every row's vertices with
- * `.map(round)` over the corners or the skinned vertices it just computed, a
- * new array per attachment per pose, held by nothing but the row. The core
- * suite's `CO45` plants a poser that hands every pose the same array and reads
- * the retained frames red.
+ * `poseGeometry` (`./vertices.ts`) hands every row the corners or the skinned
+ * vertices the poser just computed, a new array per attachment per pose, or a
+ * rounded copy of it (`roundedRow`, issue #1530), held by nothing but the row.
+ * The core suite's `CO45` plants a scan that hands every pose the same array
+ * and `CO59` a poser that does, and both read the retained frames red.
  */
 function scanDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode, scanPlant: ScanPlant = {}): ScanDrawn[] {
   const { rows } = drawnGeometry(doc, shown, world, order, plant, mode);
@@ -385,6 +387,23 @@ function scanDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world
   return drawn;
 }
 
+/**
+ * A row's numbers as the pose hands them on (issue #1530): the row's own
+ * array wherever it holds no `null` — `numberOf` is then the identity on
+ * every one of them, under either mode — and mapped through `numberOf` as
+ * before where it does, so a raw walk refuses the same value by the same
+ * name and a kept one turns it into NaN. The row's array is the pose's own:
+ * `poseGeometry` (`./vertices.ts`, `roundedRow`) hands each row the array
+ * the poser just built or a fresh rounded copy of it, and `poseClipped` maps
+ * every clipped row into a new array; nothing else holds one, so a frame a
+ * consumer keeps is not written by the next pose. The core suite's
+ * retained-frame control plants a poser that keeps one buffer per slot and
+ * reads the kept frames red.
+ */
+function numbersOf(values: Array<number | null>, what: string, mode: WalkMode): number[] {
+  return allNumbers(values) ? values : values.map((v) => numberOf(v, what, mode));
+}
+
 /** Whether a row's vertices hold no `null` — what `numberOf` would map — so the row's own array can be handed on as numbers. */
 function allNumbers(values: Array<number | null>): values is number[] {
   for (const v of values) if (v === null) return false;
@@ -417,24 +436,23 @@ function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world:
     if (row === undefined || row[0] !== s.slot) throw new CoreInputError(`slot "${s.slot}": the attachment rows are not in the shown records' order`);
     const record = doc.skins.find((x) => x.name === s.skin)?.attachments[s.slot]?.[s.placeholder];
     const colour = record?.color === undefined ? ([1, 1, 1, 1] as [number, number, number, number]) : readColour(record.color);
-    let uvs: number[];
-    let triangles: number[];
+    let uvs: readonly number[];
+    let triangles: readonly number[];
     let hull: number | null = null;
     if (g.kind === 'region') {
-      uvs = [...REGION_UVS];
-      triangles = [...REGION_TRIANGLES];
+      uvs = REGION_UVS;
+      triangles = REGION_TRIANGLES;
     } else {
       const source = g.kind === 'mesh' ? g : doc.skins.find((x) => x.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
       if (source === undefined || source.kind !== 'mesh') throw new CoreInputError(`slot "${s.slot}": the linked mesh's source carries no mesh`);
-      uvs = [...source.uvs];
-      triangles = [...source.triangles];
+      ({ uvs, triangles } = (plant.meshArrays ?? meshArraysOf)(source));
       hull = source.hull ?? null;
     }
     const sequenceIndex = s.frame ?? record?.sequenceSetup ?? 0;
-    drawn.push({ slot: s.slot, attachment: row[1], kind: row[2], vertices: row[3].map((v) => numberOf(v, `vertex of slot "${s.slot}"`, mode)), uvs, triangles, hull, sequenceIndex, colour });
+    drawn.push({ slot: s.slot, attachment: row[1], kind: row[2], vertices: numbersOf(row[3], `vertex of slot "${s.slot}"`, mode), uvs, triangles, hull, sequenceIndex, colour });
   }
-  const clips = geometry.clips.map((c): RawClip => [c[0], c[1], c[2], c[3].map((v) => numberOf(v, `clip vertex of slot "${c[0]}"`, mode))]);
-  const clipped = geometry.drawnClipped.map((c): RawClipped => [c[0], c[1], c[2], c[3].map((v) => numberOf(v, `clipped vertex of slot "${c[0]}"`, mode)), c[4].map((v) => numberOf(v, `clipped uv of slot "${c[0]}"`, mode)), c[5]]);
+  const clips = geometry.clips.map((c): RawClip => [c[0], c[1], c[2], numbersOf(c[3], `clip vertex of slot "${c[0]}"`, mode)]);
+  const clipped = geometry.drawnClipped.map((c): RawClipped => [c[0], c[1], c[2], numbersOf(c[3], `clipped vertex of slot "${c[0]}"`, mode), numbersOf(c[4], `clipped uv of slot "${c[0]}"`, mode), c[5]]);
   return { drawn, clips, clipped };
 }
 

package/src/core/vertices.ts

@@ -147,6 +147,41 @@ export type CoreGeometry =
   | { kind: 'boundingbox'; vertices: ModelVertices }
   | { kind: 'path'; vertices: ModelVertices; closed: boolean; constantSpeed: boolean; lengths: number[] };
 
+/** A mesh's geometry as the document view files it — what `meshArraysOf` keys on. */
+export type CoreMeshGeometry = Extract<CoreGeometry, { kind: 'mesh' }>;
+
+/** A mesh's UVs and triangles as a pose hands them out: read-only, and the same arrays on every pose. */
+export interface MeshArrays {
+  readonly uvs: readonly number[];
+  readonly triangles: readonly number[];
+}
+
+/** What hands out a mesh's `MeshArrays`: `meshArraysOf` unless a control passes another (the core suite's shared-array control). */
+export type MeshArraysOf = (mesh: CoreMeshGeometry) => MeshArrays;
+
+/** Each mesh geometry's frozen arrays, keyed on the document view's own geometry object, which no reader writes. */
+const meshArraysByGeometry = new WeakMap<CoreMeshGeometry, MeshArrays>();
+
+/**
+ * A mesh's UVs and triangles, copied once per geometry object and frozen
+ * (issue #1530). The raw entry used to spread both into new arrays on every
+ * pose for every drawn mesh, so that a consumer writing into a pose's arrays
+ * could not reach the document's; frozen, a write throws instead, and every
+ * pose of every walk and track over the same document view hands out the
+ * same two arrays — so a consumer keyed on them by identity reuses what it
+ * built from them. The copy is what keeps the document's own arrays out of a
+ * consumer's hands: they are the reader's, and freezing them would write to
+ * a value the caller passed in.
+ */
+export function meshArraysOf(mesh: CoreMeshGeometry): MeshArrays {
+  let kept = meshArraysByGeometry.get(mesh);
+  if (kept === undefined) {
+    kept = Object.freeze({ uvs: Object.freeze([...mesh.uvs]), triangles: Object.freeze([...mesh.triangles]) });
+    meshArraysByGeometry.set(mesh, kept);
+  }
+  return kept;
+}
+
 /** One row of `setup.attachments`: `[slot, attachment, kind, vertices]`, the oracle's row. */
 export type CoreAttachmentRow = [string, string, 'region' | 'mesh', Array<number | null>];
 /** One row of `setup.clips`: `[slot, attachment, end, polygon]`, the oracle's row. */
@@ -220,6 +255,46 @@ export function worldVertices(vertices: ModelVertices, bone: CoreWorld, world: R
   return out;
 }
 
+/**
+ * `worldVertices(deformedVertices(vertices, deform), bone, world, EXACT_COORDS)`
+ * in one pass (issue #1530): the same operations on the same numbers in the
+ * same order — an unweighted vertex's coordinates are the deform array's,
+ * read as they are; a weighted binding's are its float32 coordinate plus the
+ * deform's pair, its weight through `Math.fround` — without building the
+ * deformed array (and, weighted, one binding record per influence) on every
+ * pose only to map it again. A planted vertex poser still reads the deformed
+ * array (`poseGeometry`). Posed output is held equal by the core gate's
+ * sample attachments and by `tools/posed_frames.ts` across the change.
+ */
+export function deformedWorldVertices(vertices: ModelVertices, deform: readonly number[], bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>): number[] {
+  const out: number[] = [];
+  if (!vertices.weighted) {
+    for (let i = 0; i + 1 < deform.length; i += 2) {
+      const x = deform[i];
+      const y = deform[i + 1];
+      out.push(x * bone.a + y * bone.b + bone.worldX, x * bone.c + y * bone.d + bone.worldY);
+    }
+    return out;
+  }
+  let k = 0;
+  for (const influences of vertices.bindings) {
+    let wx = 0;
+    let wy = 0;
+    for (const binding of influences) {
+      const t = world.get(binding.bone);
+      if (t === undefined) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
+      const x = Math.fround(binding.x) + deform[k];
+      const y = Math.fround(binding.y) + deform[k + 1];
+      k += 2;
+      const weight = Math.fround(binding.weight);
+      wx += (x * t.a + y * t.b + t.worldX) * weight;
+      wy += (x * t.c + y * t.d + t.worldY) * weight;
+    }
+    out.push(wx, wy);
+  }
+  return out;
+}
+
 const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
 const finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);
 const RECT_FIELDS = ['width', 'height', 'offsetX', 'offsetY', 'originalWidth', 'originalHeight'] as const;
@@ -397,6 +472,32 @@ export interface ShownGeometry {
   frame?: number;
 }
 
+/**
+ * A row's numbers: `values` through `round`, as `values.map(round)` writes
+ * them — and `values` itself, not a copy, where `round` leaves every one of
+ * them the same number (`Object.is`, so a `-0` the round writes as `0` is a
+ * change). Issue #1530: the raw entry's `rawNumber` is the identity on every
+ * finite double but `-0`, so on every pose that drew a finite attachment the
+ * map was a second array of the same numbers, per attachment per pose. The
+ * array handed in is the poser's own (`regionCorners` and `worldVertices`
+ * build a fresh one per call, and so does the deform path's
+ * `deformedWorldVertices`), held by nothing but this call, so the row may own it; the
+ * draw walk's step reads the same array and writes nothing into it
+ * (`DrawStep`'s arrays are readonly). A planted poser that hands out an array
+ * it keeps is the shape the core suite's retained-frame control plants.
+ */
+export function roundedRow(values: number[], round: (v: number) => number | null): Array<number | null> {
+  for (let i = 0; i < values.length; i++) {
+    const r = round(values[i]);
+    if (Object.is(r, values[i])) continue;
+    const out: Array<number | null> = values.slice(0, i);
+    out.push(r);
+    for (let j = i + 1; j < values.length; j++) out.push(round(values[j]));
+    return out;
+  }
+  return values;
+}
+
 /** Resolves a linked mesh's source to its vertex array, or names why not. */
 export type SourceOf = (skin: string, slot: string, source: string) => ModelVertices | string;
 
@@ -409,7 +510,7 @@ export type SourceOf = (skin: string, slot: string, source: string) => ModelVert
 export interface DrawWalk {
   order: readonly string[];
   active: ReadonlySet<string>;
-  meshOf: (skin: string, slot: string, source: string) => { uvs: number[]; triangles: number[] } | undefined;
+  meshOf: (skin: string, slot: string, source: string) => { uvs: readonly number[]; triangles: readonly number[] } | undefined;
   clip?: TriangleClipper;
   /** What the drawn rows are cut through (`clipThrough`), replaceable by the render suite's plants. */
   through?: ShapeClipper;
@@ -436,38 +537,44 @@ export function poseGeometry(
   const attachments: CoreAttachmentRow[] = [];
   const clips: CoreClipRow[] = [];
   const nulls: string[] = [];
+  // Issue #1530: the draw walk cuts drawn attachments through the clips the pose shows, and with none shown it cuts nothing — `poseClipped`
+  // over a walk with no clip step returns no row and no reason — so the walk's steps are built only where a clip is shown.
+  const walked = draw !== undefined && shown.some((s) => s.geometry.kind === 'clipping');
   const steps = new Map<string, DrawStep>();
   for (const s of shown) {
     const bone = world.get(s.bone);
     if (bone === undefined) throw new Error(`slot "${s.slot}": bone "${s.bone}" has no world transform`);
     const g = s.geometry;
     // A deform array replaces the stored vertices, its coordinates read as they are (`./deform.ts`).
-    const drawn = (v: ModelVertices): number[] => (s.deform === undefined ? vertices(v, bone, world) : vertices(deformedVertices(v, s.deform), bone, world, EXACT_COORDS));
+    // Unplanted, the deformed positions are read in one pass (`deformedWorldVertices`, issue #1530) rather than through a deformed copy of the array.
+    const deform = s.deform;
+    const drawn = (v: ModelVertices): number[] => (deform === undefined ? vertices(v, bone, world) : plant.vertices === undefined ? deformedWorldVertices(v, deform, bone, world) : vertices(deformedVertices(v, deform), bone, world, EXACT_COORDS));
     if (g.kind === 'region') {
       const rect = s.frame === undefined ? g.region.atlas : (g.region.frames?.[s.frame] ?? g.region.atlas);
       if (rect === null) {
         nulls.push(`slot "${s.slot}" shows region "${s.name}" (skin "${s.skin}", placeholder "${s.placeholder}")`);
         continue;
       }
-      const corners = region({ ...g.region, atlas: rect }, bone);
-      attachments.push([s.slot, s.name, 'region', corners.map(round)]);
-      steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: corners, triangles: [...REGION_TRIANGLES], uvs: [...REGION_UVS] });
+      // The record's own geometry wherever the rectangle drawn is its own (no series frame): the same fields, without a copy per pose.
+      const corners = region(rect === g.region.atlas ? (g.region as CoreRegionGeometry & { atlas: ModelAtlasRect }) : { ...g.region, atlas: rect }, bone);
+      attachments.push([s.slot, s.name, 'region', roundedRow(corners, round)]);
+      if (walked) steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: corners, triangles: REGION_TRIANGLES, uvs: REGION_UVS });
     } else if (g.kind === 'mesh') {
       const world = drawn(g.vertices);
-      attachments.push([s.slot, s.name, 'mesh', world.map(round)]);
-      steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: world, triangles: g.triangles, uvs: g.uvs });
+      attachments.push([s.slot, s.name, 'mesh', roundedRow(world, round)]);
+      if (walked) steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: world, triangles: g.triangles, uvs: g.uvs });
     } else if (g.kind === 'linkedmesh') {
       const source = sourceOf(g.skin, g.slot, g.source);
       if (typeof source === 'string') throw new Error(`slot "${s.slot}": ${source} (readModel refuses it first)`);
       const world = drawn(source);
-      attachments.push([s.slot, s.name, 'mesh', world.map(round)]);
+      attachments.push([s.slot, s.name, 'mesh', roundedRow(world, round)]);
       // A linked mesh draws its source's triangles over its source's UVs.
       const mesh = draw?.meshOf(g.skin, g.slot, g.source);
       if (draw !== undefined && mesh === undefined) throw new Error(`slot "${s.slot}": the linked mesh's source "${g.source}" carries no triangles (readModel refuses it first)`);
-      if (mesh !== undefined) steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: world, triangles: mesh.triangles, uvs: mesh.uvs });
+      if (walked && mesh !== undefined) steps.set(s.slot, { slot: s.slot, kind: 'draw', attachment: s.name, vertices: world, triangles: mesh.triangles, uvs: mesh.uvs });
     } else if (g.kind === 'clipping') {
       const polygon = drawn(g.vertices);
-      clips.push([s.slot, s.name, g.end, polygon.map(round)]);
+      clips.push([s.slot, s.name, g.end, roundedRow(polygon, round)]);
       steps.set(s.slot, { slot: s.slot, kind: 'clip', attachment: s.name, active: draw?.active.has(s.bone) ?? false, end: g.end, polygon, inverse: g.inverse, convex: g.convex });
     }
   }
@@ -478,7 +585,12 @@ export function poseGeometry(
   let clippedWhy: string | null = draw === undefined ? 'the draw order was not given' : attachmentsWhy;
   let drawnClipped: CoreClippedRow[] | null = null;
   let drawnClippedWhy: string | null = clippedWhy;
-  if (draw !== undefined && attachmentsWhy === null) {
+  if (draw !== undefined && attachmentsWhy === null && !walked) {
+    clipped = [];
+    clippedWhy = null;
+    drawnClipped = [];
+    drawnClippedWhy = null;
+  } else if (draw !== undefined && attachmentsWhy === null) {
     const walk = draw.order.map((slot): DrawStep => steps.get(slot) ?? { slot, kind: 'none' });
     const posed = poseClipped(walk, round, draw.clip, draw.through);
     clipped = posed.rows;

package/src/pose.ts

@@ -185,7 +185,7 @@ export const COARSE_STRIDE_FRACTION = 0.125;
  * trials found rather than 226, and 12 that placed on the old grid lost rather
  * than 9 (both at three minima per rung).
  */
-const COARSE_SUPPRESSION_CELLS = 4;
+export const COARSE_SUPPRESSION_CELLS = 4;
 
 /** How many scale rungs one octave gets in the coarse ladder. */
 export const SCALE_STEPS_PER_OCTAVE = 3;
@@ -254,7 +254,27 @@ export const BACKGROUND_BORDER_SHARE = 0.6;
  * carries it: 227 trials found against 226 at three, none lost, and a CPU cost
  * inside the grid's run-to-run noise.
  */
-const MINIMA_PER_SCALE = 5;
+export const MINIMA_PER_SCALE = 5;
+
+/**
+ * The three numbers that decide which basins the coarse pass sends down —
+ * `COARSE_STRIDE_FRACTION`, `COARSE_SUPPRESSION_CELLS`, `MINIMA_PER_SCALE` — as
+ * one value, so a control can run the search on the grid an earlier release
+ * used and show what the current one buys (issue #1519). See
+ * `PoseOptions.coarseGrid`.
+ */
+export interface PoseCoarseGrid {
+  strideFraction: number;
+  suppressionCells: number;
+  minimaPerScale: number;
+}
+
+/** The grid every caller gets — the three constants above, unchanged. */
+export const COARSE_GRID: PoseCoarseGrid = {
+  strideFraction: COARSE_STRIDE_FRACTION,
+  suppressionCells: COARSE_SUPPRESSION_CELLS,
+  minimaPerScale: MINIMA_PER_SCALE,
+};
 
 /**
  * How many candidates survive each refinement level.
@@ -387,6 +407,117 @@ export function floorClause(): string {
   return `detail ${POSE_FLOOR.detail}, measured from ${POSE_FLOOR.span} px up`;
 }
 
+/**
+ * When an ambiguity is ONE part fitting several places at one size — the
+ * reading a left/right pair cut from one drawing gives, which no window
+ * resolves (issue #1519).
+ *
+ * Both bars are read off the measured gap between the two populations, and
+ * each sits at that gap's geometric middle — the same rule for both, so neither
+ * is a number chosen to make one case come out:
+ *
+ * - **Scale**, as `|alternate / best − 1|` and over EVERY alternate inside the
+ *   margin. Same-size repeats measured 0.00001–0.00034 (a pair of legs and a pair
+ *   of ears in a picture rendered from a rig), 0.0030 (the selftest's twin
+ *   fixture, PO34) and 0.0055 (the pose fixture's mirrored arms, PO02). Every
+ *   other ambiguous part above the floor on `tools/pose_floor.ts`'s 420 trials
+ *   had an alternate at least 0.0719 off its best's scale — two scales at one
+ *   spot — and so did a pair of eyes read at 1.000 and 0.922. √(0.0055 × 0.0719)
+ *   ≈ 0.020.
+ * - **Distance**, from the best's centre to the nearest alternate's, over the
+ *   part's span at the best's scale. On that grid every other alternate above
+ *   the floor sat within 0.336 span of its best — two readings of one spot — or
+ *   2.26 spans or more away at a scale more than 20% off, which the scale bar
+ *   already separates; the closest repeat measured was the legs at 0.603.
+ *   √(0.336 × 0.603) ≈ 0.45.
+ *
+ *   📍 It is also the radius `repeatedPlaces` groups the margin into places by
+ *   (issue #1526), so it was measured again over every PAIR in a margin rather
+ *   than only pairs with the best. Over the 41 above-floor ambiguities of the
+ *   same 420 trials, every pair closer than 0.45 span was at most 0.336 apart —
+ *   one spot read at two scales, or turned, down to 0.000 for a half-turn — and
+ *   every farther pair at least 0.779, save one trial: a 24 px gun whose pairs
+ *   run on from 0.06 to 3.4 spans at scales up to 77% apart, which reads the
+ *   window sentence at every radius from 0 to 3 because the scale bar fails it.
+ *   The grid's readings came out the same at every radius in that range, so
+ *   nothing there moves the gap's middle; the repeats bound it from above
+ *   exactly as before.
+ *
+ * ⚠️ One grid trial above the floor takes this branch and is not a repeat: a
+ * blurred 48 px shin whose four placements all stopped on the scale FLOOR of the
+ * default window, at 0.5 against a truth at 1.0. Every placement on one wall has
+ * one scale by construction. Its console line marks the wall beside the value,
+ * which is the first thing to move; nothing in the alternates alone separates it
+ * from a repeat — a pair of ears in the same picture also sat on a scale floor.
+ */
+export const REPEAT_SCALE_RATIO = 0.02;
+export const REPEAT_DISTANCE_SPANS = 0.45;
+
+/** How an ambiguity's placements stand to the best one, when they are one part in several places at one size. */
+export interface PoseRepeat {
+  /** The largest `|place.scale / best.scale − 1|` over the other places, each read at its best-scoring placement. */
+  scaleRatio: number;
+  /** The nearest other place's centre distance from the best's, in spans at the best's scale. */
+  spans: number;
+  /**
+   * Placements in the margin counted as a place already counted rather than as
+   * a place of their own — a quarter- or half-turn fit at the same centre, or a
+   * second size read at one spot (issue #1526).
+   */
+  samePlace: number;
+}
+
+/**
+ * Whether every OTHER PLACE in the margin holds the part at the SAME scale as
+ * the best, against `REPEAT_SCALE_RATIO` and `REPEAT_DISTANCE_SPANS` — `null`
+ * when one does not, or there is no other place. `span` is the part's longest
+ * material side in frame pixels at the best placement's scale.
+ *
+ * 📍 The margin is grouped into places first (issue #1526): walked best-scoring
+ * first, a placement whose centre is closer than `samePlaceSpans` spans to a
+ * place already counted is counted with it, and every other one opens a place
+ * of its own, read at that placement. The bars then apply to the places other
+ * than the best's own. Without the grouping, a fit the search keeps on purpose —
+ * the quarter- and half-turn polish of its primary candidate, at the primary's
+ * own centre — sat 0 spans from the best, the nearest distance went to 0, and a
+ * part drawn twice read the window sentence: the one remedy that can take the
+ * turned duplicate away and leave the two copies unresolved.
+ *
+ * ⚠️ The grouping radius defaults to `REPEAT_DISTANCE_SPANS` and is not a
+ * second number, because it is the same question asked of the same
+ * populations — *is this placement in another place than that one?* — which the
+ * distance bar already decides between an alternate and the best. Its
+ * measurement over every PAIR in the margin, not only pairs with the best, is
+ * beside the constant.
+ *
+ * ⭐ Exported so the selftest can hand it a forged alternate and watch the
+ * reading change branch, and plant the grouping out: at `samePlaceSpans` 0 no
+ * two centres are closer than the radius, every alternate is its own place, and
+ * the bars read the minimum over all of them — issue #1519's reading. The search
+ * calls it with exactly what it reported.
+ */
+export function repeatedPlaces(
+  best: PosePlacement,
+  alternates: readonly PosePlacement[],
+  span: number,
+  samePlaceSpans: number = REPEAT_DISTANCE_SPANS,
+): PoseRepeat | null {
+  if (alternates.length === 0 || !(span > 0)) return null;
+  // Best-scoring first, so a place is read at its best placement. The margin
+  // comes sorted that way already; a forged list need not.
+  const places: PosePlacement[] = [best];
+  let samePlace = 0;
+  for (const alt of [...alternates].sort((a, b) => a.residual - b.residual)) {
+    if (places.some((p) => hypot2(alt.x - p.x, alt.y - p.y) < samePlaceSpans * span)) samePlace++;
+    else places.push(alt);
+  }
+  const others = places.slice(1);
+  if (others.length === 0) return null;
+  const scaleRatio = Math.max(...others.map((a) => Math.abs(a.scale / best.scale - 1)));
+  const spans = Math.min(...others.map((a) => hypot2(a.x - best.x, a.y - best.y) / span));
+  return scaleRatio <= REPEAT_SCALE_RATIO && spans >= REPEAT_DISTANCE_SPANS ? { scaleRatio, spans, samePlace } : null;
+}
+
 /**
  * The sentence that tells "the part is wrong" from "the part is too small or too
  * plain for `pose`", with every figure it rests on (issue #857).
@@ -394,7 +525,11 @@ export function floorClause(): string {
  * ⭐ Exported for the reason `windowEdgeNote` is: the guide quotes it, and a
  * message and the document teaching it must be built from one place.
  */
-export function legibilityReading(l: Omit<PoseLegibility, 'reading'>, verdict: 'refused' | 'ambiguous'): string {
+export function legibilityReading(
+  l: Omit<PoseLegibility, 'reading'>,
+  verdict: 'refused' | 'ambiguous',
+  repeat: PoseRepeat | null = null,
+): string {
   const figures =
     `part is ${l.width}x${l.height} px (span ${l.span} frame px, opaque ${l.opaqueShare}) with texture ${l.texture}, ` +
     `detail ${l.detail}; ` +
@@ -425,12 +560,35 @@ export function legibilityReading(l: Omit<PoseLegibility, 'reading'>, verdict: '
   // blurred goggles and gun from 128 px and rear shin at 48 px — five of them
   // 2.1–2.7 px off, the rear shin 19 px. So the sentence names that reading
   // too, with the one remedy that separates it: a window.
+  //
+  // 🔀 Except when the placements are one size in different places (issue
+  // #1519). Measured on a picture holding a left/right pair cut from one
+  // drawing: no --scale window separated them, narrower or wider, because they
+  // ARE one scale, and every --rotation window that "resolved" them did so by
+  // excluding one place — after which both files placed on the other, one of
+  // them 69 px off its truth and printed clean. There the window does not tell
+  // the two readings apart, it picks one, so the sentence names the route that
+  // does work instead.
+  const ambiguity =
+    repeat === null
+      ? 'either the frame holds more than one place this part fits, or every candidate missed the true one — ' +
+        'a narrower --scale or --rotation window around what you know of the part tells the two apart'
+      : // 📍 The subject is the places the bars measured (issue #1526): when the
+        // grouping set placements aside, those were not measured, so the sentence
+        // speaks of every other *place*; when it set none aside, places are
+        // placements and the sentence is the one it was.
+        (repeat.samePlace === 0
+          ? 'every placement in the margin'
+          : `every other place in the margin — the ${repeat.samePlace} placement(s) closer than ${REPEAT_DISTANCE_SPANS} ` +
+            'span to a better-scoring one counted as its place, another angle or size of that fit —') +
+        ` is at the best's scale (within ${(repeat.scaleRatio * 100).toFixed(2)}%, ` +
+        `bar ${REPEAT_SCALE_RATIO * 100}%) and in another place (the nearest ${repeat.spans.toFixed(2)} span(s) away, ` +
+        `bar ${REPEAT_DISTANCE_SPANS}), which is` +
+        ' the part — or a near-copy, such as a left/right pair cut from one drawing — drawn more than once: read the placements as an unordered set and order it across frames ' +
+        '(MOTION.md §2.2 🔀); a --rotation window that excludes one place chooses the answer rather than measuring it';
   return (
     `${figures} — above the measured floor (AUTHORING §11.5: ${floorClause()}), so size and texture do not explain this; ` +
-    (verdict === 'refused'
-      ? 'the cut (or the search window) is the suspect'
-      : 'either the frame holds more than one place this part fits, or every candidate missed the true one — ' +
-        'a narrower --scale or --rotation window around what you know of the part tells the two apart')
+    (verdict === 'refused' ? 'the cut (or the search window) is the suspect' : ambiguity)
   );
 }
 
@@ -664,6 +822,19 @@ export interface PoseOptions {
    * level of every part's refinement is appended to it. See `PoseTrace`.
    */
   trace?: PoseTrace;
+  /**
+   * The coarse grid to search on — default `COARSE_GRID`, which is what the CLI
+   * always uses and has no flag to change.
+   *
+   * ⚠️ A plant, not a tuning knob. It exists so the selftest can run the search
+   * on the quarter-span grid releases before 1.4.0 used and watch a control go
+   * red there: two near-identical parts 0.6 of a span apart came back as ONE
+   * placement on that grid, printed `PLACE` with no alternate (issue #1519). A
+   * control nobody has seen fail holds nothing, and the only honest way to see
+   * this one fail is to search on the grid that failed. The report states the
+   * stride fraction in force in `search.coarse.strideFraction`.
+   */
+  coarseGrid?: PoseCoarseGrid;
 }
 
 /** A search candidate as the trace states it: where the part image's centre would land, frame pixels. */
@@ -1742,7 +1913,7 @@ export function estimatePose(options: PoseOptions): PoseReport {
       coarse: {
         frameLongSide: COARSE_LONG_SIDE,
         partSpan: COARSE_PART_SPAN,
-        strideFraction: COARSE_STRIDE_FRACTION,
+        strideFraction: (options.coarseGrid ?? COARSE_GRID).strideFraction,
         framePyramid: framePyramid.length,
       },
       maxResidual,
@@ -1787,6 +1958,7 @@ export function estimatePose(options: PoseOptions): PoseReport {
         maxResidual,
         { min: scaleMin, max: scaleMax },
         rotationBounds,
+        options.coarseGrid ?? COARSE_GRID,
         options.trace,
       ),
     );
@@ -1804,6 +1976,7 @@ function placePart(
   maxResidual: number,
   scaleBounds: { min: number; max: number },
   rotationBounds: { min: number; max: number; wraps: boolean },
+  coarseGrid: PoseCoarseGrid,
   trace?: PoseTrace,
 ): PosePart {
   const scaleMin = scaleBounds.min;
@@ -1938,14 +2111,14 @@ function placePart(
   }
   const coarse = levels[coarseIndex];
   const spanAtCoarse = (span * scaleReference) / coarse.reduction;
-  const stride = Math.max(1, Math.round(spanAtCoarse * COARSE_STRIDE_FRACTION));
+  const stride = Math.max(1, Math.round(spanAtCoarse * coarseGrid.strideFraction));
   const coarseSamples = samplesFor(coarse.reduction, COARSE_SAMPLES);
   let candidates: Candidate[] = [];
   let grid = { reduction: coarse.reduction, cols: 0, rows: 0, stride };
   for (const scale of scales) {
     const field = coarseScan(coarse, coarseSamples, scale, searchRotations, stride);
     grid = { reduction: coarse.reduction, cols: field.cols, rows: field.rows, stride };
-    candidates.push(...localMinima(field, COARSE_SUPPRESSION_CELLS, MINIMA_PER_SCALE));
+    candidates.push(...localMinima(field, coarseGrid.suppressionCells, coarseGrid.minimaPerScale));
   }
   base.coarse = grid;
   candidates.sort((a, b) => a.residual - b.residual);
@@ -1976,7 +2149,7 @@ function placePart(
     const plate = plates[li];
     const smooth = li !== coarseIndex;
     const branch = li === branchLevel;
-    const keep = li === coarseIndex ? scales.length * MINIMA_PER_SCALE : REFINE_CANDIDATES;
+    const keep = li === coarseIndex ? scales.length * coarseGrid.minimaPerScale : REFINE_CANDIDATES;
     const s = samplesFor(level.reduction, li === 0 ? POLISH_SAMPLES : REFINE_SAMPLES);
     // The coarse pass only sampled every `stride` pixels, so entering the
     // refinement the anchor can be half a stride out; the first polish gets a
@@ -2235,7 +2408,17 @@ function placePart(
   // move, and this sentence is about what moving it cannot change.
   if (base.refusal !== null || base.ambiguous) {
     const verdict = base.refusal !== null ? 'refused' : 'ambiguous';
-    const reading = legibilityReading(base.legibility, verdict);
+    // The whole margin rather than the alternates kept, so a repeat is not
+    // read off a list `MAX_ALTERNATES` truncated.
+    const repeat =
+      verdict === 'ambiguous'
+        ? repeatedPlaces(
+            best,
+            close.map((d) => d.placement),
+            span * best.scale,
+          )
+        : null;
+    const reading = legibilityReading(base.legibility, verdict, repeat);
     base.legibility.reading = reading;
     if (base.refusal !== null) base.refusal.detail += `; ${reading}`;
     base.notes.push(`${name}: ${reading}.`);