@rig-c/core 2.65.1 → 2.66.0

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. |
@@ -11372,16 +11378,20 @@ ambiguous one ends with a sentence saying which reading its figures support:
 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. 🔀 When **every** placement inside
-the margin is at the best's scale and in another place — the two bars the sentence
-prints beside the figures it measured — the reading says the frame does hold it more than once and
+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. ⚠️ Above the floor is **not** a
+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
@@ -11529,7 +11539,9 @@ input bytes, and `PO32` holds it to taking the quarter-rung escape and reading t
 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.
+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`
 
@@ -12033,3 +12045,79 @@ for `declared` and the run says so on a line of its own.
   `@rig-c/play` or `rigc preview`.
 - **Not a second poser.** Everything it draws is a pose `render` would have drawn at
   the same frame; where it disagrees with `render --geometry`, it is wrong (`IN04`).
+
+## 14. Read a named mesh at setup
+
+`rig-c/core` promises `readSetupMesh(view, target)` and the types
+`SetupMeshTarget` and `SetupMesh` (issue #1538). It reads any named mesh or linked
+mesh, including one the setup pose does not select, without a player, animation
+step or change to the document's setup selection.
+
+```ts
+import { readModel, underNoSkin, readSetupMesh } from 'rig-c/core';
+import type { SetupMeshTarget, SetupMesh } from 'rig-c/core';
+
+const view = underNoSkin(readModel(modelText));
+const target: SetupMeshTarget = { slot: 'flag', attachment: 'alternate' };
+const mesh: SetupMesh = readSetupMesh(view, target);
+// mesh.vertices: full-double world x,y pairs, y up; no crop/camera conversion.
+```
+
+| field | contract |
+| --- | --- |
+| `target.slot`, `target.attachment` | exact slot name and attachment **table key**; a record's display name, path or atlas region is not an alias |
+| `target.skin` omitted | retain the supplied view, including `readModel`'s `all`; use `underNoSkin` for a fresh skeleton's view |
+| `target.skin: null` | no skin set: default-table fallback, no skin-required bones or constraints activated |
+| `target.skin: name` | the named view, with default-table fallback; only the named skin's activation lists apply |
+| `target.skin: 'all'` | all activation lists; a uniquely filled key resolves, identical definitions keep the existing resolver's first supplying skin, differing definitions are refused because the model does not carry the Spine file's merge order |
+| `mesh.slot`, `mesh.attachment`, `mesh.skin` | requested slot and table key, and the table's supplying skin (which can be the default fallback); a linked mesh retains its own identity |
+| `mesh.vertices` | fresh mutable `number[]`, flat x,y in world units; stored coordinates and weights use the poser's float32 reading and influence order, without normalization |
+| `mesh.triangles`, `mesh.hull` | fresh mutable triangle indices; hull is the number of leading hull **vertices**, or `null` when absent |
+
+Definition equality ignores object property insertion order at every depth,
+including weighted binding records. Array positions, object key presence and
+leaf values remain significant; leaves use `Object.is`, so positive and negative
+zero are distinct when retained in a model. Reordering object keys alone is not
+a different definition. A genuine value, shape or array-order difference still
+produces the same named all-skin refusal; no merge order is inferred.
+
+The setup matrices come from the raw setup poser's existing constraint path,
+including setup sliders and reset physics. A selected mesh is bit-identical to
+`poseRawSetup(view)`'s geometry, including any setup-slider deform. An unselected
+mesh uses its stored vertices through those same matrices: the API never switches
+an attachment to ask what a slider or path constraint would do after a switch.
+A linked mesh borrows its source vertices, triangles and hull; unweighted
+vertices use the queried slot's bone, weighted vertices their named bindings.
+Its `timelines` flag controls source-deform inheritance only when selected, as
+in the existing setup poser. An inactive bone keeps the existing zero world
+matrix; an attachment read does not activate it.
+
+Every result is detached: changing its object or arrays changes no document,
+pose, cached topology or subsequent read. Missing slots, attachments and skins,
+and region, clipping, path or bounding-box targets, throw `CoreInputError`
+naming the requested identity and the problem. Examples include
+`setup mesh slot "s" attachment "missing" under skin null: no such attachment`
+and `…: region is not a mesh`. Ambiguous all-skin definitions name their skins
+and say `choose a named skin`; unknown skin retains `underSkin`'s existing
+`--skin "missing": no such skin` refusal. Existing setup/non-finite refusals
+propagate; the read does not manufacture a partial result when setup is absent.
+
+`S1538` controls exercise literal coordinates, detached data, linked meshes,
+skin lookup and activation, setup-slider deform, and the official runtime's
+`computeWorldVertices` using ordinary JS output arrays at tolerance 0. The
+runtime stores local mesh coordinates and weights in float32, but an output
+`Float32Array` would add a second rounding that this API does not perform.
+
+**Measured nonselected slider distinction.** In spine-core 4.3.13,
+`computeWorldVertices(skeleton, slot, …)` over an unselected mesh still reads
+the **selected slot's deform array**, even for a linked mesh with
+`timelines: false`. `S1538_09` measures a slider at time 0.5 interpolating
+local offsets `(1,2)` and `(3,4)` to `(2,3)`, with a selected source mesh,
+a linked mesh inheriting its timeline, and an independent linked mesh.
+All three selected reads are exact. Four of the six nonselected calls to the
+official method reuse the selected deform; their maximum absolute difference
+from this API is `2.9999999999999982` world units. The other two nonselected
+calls, with the independent linked mesh selected, agree exactly. The API's
+nonselected output is the stored source geometry through the unchanged setup
+matrices; it does not borrow a different selection's deform. The control
+checks both results and the source of the difference, without an epsilon.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.65.1",
+  "version": "2.66.0",
   "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/deform.ts

@@ -180,9 +180,9 @@
  */
 import type { ModelSlot, ModelVertices } from '../model.ts';
 import { bezierPolyline, keyIndexAt, type CoreAnimationTimelines, type CoreCurve } from './animation.ts';
-import { activeBones, shownRow, type CompiledDocument, type CoreShown, type CoreSkin, type ShownResolution } from './index.ts';
+import { activeBones, shownAttachment, shownRow, type CompiledDocument, type CoreShown, type CoreSkin, type ShownResolution } from './index.ts';
 import { fillingSkins, slotTimelinesApply, type SlotTimelineGate } from './skins.ts';
-import type { CoreGeometry, ShownGeometry } from './vertices.ts';
+import type { ShownGeometry } from './vertices.ts';
 
 /** The far end the deform curve's recurrence runs to — the header's measurement. */
 export const DEFORM_CURVE_END = 0.99999999;
@@ -515,6 +515,111 @@ export function timelineIdentity(slot: string, shown: CoreShown): string | null
 
 const nameOf = (a: CoreAttachmentTimeline): string => `${a.skin}/${a.slot}/${a.attachment}`;
 
+/** The part of an attachment state that depends only on the document view and placeholder. */
+interface AttachmentIdentity {
+  readonly entry: ShownGeometry;
+  readonly identity: string | null;
+  readonly vertices: ModelVertices | null;
+  readonly count: number | undefined;
+  readonly fillers: readonly string[];
+}
+
+/** Like shownAttachment's cache, scoped to the view; a new skin view resolves its own records. */
+const identitiesOfView = new WeakMap<CompiledDocument, Map<string, Map<string, AttachmentIdentity | null>>>();
+
+function readIdentity(doc: CompiledDocument, resolve: (doc: CompiledDocument, slot: ModelSlot) => ShownResolution, slot: ModelSlot, placeholder: string): AttachmentIdentity | null {
+  const s = resolve(doc, { ...slot, setup: placeholder });
+  if (s === null || 'conflict' in s || s.record.geometry === undefined) return null;
+  const g = s.record.geometry;
+  const source = g.kind === 'linkedmesh' ? doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source] : s.record;
+  const sg = source?.geometry;
+  return Object.freeze({
+    entry: Object.freeze({ slot: slot.name, bone: slot.bone, name: shownRow(s).name, placeholder: s.placeholder, skin: s.skin, geometry: g }),
+    identity: timelineIdentity(slot.name, s),
+    vertices: sg !== undefined && sg.kind !== 'region' && sg.kind !== 'linkedmesh' ? sg.vertices : null,
+    count: source?.sequenceCount,
+    fillers: Object.freeze(fillingSkins(doc, slot.name, s.placeholder).map((k) => `"${k}"`)),
+  });
+}
+
+function identityOf(doc: CompiledDocument, resolve: (doc: CompiledDocument, slot: ModelSlot) => ShownResolution, slot: ModelSlot, placeholder: string | null): AttachmentIdentity | null {
+  if (placeholder === null) return null;
+  // A planted resolver may read changing state outside the document. Only the document's own reader is immutable.
+  if (resolve !== shownAttachment) return readIdentity(doc, resolve, slot, placeholder);
+  let slots = identitiesOfView.get(doc);
+  if (slots === undefined) identitiesOfView.set(doc, slots = new Map());
+  let placeholders = slots.get(slot.name);
+  if (placeholders === undefined) slots.set(slot.name, placeholders = new Map());
+  if (placeholders.has(placeholder)) return placeholders.get(placeholder) as AttachmentIdentity | null;
+  const identity = readIdentity(doc, resolve, slot, placeholder);
+  placeholders.set(placeholder, identity);
+  return identity;
+}
+
+/** Index only immutable timeline identity. Times, mixes and the values they compute are never cached. */
+const attachmentsByIdentity = new WeakMap<readonly CoreAttachmentTimeline[], ReadonlyMap<string, readonly CoreAttachmentTimeline[]>>();
+type AttachmentSlots = AttachmentApplication['timelines']['slots'];
+type AttachmentSwitch = NonNullable<AttachmentSlots[number]['timelines'][number]['keys']>;
+const switchesBySlot = new WeakMap<AttachmentSlots, ReadonlyMap<string, readonly AttachmentSwitch[]>>();
+
+function matchingAttachments(timelines: readonly CoreAttachmentTimeline[], identity: string): readonly CoreAttachmentTimeline[] | undefined {
+  let index = attachmentsByIdentity.get(timelines);
+  if (index === undefined) {
+    const rows = new Map<string, CoreAttachmentTimeline[]>();
+    for (const a of timelines) {
+      const name = nameOf(a);
+      const found = rows.get(name);
+      if (found === undefined) rows.set(name, [a]);
+      else found.push(a);
+    }
+    attachmentsByIdentity.set(timelines, index = rows);
+  }
+  return index.get(identity);
+}
+
+function slotSwitches(slots: AttachmentSlots, slot: string): readonly AttachmentSwitch[] | undefined {
+  let index = switchesBySlot.get(slots);
+  if (index === undefined) {
+    const rows = new Map<string, AttachmentSwitch[]>();
+    for (const target of slots) {
+      for (const tl of target.timelines) {
+        if (tl.kind !== 'attachment' || tl.keys === undefined) continue;
+        const found = rows.get(target.name);
+        if (found === undefined) rows.set(target.name, [tl.keys]);
+        else found.push(tl.keys);
+      }
+    }
+    switchesBySlot.set(slots, index = rows);
+  }
+  return index.get(slot);
+}
+
+/** Allocated only when a matching timeline or a mixed deform actually has per-pose state. */
+interface AttachmentValues {
+  deform: number[] | null;
+  frame: number | null;
+  seen: string[];
+}
+
+function applyAttachment(now: AttachmentIdentity | null, values: AttachmentValues | null, timelines: readonly CoreAttachmentTimeline[], t: number, blend: AttachmentApplication | null, evalDeform: DeformEvaluator, blendOf: DeformBlender, evalFrame: SequenceEvaluator): AttachmentValues | null {
+  if (now === null || now.identity === null) return values;
+  const matching = matchingAttachments(timelines, now.identity);
+  if (matching === undefined) return values;
+  values ??= { deform: null, frame: null, seen: [] };
+  if (!values.seen.includes(now.identity)) values.seen.push(now.identity);
+  for (const a of matching) {
+    if (a.deform !== null && now.vertices !== null) {
+      const target = evalDeform(now.vertices, a.deform, t);
+      if (target !== null) values.deform = blend === null ? target : blendOf(now.vertices, values.deform, target, blend.alpha, blend.additive);
+    }
+    if (a.sequence !== null && now.count !== undefined) {
+      const f = evalFrame(a.sequence, now.count, t);
+      if (f !== null) values.frame = f;
+    }
+  }
+  return values;
+}
+
 /**
  * Every slot's shown geometry at one pose — the setup's (`sample` null) or a
  * sample's — with the deform array and the series' frame its attachment
@@ -528,6 +633,11 @@ const nameOf = (a: CoreAttachmentTimeline): string => `${a.skin}/${a.slot}/${a.a
  * differently is left to the slots' own absence. `why` names what the core
  * does not pose: a timeline moving a record whose placeholder several skins
  * fill (the header's ⚠️).
+ *
+ * Identity is kept per document view, slot and placeholder, and timelines
+ * indexed by their record identity. A slot with no per-pose values reuses its
+ * frozen entry; deform arrays and sequence frames are evaluated afresh.
+ * Sliders select identities in application order, never a cached posed value.
  */
 export function attachmentStates(
   doc: CompiledDocument,
@@ -557,66 +667,39 @@ export function attachmentStates(
     const live = gate(doc, slot, active);
     let placeholder = placeholders.get(slot.name) ?? null;
     const base = live ? mixed?.get(slot.name) : undefined;
-    let deform: number[] | null = base?.deform ?? null;
-    let frame: number | null = null;
-    const seen: string[] = base === undefined ? [] : [...base.seen];
-    // What the slot shows now, the record its timelines are keyed as, and what a deform or a frame is computed on.
-    const state = (): { s: CoreShown; identity: string | null; vertices: ModelVertices | null; count: number | undefined } | null => {
-      if (placeholder === null) return null;
-      const s = resolve(doc, { ...slot, setup: placeholder });
-      if (s === null || 'conflict' in s || s.record.geometry === undefined) return null;
-      const g = s.record.geometry;
-      const source = g.kind === 'linkedmesh' ? doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source] : s.record;
-      const sg = source?.geometry;
-      const vertices = sg !== undefined && sg.kind !== 'region' && sg.kind !== 'linkedmesh' ? sg.vertices : null;
-      return { s, identity: timelineIdentity(slot.name, s), vertices, count: source?.sequenceCount };
-    };
-    const apply = (timelines: readonly CoreAttachmentTimeline[], t: number, blend: { alpha: number; additive: boolean } | null): void => {
-      const now = state();
-      if (now === null || now.identity === null) return;
-      for (const a of timelines) {
-        if (nameOf(a) !== now.identity) continue;
-        if (!seen.includes(now.identity)) seen.push(now.identity);
-        if (a.deform !== null && now.vertices !== null) {
-          const target = evalDeform(now.vertices, a.deform, t);
-          if (target !== null) deform = blend === null ? target : blendOf(now.vertices, deform, target, blend.alpha, blend.additive);
-        }
-        if (a.sequence !== null && now.count !== undefined) {
-          const f = evalFrame(a.sequence, now.count, t);
-          if (f !== null) frame = f;
-        }
-      }
-    };
-    if (sample !== null && live) apply(sample.timelines.attachments, sample.t, null);
-    for (const app of live ? sliders : []) {
-      // The slider's attachment key first, as the slot timelines are (`applySliderSlots` in `./constraints_slider.ts`); a switch to another placeholder clears what the timelines set.
-      for (const target of app.timelines.slots) {
-        if (target.name !== slot.name) continue;
-        for (const tl of target.timelines) {
-          if (tl.kind !== 'attachment' || tl.keys === undefined) continue;
-          const i = keyIndexAt(tl.keys, app.at);
-          if (i < 0) continue;
-          const next = tl.keys[i].name ?? null;
-          if (next !== placeholder) {
-            deform = null;
-            frame = null;
+    let values: AttachmentValues | null = base === undefined || (base.deform === null && base.seen.length === 0) ? null : { deform: base.deform, frame: null, seen: [...base.seen] };
+    let now = identityOf(doc, resolve, slot, placeholder);
+    if (sample !== null && live) values = applyAttachment(now, values, sample.timelines.attachments, sample.t, null, evalDeform, blendOf, evalFrame);
+    if (live) for (const app of sliders) {
+      // Each slider switches first, clearing only the per-pose values; then its attachment timelines apply to the new identity.
+      const switches = slotSwitches(app.timelines.slots, slot.name);
+      if (switches !== undefined) for (const keys of switches) {
+        const i = keyIndexAt(keys, app.at);
+        if (i < 0) continue;
+        const next = keys[i].name ?? null;
+        if (next !== placeholder) {
+          if (values !== null) {
+            values.deform = null;
+            values.frame = null;
           }
           placeholder = next;
+          now = identityOf(doc, resolve, slot, placeholder);
         }
       }
-      apply(app.timelines.attachments, app.at, { alpha: app.alpha, additive: app.additive });
+      values = applyAttachment(now, values, app.timelines.attachments, app.at, app, evalDeform, blendOf, evalFrame);
     }
-    const now = state();
     if (now === null) continue;
-    const entry: ShownGeometry = { slot: slot.name, bone: slot.bone, name: shownRow(now.s).name, placeholder: now.s.placeholder, skin: now.s.skin, geometry: now.s.record.geometry as CoreGeometry };
+    // The cached entry is frozen. A pose with a deform/frame owns its wrapper and values; later poses cannot write into it.
+    const entry = values === null || (values.deform === null && values.frame === null) ? now.entry : { ...now.entry };
     shown.push(entry);
-    const fillers = fillingSkins(doc, slot.name, now.s.placeholder).map((k) => `"${k}"`);
-    if (seen.length > 0 && fillers.length > 1) {
-      why.push(`slot "${slot.name}" shows placeholder "${now.s.placeholder}", which skins ${fillers.join(', ')} fill, and ${seen.map((x) => `"${x}"`).join(', ')} key(s) it — which record --skin all shows, and so whether the timeline moves it, is the Spine file's skin order, not the model's`);
+    if (values !== null && values.seen.length > 0 && now.fillers.length > 1) {
+      why.push(`slot "${slot.name}" shows placeholder "${now.entry.placeholder}", which skins ${now.fillers.join(', ')} fill, and ${values.seen.map((x) => `"${x}"`).join(', ')} key(s) it — which record --skin all shows, and so whether the timeline moves it, is the Spine file's skin order, not the model's`);
       continue;
     }
-    if (deform !== null) entry.deform = deform;
-    if (frame !== null) entry.frame = frame;
+    if (values !== null) {
+      if (values.deform !== null) entry.deform = values.deform;
+      if (values.frame !== null) entry.frame = values.frame;
+    }
   }
   return { shown, why };
 }

package/src/core/entry.ts

@@ -24,14 +24,15 @@
  * a Bézier segment as, so that a fitter holds its tolerance to the poser's
  * own evaluation rather than to a mirror of it, issue #1417 — re-exported,
  * never copied, because a copy is the drift the request exists to remove;
- * `CA12` holds the identity).
+ * `CA12` holds the identity; `readSetupMesh`, issue #1538, the named setup
+ * geometry read requested by the player, with `SetupMesh` and `SetupMeshTarget`).
  * The list is `scripts/install_smoke.ts`'s `OBSERVED_SYMBOLS` rows for
  * `./core`, and a symbol added here and not there is not promised.
  */
 export { readModel, underSkin, underNoSkin, CoreInputError, CORE_DOCUMENT_SPEC, CORE_DOCUMENT_SPECS, CORE_BLEND_MODES, activeBones } from './index.ts';
 export type { CompiledDocument, CoreSlotRow, CoreBlendMode } from './index.ts';
-export { poseRawSetup, poseRawAnimation, poseRawAnimationEach, loopedTime, setupBounds, physicsClockStep, PHYSICS_CLOCK_LEAD } from './raw.ts';
-export type { RawPose, RawBone, RawDrawn, RawClip, RawClipped, RawEvent, RawReset } from './raw.ts';
+export { readSetupMesh, poseRawSetup, poseRawAnimation, poseRawAnimationEach, loopedTime, setupBounds, physicsClockStep, PHYSICS_CLOCK_LEAD } from './raw.ts';
+export type { SetupMesh, SetupMeshTarget, RawPose, RawBone, RawDrawn, RawClip, RawClipped, RawEvent, RawReset } from './raw.ts';
 export { poseWalkSetup, poseLoopingWalk } from './walk.ts';
 export { openTrack } from './track.ts';
 export type { LiveTrack, TrackOptions, AdjustableLocals, BoneLocals, LocalAdjust, PhysicsEnvironment } from './track.ts';

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`). */
@@ -1194,10 +1196,11 @@ const shownOfView = new WeakMap<CompiledDocument, Map<string, Map<string, ShownR
  * The answer reads the view's skins and the slot's name and placeholder only,
  * so it is resolved once per view, slot and placeholder and kept (issue
  * #1134: every sample of a walk resolved every slot again). Read-only to every
- * caller; a view built anew resolves its own.
+ * caller; a view built anew resolves its own. An explicit placeholder reads
+ * another table key without changing the slot (issue #1538).
  */
-export function shownAttachment(doc: CompiledDocument, slot: ModelSlot): ShownResolution {
-  if (slot.setup === null) return null;
+export function shownAttachment(doc: CompiledDocument, slot: ModelSlot, placeholder: string | null = slot.setup): ShownResolution {
+  if (placeholder === null) return null;
   let bySlot = shownOfView.get(doc);
   if (bySlot === undefined) {
     bySlot = new Map();
@@ -1208,9 +1211,9 @@ export function shownAttachment(doc: CompiledDocument, slot: ModelSlot): ShownRe
     byPlaceholder = new Map();
     bySlot.set(slot.name, byPlaceholder);
   }
-  if (byPlaceholder.has(slot.setup)) return byPlaceholder.get(slot.setup) as ShownResolution;
-  const resolved = resolveShown(doc, slot.name, slot.setup);
-  byPlaceholder.set(slot.setup, resolved);
+  if (byPlaceholder.has(placeholder)) return byPlaceholder.get(placeholder) as ShownResolution;
+  const resolved = resolveShown(doc, slot.name, placeholder);
+  byPlaceholder.set(placeholder, resolved);
   return resolved;
 }
 

package/src/core/raw.ts

@@ -113,7 +113,7 @@
  * naming why (`CoreInputError`): a renderer handed a pose with a block
  * missing would draw a different picture in silence.
  */
-import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, readColour, shownAttachment, sourceOfDoc, underNoSkin, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
+import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, readColour, shownAttachment, sourceOfDoc, underNoSkin, underSkin, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
 import { posedBoneWorld, posedBoneWorldAlone, posedSlots, type CoreAnimationTimelines, type LocalAdjust, type TimelinePlant } from './animation.ts';
 import { constraintsAbsentWhy, pathAnimationsWhy } from './constraints.ts';
 import { freshStepContext, rotatePhysics, steppedPreviousPassWhy, translatePhysics, DEFAULT_PHYSICS_ENVIRONMENT, type PhysicsEnvironment, type PhysicsStepContext } from './constraints_physics.ts';
@@ -121,8 +121,9 @@ 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, worldVertices, type CoreAttachmentRow, type CoreClipRow, type ShownGeometry } from './vertices.ts';
 import { RUNTIME_DEG, type CoreWorld } from './world.ts';
+import { fillingSkins } from './skins.ts';
 import type { SliderApplication } from './constraints_slider.ts';
 
 /** One bone, posed: the world transform and the runtime getters' four readings (the header's `bones`). */
@@ -148,8 +149,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 +366,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 +388,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 +437,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 };
 }
 
@@ -447,6 +466,81 @@ export function poseRawSetup(doc: CompiledDocument, plant: CorePlant = {}): RawP
   return setupPoseIn(doc, plant, RAW_MODE);
 }
 
+/** A table key to read, with an optional skin-view override; omitted skin keeps the supplied view. */
+export interface SetupMeshTarget {
+  readonly slot: string;
+  readonly attachment: string;
+  /** A named skin (with default fallback), `all`, or `null` for no skin set. */
+  readonly skin?: string | null;
+}
+
+/** A detached named mesh in setup world units, y up; hull counts vertices, not coordinates. */
+export interface SetupMesh {
+  slot: string;
+  /** The requested attachment table key, even when the record states another display name. */
+  attachment: string;
+  /** The skin whose table supplied the requested record, including a fallback. */
+  skin: string;
+  vertices: number[];
+  triangles: number[];
+  hull: number | null;
+}
+
+/** Model definitions by value: object key order is irrelevant, array positions and signed zero are not. */
+function sameSetupMeshDefinition(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length) return false;
+  const left = a as Record<string, unknown>;
+  const right = b as Record<string, unknown>;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) =>
+    Object.prototype.hasOwnProperty.call(right, key) && sameSetupMeshDefinition(left[key], right[key]));
+}
+
+/**
+ * Read a named mesh without changing the setup selection or playing anything
+ * (issue #1538). Setup constraints and reset physics use the raw poser's own
+ * path. A selected mesh includes its setup-slider deform; an unselected mesh
+ * reads its stored geometry through those same matrices, with no hypothetical
+ * attachment switch or deform. Linked meshes use their source topology and
+ * bindings, and the queried slot's bone for unweighted vertices; `timelines`
+ * affects only a selected mesh's setup-slider deform, as in `poseRawSetup`.
+ *
+ * Skin resolution is the supplied view's unless explicitly overridden. Under
+ * `all`, differing definitions of the requested mesh are refused: the model
+ * does not carry the file order that would choose one. Object property order
+ * does not distinguish definitions; array positions and Object.is leaf values
+ * do. Identical definitions keep the resolver's first supplying skin. All arrays are fresh.
+ */
+export function readSetupMesh(doc: CompiledDocument, target: SetupMeshTarget): SetupMesh {
+  const view = target.skin === undefined ? doc : target.skin === null ? underNoSkin(doc) : underSkin(doc, target.skin);
+  const where = `setup mesh slot ${JSON.stringify(target.slot)} attachment ${JSON.stringify(target.attachment)} under skin ${JSON.stringify(view.skin)}`;
+  const slot = view.slots.find((s) => s.name === target.slot);
+  if (slot === undefined) throw new CoreInputError(`${where}: no such slot`);
+  const resolved = shownAttachment(view, slot, target.attachment);
+  if (resolved === null) throw new CoreInputError(`${where}: no such attachment`);
+  const fills = fillingSkins(view, slot.name, target.attachment);
+  const definitions = fills.map((name) => view.skins.find((k) => k.name === name)?.attachments[slot.name]?.[target.attachment]);
+  if ('conflict' in resolved || definitions.some((r) => !sameSetupMeshDefinition(r, definitions[0]))) {
+    throw new CoreInputError(`${where}: skins [${fills.join(', ')}] fill this attachment differently; choose a named skin`);
+  }
+  const geometry = resolved.record.geometry;
+  const mesh = geometry?.kind === 'linkedmesh'
+    ? view.skins.find((s) => s.name === geometry.skin)?.attachments[geometry.slot]?.[geometry.source]?.geometry
+    : geometry;
+  if (mesh?.kind !== 'mesh') throw new CoreInputError(`${where}: ${resolved.record.kind} is not a mesh`);
+  const { world, shown, drawOrder } = setupPosed(view, {}, RAW_MODE);
+  const selected = shown.find((s) => s.slot === slot.name && s.placeholder === target.attachment && s.skin === resolved.skin);
+  const bone = world.get(slot.bone);
+  if (bone === undefined) throw new CoreInputError(`${where}: no setup transform for bone ${JSON.stringify(slot.bone)}`);
+  const vertices = selected === undefined
+    ? numbersOf(worldVertices(mesh.vertices, bone, world).map(rawNumber), `${where} vertex`, RAW_MODE)
+    : rawDrawn(view, [selected], world, drawOrder, {}).drawn[0].vertices;
+  return { slot: slot.name, attachment: target.attachment, skin: resolved.skin, vertices: [...vertices], triangles: [...mesh.triangles], hull: mesh.hull ?? null };
+}
+
 /** `poseRawSetup` in `mode` — under `keep`, a value that is not finite stays in the pose (`./walk.ts`). */
 export function setupPoseIn(doc: CompiledDocument, plant: CorePlant, mode: WalkMode): RawPose {
   const { world, shown, slots, drawOrder } = setupPosed(doc, plant, mode);

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

@@ -431,6 +431,18 @@ export function floorClause(): string {
  *   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
@@ -443,26 +455,67 @@ 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 `|alternate.scale / best.scale − 1|` inside the margin. */
+  /** The largest `|place.scale / best.scale − 1|` over the other places, each read at its best-scoring placement. */
   scaleRatio: number;
-  /** The nearest alternate's centre distance from the best's, in spans at the best's scale. */
+  /** 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 alternate inside the margin is a DIFFERENT place at the SAME
- * scale as the best, against `REPEAT_SCALE_RATIO` and `REPEAT_DISTANCE_SPANS`
- * — `null` when any one is not, or there is none. `span` is the part's longest
+ * 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; the search calls it with exactly what it reported.
+ * 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): PoseRepeat | null {
+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;
-  const scaleRatio = Math.max(...alternates.map((a) => Math.abs(a.scale / best.scale - 1)));
-  const spans = Math.min(...alternates.map((a) => hypot2(a.x - best.x, a.y - best.y) / span));
-  return scaleRatio <= REPEAT_SCALE_RATIO && spans >= REPEAT_DISTANCE_SPANS ? { scaleRatio, spans } : 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;
 }
 
 /**
@@ -520,10 +573,18 @@ export function legibilityReading(
     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'
-      : `every placement in the margin is at the best's scale (within ${(repeat.scaleRatio * 100).toFixed(2)}%, ` +
+      : // 📍 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 ' +
+        `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; ` +