spine-rigc 2.14.0 → 2.15.0

package/README.md

@@ -688,7 +688,13 @@ bun tools/editor_roundtrip.ts --build build/ --editor /Applications/Spine.app/Co
 Of the editor's `--version` it records one line, the `Spine <x.y.z> …` line that
 carries the version, and nothing else that command prints — the rest of it
 names the licence holder — or `editor version: not found in --version output`
-where no such line is there. It prints the import and export exit codes, the
+where no such line is there. That call carries the same `-u` as the import and
+the export, so a trip pinned with `--editor-version <v>` names the editor it
+pinned and says so on the line (`(read from --version under -u <v>, …)`); an
+unpinned trip names the launcher's default. Once the export exists the version
+is held against the export's own `skeleton.spine`, and a disagreement is a FAIL
+naming both values — the line would otherwise name an editor the trip did not
+run on. It prints the import and export exit codes, the
 validator's verdict on the export, every `diff` measure that moved, `check`'s mean MAE and worst drift per
 animation **for each skin the build and the export both declare** — one
 render-and-check block per skin, with a per-skin roll-up under them, because a

package/docs/AUTHORING.md

@@ -3394,6 +3394,13 @@ carrying here:
   raw JSON the parser throws.
 - Each transform mix is read **only if the matching `to` property was declared**, so
   a `mixRotate` without a `rotate` entry is dead data.
+- An **ik** constraint's `bones` is **one bone, or two where the second's parent is the
+  first**. The runtime's update applies one bone or two and nothing else, so an ik over
+  three loads clean and moves nothing; and the two-bone solve places the second bone
+  through the first's matrix from the second's own local offset, so a bone standing
+  between the pair is left out of the triangle it solves and the tip misses the target
+  in every frame. rigc refuses both by name (§5.1), and `A47` refuses them in a file a
+  rig spec did not write (§5.2). A chain longer than two is several constraints.
 - A physics constraint's five components all default to 0, so one that names none of
   them parses cleanly and does nothing at all. rigc refuses it up front, and `A23`
   catches it from the other side.
@@ -6132,6 +6139,8 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `<file>: <where> is Infinity; a number in this file is finite at float32 precision, at most ±3.4028234663852886e+38, because the skeleton is written as float32 — …` (also `is -Infinity`, `is 1e+308`, and `is NaN` from a library caller) | §3 — state the number you meant, inside float32's range. One walk over the whole file, run right after the key scan and before any other rig-spec check, so a range rule never prints `NaN`. `<where>` is every number in the rig spec — a bone (`bone "hip" x`), a slot, a skin's attachment down to its arrays (`skin "default" slot "s" attachment "a" weights[3][1].x`), a constraint (`constraint "aim" mixRotate`), an event, `skeleton`, `invariants.meshTriangles` — and the dotted path in the cut manifest (`crop.h`) and in the motion spec (`` `animations.idle.tracks[0].keys[1].v[0]` ``, after the motion spec's own field checks, which keep their sentences). ⚠️ It sees numbers only: `"x": "NaN"` is a string, and the row above refuses it as one |
 | `two bones are called "X"` | bone names are the join key; rename one |
 | `two ik constraints are called "X" — a constraint resolves by name AND type (\`SkeletonData.findConstraint\`), so names are unique PER KIND: an ik and a transform constraint may share one, two of a kind may not` | §3.5 — rename one of the two. The kind in the sentence is the pair's own, so `two transform constraints are called "X"` is the same refusal on another kind; a name shared **across** kinds is not this error |
+| `ik constraint "X" names 3 bones ("a", "b", "c"); the solver applies one or two, so a constraint over 3 moves nothing — name one bone, or two where the second is the first's child` | §3.5 — the constraint's `bones` is what changes: one bone, or a parent and its child. The runtime's ik update has a case for one bone and one for two, so a longer list loads, sits in the update cache and applies nothing — [measured] every bone posed exactly where the same rig with no constraint has it. A longer chain is several constraints, each over one bone or a pair |
+| `ik constraint "X": "B" is not a child of "A" ("C" stands between), so the two-bone solve is not of the chain drawn — name "B"'s own parent as the first bone, or make "B" a child of "A"` (also `("A" is not above it; its parent is "P")`, `("B" has no parent)`) | §3.5 — the constraint's `bones` is what changes, or `B`'s `parent`. The two-bone solve places `B` through `A`'s matrix from `B`'s own local offset, so what stands between them is left out of the triangle it solves — [measured] a bone between them at `B`'s origin left the tip up to 2.60 off the target, and one at `A`'s origin landed only while it held its identity |
 | `physics constraint "X" is declared in both the rig spec and the motion spec's physics table` | §4.6 — the rig spec declares a physics constraint's structure and the motion spec's `physics` table declares one outright; pick the file it belongs in. Per kind, like every other constraint name: an `ik` "X" in the rig spec beside a `physics` "X" here is two constraints and is not this error |
 | `skin "S" lists "X" under "transform", but the rig declares it as a "ik" constraint — a skin looks its constraints up by name AND type, so this one is a miss and the loader throws` | §3.4.1 — move the name to the list named after the constraint's own kind. A name the rig declares under **no** kind is the other miss and says so (`skin "S" activates ik constraint "X", which this rig does not declare`). ⚠️ A name listed by **several skins** is not an error: the lists are per-skin sets and a bone or constraint in two of them is active under either |
 | `slot "X" names bone "Y", which this rig does not declare` | add the bone, or fix the slot's `bone` |
@@ -6409,7 +6418,7 @@ Fix A00 and run it again.
 | `A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN` | both | a **linked mesh** (§3.4) — `type: "linkedmesh"`, or a `type: "mesh"` carrying `source` — that also states `uvs`, `triangles`, `vertices`, `hull` or `edges`. The parser returns from the `source` branch before `readVertices` (`SkeletonJson.ts:582-586`), so those keys are read by **nothing at all** and `setSourceMesh` fills the attachment with the source's arrays instead: the file says one mesh and every runtime draws another, in silence. The detail names the attachment by skin, slot and placeholder, every key it states, the `source` and where the parser looks for it — the two defaults spelled out, because an omitted `skin` is the **default** skin rather than the one the link is written in — and the shape the keys describe beside the shape the attachment loaded. ⚠️ **`width`/`height` are not part of this.** `setSourceMesh` overwrites both with the source's, so they are as dead at runtime — but the parser reads them (`:569-570`), the format carries them on a link and rigc emits them, so refusing them would refuse every link rigc writes (§3.4). `compile.ts` refuses the same shape outright in a rig rigc builds (§5.1); this is that fact held against a skeleton it did not write, and `ingest` reports it as `ATTACHMENT_LINK_GEOMETRY` ([INGEST §2.0](INGEST.md)). **SKIP** when no attachment in the skeleton takes its geometry from another — which is almost every skeleton, so a pass here means a link was read |
 | `A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN` | both | an `rgb` or `alpha` timeline (§4.4) the runtime does not hold as the file states it, in one of two shapes that both parse in silence. **A channel keyed twice**: another colour timeline of the same slot in the same animation poses a channel this one poses — `rgba` beside `alpha` is the shape a converter leaves when it writes a separable `rgb` back as `rgba` next to the `alpha` it kept. Every colour timeline poses its channels at every time, the setup value before its first key included, so the one the file states later overwrites the other everywhere; the detail names both timelines, the channel, and which one survives. **A key not posed as written**: the animation is stepped to each key's own time — at the key **as the runtime stores it**: spine-core keeps key times as 32-bit floats, so a key at `0.2` is posed at `0.20000000298…`, the later of the two, and not one float step before it, where a first key still shows the setup value and a stepped key the one before, and the posed r g b (for `rgb`, against the hex, to half a quantisation step) or alpha (for `alpha`, against `value`, whose absence the parser reads as 0) is compared — a colour that is not six hex digits loads as NaN, and a key whose time another key repeats is read by nothing. ⚠️ An `rgb` alone written as an `rgba` holding the setup alpha is **not** caught and cannot be from the file: it is a correct `rgba`, and the difference shows only under another track that moves the alpha. The loaded timeline class and the channels a separable timeline leaves alone are not measured here, because against the linked parser neither can come out wrong. The channel table is `SLOT_COLOR_CHANNELS` in `src/timelines.ts`, shared with the compiler's refusal and held to the runtime's own property ids. **SKIP** when no animation keys an `rgb` or `alpha` — there is then no separable slot colour to read back |
 | `A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES` | both | a **numbered series** (§3.4.3, §4.13) that the runtime does not show as the file states it. Every shape below loads without a word, measured on spine-core 4.3.13. **The block**: a `sequence` with no `count` (`readSequence` reads 0, and the attachment holds no region) or a `setup` at or past `count` (`Sequence.resolveIndex` clamps it to the last frame). **The keys**: a `mode` outside the seven — `hold`, `once`, `loop`, `pingpong`, `onceReverse`, `loopReverse`, `pingpongReverse` — loads as `hold`; an `index` that is fractional (`index << 4` truncates it) or past the end (clamped); an advancing mode at an effective delay of 0 (the parser carries a key's `delay` from the key before; `(time - keyTime) / 0` is Infinity and `Infinity \| 0` is 0, so it never advances); a timeline on an attachment that carries no block (the parser gives every region a one-region series, so every mode shows it). **The pose**: every key is stepped to mid-frame sample times — enough to wrap every mode, and a `hold` key to its own time as the runtime stores it, a 32-bit float — and the region the slot shows is held to the frame the file's own statement gives, the arithmetic of `SequenceTimeline.applyToSlot` and the names of `Sequence.getPath` transcribed rather than read off the loaded timeline, so the check is not the runtime agreeing with itself. Before the first key the frame is `setup`. ⚠️ A sample where the slot shows another attachment is not compared, because the runtime writes nothing there; a timeline with no comparable sample is counted in `stats.sequenceSamplesUnshown`. `compile.ts` refuses every one of these shapes in a spec (§5.1); this is them held against a skeleton it did not write. **SKIP** when no attachment carries a `sequence` block and no animation keys a `sequence` timeline |
-| `A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | an ik constraint resting at `mix` 0 that no animation keys **away from 0** (§4.9, §4.12). `IkConstraint.update` returns on `mix === 0`, so it sits in the update cache and moves nothing. The keys are read the way `A23`/`A36`/`A37` read theirs — every value the loaded timeline poses on its `mix` channel, Bezier samples included — so a timeline keying 0 only is no rescue: [measured] it poses every bone exactly where the same rig with no constraint does. Live is the runtime's `!== 0`, so a negative mix is not refused. `ik constraint "C" has mix 0 at setup and none of the 1 animation keys its mix above 0; update() returns on mix 0, so "upper" never reaches for "goal" — rest it above 0, or key its mix above 0 in an animation, or declare that the consumer drives its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "C", "type": "ik", "why": … }]`. A constraint the rig spec declares in `invariants.consumerDrivenMix` (§3.7) is not measured, and one the file also switches on is refused: `ik constraint "C" is declared in the rig spec as invariants.consumerDrivenMix, and the file already switches it on — … — so the declaration exempts nothing; drop the entry`. **SKIP** when the skeleton declares no ik constraint, and **SKIP by name** when every ik constraint it declares is declared consumer-driven: `every ik constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "C" (why: …): it rests muted and none of the 1 animation keys its mix above 0`. With a live one beside it the rule measures that one and the stats line names the declared (`ikConsumerDriven`) |
+| `A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | an ik constraint resting at `mix` 0 that no animation keys **away from 0** (§4.9, §4.12). `IkConstraint.update` returns on `mix === 0`, so it sits in the update cache and moves nothing. The keys are read the way `A23`/`A36`/`A37` read theirs — every value the loaded timeline poses on its `mix` channel, Bezier samples included — so a timeline keying 0 only is no rescue: [measured] it poses every bone exactly where the same rig with no constraint does. Live is the runtime's `!== 0`, so a negative mix is not refused. `ik constraint "C" has mix 0 at setup and none of the 1 animation keys its mix above 0; update() returns on mix 0, so "upper" never reaches for "goal" — rest it above 0, or key its mix above 0 in an animation, or declare that the consumer drives its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "C", "type": "ik", "why": … }]`. A constraint the rig spec declares in `invariants.consumerDrivenMix` (§3.7) is not measured, and one the file also switches on is refused: `ik constraint "C" is declared in the rig spec as invariants.consumerDrivenMix, and the file already switches it on — … — so the declaration exempts nothing; drop the entry`. 🔩 **The shape clause** (issue #1205) reads `bones` whatever the mix, declared or not: an ik over more than two bones — `ik constraint "C" names 3 bones ("a", "b", "c"); the solver applies one or two, so a constraint over 3 moves nothing — name one bone, or two where the second is the first's child` — and a pair whose second bone's parent is not the first — `ik constraint "C": "b" is not a child of "a" ("m" stands between), so the two-bone solve is not of the chain drawn — name "b"'s own parent as the first bone, or make "b" a child of "a"`, or `("a" is not above it; its parent is "p")` when `a` is not an ancestor at all. [measured, rigc's fixtures through spine-core] the three-bone and four-bone ik posed every bone exactly where no constraint does; a pair skipping a bone missed by 18.95–22.25, a pair with a bone between at the child's origin by 0.27–2.60, and one at the parent's origin landed only while that bone held its identity (turned 15°: 3.50–4.11 off). The fix is the rig spec's `bones` (§3.5), and a rig spec states neither shape — the parser refuses both with the same sentence (§5.1) — so this clause is for a file a rig spec did not write. On the core entry the model document's reader refuses both first, as `A00_MODEL_READ`. **SKIP** when the skeleton declares no ik constraint, and **SKIP by name** when every ik constraint it declares is declared consumer-driven: `every ik constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "C" (why: …): it rests muted and none of the 1 animation keys its mix above 0`. With a live one beside it the rule measures that one and the stats line names the declared (`ikConsumerDriven`) |
 | `A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | a transform constraint none of whose mixes **for a property it drives** is away from 0 at setup or on any value an animation poses (§4.10, §4.12), or one whose `properties` name no `to` at all. A property is applied only when its own mix `!== 0`, and a key that omits a mix reads it as 1, so the six-mix early return of `TransformConstraint.update` would take a key of `mixRotate: 0` alone as a rescue — [measured] that key, and one keying `mixX` 1 on a rotate-only constraint, pose every bone exactly where no constraint does. A negative mix runs, and five transforms in the editor's example exports rest at −1. `transform constraint "C" drives rotate and has mixRotate 0 at setup, and none of the 1 animation keys its mix above 0; a mix is read only for a property the constraint drives, and update() skips each one at 0, so nothing ever moves "follower" — rest mixRotate above 0, or key its mix above 0 in an animation, or declare that the consumer drives its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "C", "type": "transform", "why": … }]`. A constraint the rig spec declares in `invariants.consumerDrivenMix` (§3.7) is not measured, and one the file also switches on is refused as `A47`'s is; one that drives no property is refused with its own sentence declared or not, since no mix it carries is read by anybody. **SKIP** when the skeleton declares no transform constraint, and **SKIP by name** when every transform constraint it declares is declared consumer-driven: `every transform constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "C" (why: …): it rests muted and none of the 1 animation keys its mix above 0`. With a live one beside it the stats line names the declared (`transformConsumerDriven`) |
 | `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` | renderer | two regions on one page whose rectangles overlap **and** whose footprints overlap — so one drawing samples texels that are the other's. A region's **footprint** is what samples it: a region a mesh names (its `path`, else its name, every frame of a `sequence` included) draws the mesh's hull loop and its triangles, its UVs placed on the page as `MeshAttachment.computeUVs` places them (a **linked mesh** draws its source's); a region a region attachment names, or that nothing names, draws its whole rectangle — and so does a mesh region whose UVs leave 0..1, whose hull or triangles do not index its vertices, or that is turned by `rotate:`, and every region when a `sequence` cannot be read. For two rectangles that is exactly the clause `A06` held until issue #1099 — an editor alias, a sequence frame, two rectangles moved over the same texels are refused as they were — and it accepts what `--pack-shape polygon` writes: a neighbour inside a mesh's rectangle where the hull is not (§0.1). **Touching is not overlapping**: interiors are compared, every comparison `FOOTPRINT_SLACK` (1e-6 texels) in favour of apart. `regions "ear_l" (341,696 112x420) and "mouth" (332,709 96x48) overlap on page "skeleton.png", and so do their footprints — "ear_l" draws the hull of mesh "ear_l" (skin "default", slot "ear_l"), "mouth" draws its whole rectangle, which region attachment "mouth" (skin "default", slot "mouth") draws; what they draw overlaps by 1916.5512 texel(s) of area inside 347,709 81x48. One drawing samples texels that are the other's: move one region clear of the other's footprint, or pack the page again` — `gallery/nod`'s polygon pack with `mouth` moved onto a triangle of the `ear_l` mesh (`PK88`). Nothing about the **padding** is read — the atlas and the model document do not state it — and the `2 · padding` the packer keeps is the packer's own (`PK81`). A renderer rule because two regions over the same texels is what an editor's packer writes for an alias or a sequence: 49 pairs on four of the ten atlases in `examples/`. **SKIP** when the atlas declares no page or no region, and when no page carries two regions — every unpacked build |
 | `A50_STAGE_BOX_IS_THE_STAGE` | both | the stage box a rig asked for (`skeleton.stageBox`, §3.1) is not the stage the model document states. Read on the data a consumer reads and on the pose it reads: the slot carries, in the `default` skin under the asked name, an unweighted bounding box of four vertices whose **stored** vertices are the stage's corners exactly — `(x, y)`, `(x + w, y)`, `(x + w, y + h)`, `(x, y + h)`, as the float32 the runtime loads — and whose **world** vertices at the setup pose (constraints applied, no physics, no skin set) are those corners as the runtime poses them on an unrotated root, compared on the header's 1e-6 grid at float32. `the stage box (slot "stage", attachment "stage"): vertex 1 is stored as (65, 0) and the stage's corner is (64, 0) — the stage 0,0 64x48, bottom-left first and counter-clockwise`; a root moved at setup reads *vertex 0 poses at (1, 0) at the setup pose and the stage's corner poses at (0, 0) on an unrotated root, on the header's grid — something moves the box's bone at setup (a constraint, or a pose the root does not state)*; a slot the skeleton lacks, no attachment of that name, another type, or a weighted box are each named too. Through spine-core it reads `findSlot`, `defaultSkin.getAttachment` and `computeWorldVertices` on a fresh skeleton after `setupPose()` and `updateWorldTransform(Physics.none)`; on the model side the document's record and rigc's core poser, held to spine-core's poses at tolerance 0 (`PG06`, `PG07`). **SKIP** where nothing asks: *nothing asks for a stage box: no rigc-compiled/3 model document beside this skeleton states one …* — a rig without the field, and any skeleton with no `/3` document beside it, an export among them |

package/package.json

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

package/src/assertions/bodies/a47.ts

@@ -14,16 +14,83 @@
  *
  * Moved out of `src/validate.ts` whole: the bones, the target, the setup mix
  * and the keyed ones are the rig's, the declaration the rig spec's.
+ *
+ * 🔩 A second clause reads the constraint's `bones` as a shape, whatever its
+ * mix (issue #1205): more than two bones, or a pair whose second bone's
+ * parent is not the first, is a constraint the solver cannot apply as drawn
+ * — `ikShapeFault` below, whose sentence the rig-spec parser prints too. A
+ * clause rather than an assertion of its own because it asks this body's
+ * question of the same object — does this ik do what it says — and a new
+ * registry entry would move every count the documents state.
  */
 import type { Verdicts } from '../harness.ts';
 import type { ConstraintFacts } from '../facts/constraints.ts';
 import { consumerDriven, consumerSkip, declaredButLive, declareIt, ikLive, noneKeysItsMixAbove0, REST_OR_KEY_ITS_MIX, switchedOn } from '../constraint_words.ts';
 import type { RigInfo } from '../../types.ts';
 
+/**
+ * What is wrong with an ik constraint's `bones` as a shape, in the sentence
+ * both the rig-spec parser and A47 print — or `null` when the shape is one
+ * the solver applies as drawn (issue #1205).
+ *
+ * - **A count other than one or two moves nothing.** The runtime's update
+ *   switches on the count with a case for one bone and one for two, so a
+ *   constraint over three or more is in the update cache and applies nothing
+ *   [measured: a chain under an ik over three bones and over four posed every
+ *   bone exactly where the same rig with no constraint did, 49 samples,
+ *   tolerance 0]. A list of none is refused before this (the compiler's
+ *   "needs a non-empty bones array"; an export's own loader).
+ * - **A pair whose second bone's parent is not the first solves another
+ *   triangle.** The two-bone solve places the second bone through the first's
+ *   matrix from the second's own local offset, so whatever stands between
+ *   them is left out of the chain it solves [measured on the same chain: a
+ *   bone between them at the child's origin left the tip 0.27–2.60 off the
+ *   target, a pair skipping a bone 18.95–22.25 off, and a zero-offset bone
+ *   between them at the parent's origin landed only while it held its
+ *   identity — turned 15° in setup, 3.50–4.11 off in every frame]. The rule
+ *   reads the parent and not the pose, because a pose that happens to agree
+ *   is not a rig that does. rigc's own reader of the model document refuses
+ *   both shapes too (`A00_MODEL_READ` on the core entry); this is the same
+ *   refusal on the side that reads a Spine file.
+ *
+ * `secondAncestors` is the second bone's ancestors, parent first, as the
+ * facts carry them.
+ */
+export function ikShapeFault(name: string, bones: readonly string[], secondAncestors: readonly string[]): string | null {
+  const quoted = (list: readonly string[]): string => list.map((b) => `"${b}"`).join(', ');
+  if (bones.length > 2) {
+    return (
+      `ik constraint "${name}" names ${bones.length} bones (${quoted(bones)}); the solver applies one or two, so a constraint ` +
+      `over ${bones.length} moves nothing — name one bone, or two where the second is the first's child`
+    );
+  }
+  if (bones.length !== 2 || secondAncestors[0] === bones[0]) return null;
+  const [first, second] = bones;
+  const at = secondAncestors.indexOf(first);
+  const why =
+    at > 0
+      ? `${quoted(secondAncestors.slice(0, at))} ${at === 1 ? 'stands' : 'stand'} between`
+      : secondAncestors.length === 0
+        ? `"${second}" has no parent`
+        : `"${first}" is not above it; its parent is "${secondAncestors[0]}"`;
+  return (
+    `ik constraint "${name}": "${second}" is not a child of "${first}" (${why}), so the two-bone solve is not of the ` +
+    `chain drawn — name "${second}"'s own parent as the first bone, or make "${second}" a child of "${first}"`
+  );
+}
+
 export function a47IkConstraintNotMutedThroughout({ fail, skip, stats }: Verdicts, facts: ConstraintFacts, rig: RigInfo | undefined): void {
   const NAME = 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT';
   const constraints = facts.constraints.flatMap((c, index) => (c.ik === undefined ? [] : [{ name: c.name, ik: c.ik, index }]));
   if (!constraints.length) return skip(NAME, 'the skeleton declares no ik constraint');
+  // The shape first, whatever the mix: a constraint the solver cannot apply as drawn is not exempted by a declaration of who sets its mix.
+  let shapeFaults = 0;
+  for (const { name, ik } of constraints) {
+    const fault = ikShapeFault(name, ik.bones, ik.secondAncestors);
+    if (fault === null) continue;
+    shapeFaults++;
+    fail(NAME, fault);
+  }
   // Channel 0 is `mix`; the other four are softness, bend direction, compress and stretch.
   const ikSwitchedOn = switchedOn(facts, (timeline) => timeline.kind === 'ik', 1, (_timeline, value, channel) => channel === 0 && ikLive(value));
   const declared = consumerDriven(rig, 'ik');
@@ -55,5 +122,5 @@ export function a47IkConstraintNotMutedThroughout({ fail, skip, stats }: Verdict
     );
   }
   if (exempt.length) stats.ikConsumerDriven = exempt.map(([name]) => name).join(',');
-  if (exempt.length === constraints.length) return skip(NAME, consumerSkip('ik', exempt, facts.animations));
+  if (exempt.length === constraints.length && shapeFaults === 0) return skip(NAME, consumerSkip('ik', exempt, facts.animations));
 }

package/src/assertions/facts/constraints.ts

@@ -79,7 +79,19 @@ export interface ConstraintEntry {
     readonly scale: number;
     readonly mix: number;
   };
-  readonly ik?: { readonly bones: readonly string[]; readonly target: string; readonly mix: number };
+  readonly ik?: {
+    readonly bones: readonly string[];
+    readonly target: string;
+    readonly mix: number;
+    /**
+     * For an ik over exactly two bones, the second bone's ancestors, its
+     * parent first and the root last; empty for any other count (issue
+     * #1205). The two-bone solve places the second bone through the first's
+     * matrix from the second's own local offset, so it is the solve of the
+     * chain drawn only when the first entry here is the first bone.
+     */
+    readonly secondAncestors: readonly string[];
+  };
   /**
    * A transform constraint's six mix channels in frame order — `mixRotate`,
    * `mixX`, `mixY`, `mixScaleX`, `mixScaleY`, `mixShearY` — each the field's

package/src/assertions/model/constraints.ts

@@ -125,8 +125,14 @@ function entryOf(doc: CompiledDocument, kind: ConstraintKind, name: string, reco
         },
       };
     }
-    case 'ik':
-      return { ...base, ik: { bones: record.bones, target: record.target, mix: record.mix } };
+    case 'ik': {
+      // The second bone's ancestors, parent first (issue #1205). The core's reader refuses a pair that is not a parent and its child, so on this side the first entry is always the first bone.
+      const secondAncestors: string[] = [];
+      if (record.bones.length === 2) {
+        for (let at = doc.bones.find((b) => b.name === record.bones[1])?.parent; at !== undefined; at = doc.bones.find((b) => b.name === at)?.parent) secondAncestors.push(at);
+      }
+      return { ...base, ik: { bones: record.bones, target: record.target, mix: record.mix, secondAncestors } };
+    }
     case 'transform':
       return {
         ...base,

package/src/assertions/model/stepped_poses.ts

@@ -13,7 +13,15 @@
  *   rather than refusing it. It is held equal to spine-core's walk at
  *   tolerance 0 by `tools/core_gate.ts`'s walk block and the selftest's
  *   `CO25`, and the poses A10 asks for here are compared with spine-core's on
- *   every call with a model in hand (`VF13`).
+ *   every call with a model in hand (`VF13`). Since issue #1179's second part
+ *   the poses come through that walk's scan assembler (`scanWalkSetup`,
+ *   `scanLoopingWalk`): the same walk, each pose carrying what A10 reads — the
+ *   bones' matrix and origin, the slot rows, the drawn attachments' slot, name
+ *   and vertices — and none of the bones' getter readings and oracle rows or
+ *   the drawn rows' UVs, triangles and colour, which nothing it reads is
+ *   computed from. The core suite's `CO43` holds the scan to the public walk's
+ *   numbers bit for bit, `CO44` what it leaves out to move none of them, and
+ *   `CO45` that the vertex arrays it hands on uncopied are each pose's own.
  * - **A bone's mode**: the mode the core's bone timelines pose at the time
  *   (`posedBones`, a fresh non-looping track: the time held at the duration),
  *   folded as the runtime's lookup folds it (`foldInheritMode`). `readModel`
@@ -30,7 +38,8 @@
 import { fileAnimationOrder } from '../../compile.ts';
 import { foldInheritMode, type CompiledDocument } from '../../core/index.ts';
 import { posedBones } from '../../core/animation.ts';
-import { poseLoopingWalk, poseWalkSetup, type WalkPose } from '../../core/walk.ts';
+import { scanLoopingWalk, scanWalkSetup } from '../../core/walk.ts';
+import type { ScanPose } from '../../core/raw.ts';
 import { noSkinView } from '../../render_core.ts';
 import type { ModelBone } from '../../model.ts';
 import type { SteppedFrame, SteppedPoseFacts } from '../facts/stepped_poses.ts';
@@ -45,11 +54,11 @@ const channel = (v: number | null): number => (v === null ? Number.NaN : v);
 /** Each bone's posed mode as the facts spell it (`modeOf`), by name. */
 const modesOf = (posed: readonly ModelBone[]): ReadonlyMap<string, string | null> => new Map(posed.map((b) => [b.name, modeOf(b)]));
 
-/** One walk pose as A10 reads it, each bone's mode taken from `modes` (`modesOf` the bones the timelines posed at the pose's time). */
-function frameOf(pose: WalkPose, modes: ReadonlyMap<string, string | null>): SteppedFrame {
+/** One scan pose as A10 reads it, each bone's mode taken from `modes` (`modesOf` the bones the timelines posed at the pose's time); the drawn attachments are the scan's own rows, already in the shape A10 reads. */
+function frameOf(pose: ScanPose, modes: ReadonlyMap<string, string | null>): SteppedFrame {
   return {
     bones: pose.bones.map((b) => ({ name: b.name, a: b.a, b: b.b, c: b.c, d: b.d, worldX: b.worldX, worldY: b.worldY, inherit: modes.get(b.name) ?? null })),
-    drawn: pose.drawn.map((d) => ({ slot: d.slot, attachment: d.attachment, vertices: d.vertices })),
+    drawn: pose.drawn,
     slots: pose.slots.map((row) => ({
       name: row[0],
       colour: [channel(row[2]), channel(row[3]), channel(row[4]), channel(row[5])] as const,
@@ -82,10 +91,10 @@ export function modelSteppedPoses(read: ReadDocument): SteppedPoseFacts {
     },
     // The document's stated mode — asked only of a bone posing none, which the reader leaves this side no document to hold.
     statedInherit: (name) => `${JSON.stringify(read.doc.bones.find((b) => b.name === name)?.inheritMode)}`,
-    setup: () => frameOf(poseWalkSetup(viewOf()), modesOf(viewOf().bones)),
+    setup: () => frameOf(scanWalkSetup(viewOf()), modesOf(viewOf().bones)),
     walk: (animation, step, frames) => {
       const anim = animationOf(animation);
-      const poses = poseLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
+      const poses = scanLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
       // A bone's posed mode moves only by an `inherit` timeline: every other one `posedBones` reads leaves the setup's mode on its copy. So an animation
       // keying none poses the setup's modes at every time, and they are read once rather than posed again at each of its frames (issue #1179).
       const keysInherit = anim.timelines.bones.some((target) => target.timelines.some((tl) => tl.kind === 'inherit'));

package/src/core/animation.ts

@@ -797,6 +797,17 @@ export function posedBoneWorld(doc: CompiledDocument, timelines: CoreAnimationTi
   return { rows: stepRows(posed), world: posed.world };
 }
 
+/**
+ * `posedBoneWorld`'s world transforms without its rows (issue #1179, the
+ * second part): the same pose by the same operations in the same order, since
+ * `stepRows` only reads the world once it is posed. A walk reads `world` and
+ * no row, so the scan's walk (`scanWalkIn` in `./raw.ts`, A10's) asks for
+ * this; the raw entry's walk still forms the rows it does not read, unchanged.
+ */
+export function posedBoneWorldAlone(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant, constraints: CoreConstraintTimelines | undefined, sliders: SliderApplication[] | undefined, step: { ctx: PhysicsStepContext; before: number } | undefined): Map<string, CoreWorld> {
+  return posedBoneStep(doc, timelines, t, plant, constraints, sliders, step).world;
+}
+
 /**
  * One pose of the bones before its rows are read: the world transforms, and
  * what the rows are rounded from. A stepped walk reads rows only off the step

package/src/core/raw.ts

@@ -114,14 +114,14 @@
  * 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 { posedBoneWorld, posedSlots, type TimelinePlant } from './animation.ts';
+import { posedBoneWorld, posedBoneWorldAlone, posedSlots, type TimelinePlant } from './animation.ts';
 import { constraintsAbsentWhy, pathAnimationsWhy } from './constraints.ts';
 import { freshStepContext, steppedPreviousPassWhy } from './constraints_physics.ts';
 import { attachmentStates } from './deform.ts';
 import { drawOrderAt } from './draw_order.ts';
 import { eventsFired } from './events.ts';
-import { REGION_TRIANGLES, REGION_UVS, type ShapeClipper } from './clipping.ts';
-import { poseGeometry, type ShownGeometry } from './vertices.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 { RUNTIME_DEG, type CoreWorld } from './world.ts';
 import type { SliderApplication } from './constraints_slider.ts';
 
@@ -195,6 +195,43 @@ export interface RawPose {
   // --- #968 render: end ---
 }
 
+/**
+ * One bone as the scan reads it (issue #1179, the second part): the world
+ * matrix and origin `RawBone` carries, and none of the readings it forms from
+ * them. `A10_NO_NAN_AFTER_STEPPING` reads these six numbers and the name off a
+ * bone, and nothing else (`firstNonFinite` in `src/nonfinite.ts`).
+ */
+export interface ScanBone {
+  name: string;
+  a: number;
+  b: number;
+  c: number;
+  d: number;
+  worldX: number;
+  worldY: number;
+}
+
+/**
+ * One pose as the scan reads it (issue #1179, the second part) — the scan's
+ * walk (`scanWalkIn`, `scanSetupIn`): the time the animation was applied at,
+ * and the bones, slot rows and drawn attachments computed exactly as a
+ * `RawPose`'s are. Internal to A10's walk (`./walk.ts`); no exported pose type
+ * changed for it.
+ */
+export interface ScanPose {
+  animationTime: number;
+  bones: ScanBone[];
+  slots: CoreSlotRow[];
+  drawn: ScanDrawn[];
+}
+
+/** One region or mesh drawn, as the scan reads it: its slot, its name and its world vertices, as `RawDrawn` carries them. */
+export interface ScanDrawn {
+  slot: string;
+  attachment: string;
+  vertices: number[];
+}
+
 // --- #968 render: begin ---
 /** The shown records in `order`, the pose's draw order (a pose's `shown`). */
 function drawOrderOf(shown: readonly ShownGeometry[], order: readonly string[]): ShownGeometry[] {
@@ -274,17 +311,96 @@ function rawBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>):
   });
 }
 
-/** Every region and mesh the shown records draw, with what the renderer reads past the vertices (the header's `drawn`). */
-function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode = RAW_MODE): { drawn: RawDrawn[]; clips: RawClip[]; clipped: RawClipped[] } {
+/**
+ * The bones of a scan pose (`ScanBone`): `rawBones` less the parent, the
+ * active flag and the four getter readings, which nothing the scan reads is
+ * computed from — each reading is formed from the world after it is posed,
+ * and the matrix and origin are copied as they are.
+ */
+function scanBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>): ScanBone[] {
+  return doc.bones.map((b): ScanBone => {
+    const w = world.get(b.name);
+    if (w === undefined) throw new CoreInputError(`bone "${b.name}" has no world transform`);
+    return { name: b.name, a: w.a, b: w.b, c: w.c, d: w.d, worldX: w.worldX, worldY: w.worldY };
+  });
+}
+
+/**
+ * What a pose draws, posed and refused where the core leaves it out: the
+ * attachment rows, the clip rows and the drawn clipped rows — what `rawDrawn`
+ * and `scanDrawn` both assemble from.
+ */
+function drawnGeometry(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode): { rows: CoreAttachmentRow[]; clips: CoreClipRow[]; drawnClipped: CoreClippedRow[] } {
   const draw = drawWalkOf(doc, order, plant);
   const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, mode.loop && plant.through === undefined ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
   if (geometry.attachments === null) throw new CoreInputError(`the raw pose leaves the attachments out: ${geometry.attachmentsWhy}`);
   // The drawn rows (issue #964): the oracle's `clipped` rows where it is posed, and a concave or inverse clip cut through the core's own decomposition.
   if (geometry.drawnClipped === null) throw new CoreInputError(`the raw pose leaves the clipped triangles out: ${geometry.drawnClippedWhy}`);
+  return { rows: geometry.attachments, clips: geometry.clips, drawnClipped: geometry.drawnClipped };
+}
+
+/**
+ * The drawn attachments of a scan pose (`ScanDrawn`): `rawDrawn`'s rows, each
+ * its slot, its name and its world vertices through the same `numberOf`, and
+ * none of what `rawDrawn` reads past them for a renderer — the UVs and
+ * triangles it copies, the record it looks up for the colour and the sequence
+ * frame, the hull, the clip rows' numbers. No vertex is computed from any of
+ * those. The one refusal `rawDrawn` makes past the rows, a linked mesh whose
+ * source carries no mesh, is not reachable here: `poseGeometry` resolved the
+ * same source by the same lookup (`sourceOfDoc`) and throws before it returns.
+ *
+ * 🔁 **No copy of the vertices** (issue #1179, the second part): `rawDrawn`
+ * maps each row through `numberOf` into a new array; under `keep` that map is
+ * the identity on every number and turns only a `null` into NaN. The scan
+ * hands the row's own array on wherever it holds no `null` (`allNumbers`) and
+ * 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.
+ */
+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);
+  const drawn: ScanDrawn[] = [];
+  let k = 0;
+  for (const s of shown) {
+    const g = s.geometry;
+    if (g.kind !== 'region' && g.kind !== 'mesh' && g.kind !== 'linkedmesh') continue;
+    const row = rows[k++];
+    if (row === undefined || row[0] !== s.slot) throw new CoreInputError(`slot "${s.slot}": the attachment rows are not in the shown records' order`);
+    const vertices = row[3];
+    const kept = mode.keep && allNumbers(vertices) ? vertices : vertices.map((v) => numberOf(v, `vertex of slot "${s.slot}"`, mode));
+    drawn.push({ slot: s.slot, attachment: row[1], vertices: scanPlant.vertices === undefined ? kept : scanPlant.vertices(kept, s.slot) });
+  }
+  return drawn;
+}
+
+/** 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;
+  return true;
+}
+
+/**
+ * The scan's one plant (the core suite's `CO45`): what a drawn row's vertices
+ * are handed on as, given the array the scan would hand on. A poser that
+ * reuses one buffer per slot across steps is the plant `CO45` passes.
+ * Nothing but a control passes one.
+ */
+export interface ScanPlant {
+  vertices?: (vertices: number[], slot: string) => number[];
+}
+
+/** Every region and mesh the shown records draw, with what the renderer reads past the vertices (the header's `drawn`). */
+function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode = RAW_MODE): { drawn: RawDrawn[]; clips: RawClip[]; clipped: RawClipped[] } {
+  const geometry = drawnGeometry(doc, shown, world, order, plant, mode);
   // Under a concave or inverse clip the oracle's `clipped` block is absent (the runtime's own triangle list); what the core draws is `drawnClipped`,
   // its own decomposition, and the render samples each drawn triangle at its source triangle's affine UV, so the pixels are the decomposition's
   // coverage alone (issue #964, `Mesh.source` in src/render.ts).
-  const rows = geometry.attachments;
+  const rows = geometry.rows;
   const drawn: RawDrawn[] = [];
   let k = 0;
   for (const s of shown) {
@@ -326,14 +442,27 @@ export function poseRawSetup(doc: CompiledDocument, plant: CorePlant = {}): RawP
 
 /** `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);
+  const drawn = rawDrawn(doc, shown, world, drawOrder, plant, mode);
+  return { trackTime: 0, animationTime: 0, bones: rawBones(doc, world), slots, drawOrder, ...drawn, events: [], shown: drawOrderOf(shown, drawOrder) };
+}
+
+/** `setupPoseIn` as the scan reads it (`ScanPose`): the same setup pose, the same refusals in the same order, assembled into the scan's pose. */
+export function scanSetupIn(doc: CompiledDocument, plant: CorePlant, mode: WalkMode, scanPlant: ScanPlant = {}): ScanPose {
+  const { world, shown, slots, drawOrder } = setupPosed(doc, plant, mode);
+  const drawn = scanDrawn(doc, shown, world, drawOrder, plant, mode, scanPlant);
+  return { animationTime: 0, bones: scanBones(doc, world), slots, drawn };
+}
+
+/** The setup pose `setupPoseIn` and `scanSetupIn` assemble, refused by name where the core leaves a block of it out. */
+function setupPosed(doc: CompiledDocument, plant: CorePlant, mode: WalkMode): { world: Map<string, CoreWorld>; shown: ShownGeometry[]; slots: CoreSlotRow[]; drawOrder: string[] } {
   const posed = poseSetup(doc, { ...plant, ...roundPlant(mode) }, freshStepContext(plant.physicsStep));
   // `setup.clipped` is the oracle's block, left out under a concave or inverse clip whose triangle list is the runtime's own; what the core draws there is `rawDrawn`'s to refuse or pose (issue #964).
   const absent = posed.absent.filter(([block]) => block !== 'setup.clipped');
   if (absent.length > 0) throw new CoreInputError(`the raw setup pose leaves ${absent.map(([b, why]) => `${b} out (${why})`).join('; ')}`);
   const { setup, world, shown } = posed;
   if (world === null || shown === null || setup.slots === null || setup.drawOrder === null) throw new CoreInputError('the raw setup pose was not posed');
-  const drawn = rawDrawn(doc, shown, world, setup.drawOrder, plant, mode);
-  return { trackTime: 0, animationTime: 0, bones: rawBones(doc, world), slots: setup.slots, drawOrder: setup.drawOrder, ...drawn, events: [], shown: drawOrderOf(shown, setup.drawOrder) };
+  return { world, shown, slots: setup.slots, drawOrder: setup.drawOrder };
 }
 
 /**
@@ -361,7 +490,7 @@ export function poseRawAnimation(doc: CompiledDocument, animation: string, steps
  * poses before it.
  */
 export function poseRawAnimationEach(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, visit: (pose: RawPose, index: number) => void): void {
-  walkEach(doc, animation, steps, plant, reset, RAW_MODE, visit);
+  walkEach(doc, animation, steps, plant, reset, RAW_MODE, RAW_SHAPE, visit);
 }
 
 /**
@@ -381,12 +510,81 @@ export function loopedTime(trackTime: number, duration: number): number {
  */
 export function walkIn(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode): RawPose[] {
   const poses: RawPose[] = [];
-  walkEach(doc, animation, steps, plant, reset, mode, (pose) => poses.push(pose));
+  walkEach(doc, animation, steps, plant, reset, mode, RAW_SHAPE, (pose) => poses.push(pose));
   return poses;
 }
 
-/** `walkIn`'s walk, each pose handed to `visit` in order as it is posed (`poseRawAnimationEach`). */
-function walkEach(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode, visit: (pose: RawPose, index: number) => void): void {
+/**
+ * `walkIn` as the scan reads it (`ScanPose`, issue #1179, the second part):
+ * the same walk — every pose posed by the same operations in the same order,
+ * every refusal at the same place — each pose assembled into what A10 reads.
+ * `./walk.ts`'s `scanLoopingWalk` is its one caller.
+ */
+export function scanWalkIn(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode, scanPlant: ScanPlant = {}): ScanPose[] {
+  const poses: ScanPose[] = [];
+  walkEach(doc, animation, steps, plant, reset, mode, scanPlant.vertices === undefined ? SCAN_SHAPE : scanShape(scanPlant), (pose) => poses.push(pose));
+  return poses;
+}
+
+/** What one step of a walk posed, before a pose is assembled from it (`PoseShape`). */
+interface WalkStep {
+  trackTime: number;
+  animationTime: number;
+  world: Map<string, CoreWorld>;
+  slots: CoreSlotRow[];
+  drawOrder: string[];
+  shown: ShownGeometry[];
+  /** The events the step fired, computed when called — after the drawn rows, as the raw entry has always ordered its refusals. */
+  events: () => RawEvent[];
+}
+
+/**
+ * What a walk assembles each pose into (issue #1179, the second part): the raw
+ * entry's whole pose (`RAW_SHAPE`), or the scan's (`SCAN_SHAPE`). The walk
+ * (`walkEach`) is one body: every number a pose carries is computed there and
+ * in the two assemblers below, by the same calls, whatever the shape. A shape
+ * chooses only what is assembled from what was posed — the scan drops the
+ * readings, rows and copies nothing it reads is computed from — and keeps the
+ * order of every call that can refuse.
+ */
+interface PoseShape<P> {
+  /** Whether a step forms the oracle's bone rows beside its world (`posedBoneWorld`), which no walk pose carries; `false` poses the world alone (`posedBoneWorldAlone`). */
+  rows: boolean;
+  /** The reset pose at the setup (`reset: 'setup'`). */
+  setup: (doc: CompiledDocument, world: Map<string, CoreWorld>, slots: CoreSlotRow[], drawOrder: string[], shown: ShownGeometry[], plant: CorePlant, mode: WalkMode) => P;
+  /** One step's pose. */
+  step: (doc: CompiledDocument, posed: WalkStep, plant: CorePlant, mode: WalkMode) => P;
+}
+
+/** The raw entry's pose, assembled as it always was: at the reset the bones, then the drawn rows; at a step the drawn rows, the events, then the bones. */
+const RAW_SHAPE: PoseShape<RawPose> = {
+  rows: true,
+  setup: (doc, world, slots, drawOrder, shown, plant, mode) => ({ trackTime: 0, animationTime: 0, bones: rawBones(doc, world), slots, drawOrder, ...rawDrawn(doc, shown, world, drawOrder, plant, mode), events: [], shown: drawOrderOf(shown, drawOrder) }),
+  step: (doc, p, plant, mode) => {
+    const drawn = rawDrawn(doc, p.shown, p.world, p.drawOrder, plant, mode);
+    const events = p.events();
+    return { trackTime: p.trackTime, animationTime: p.animationTime, bones: rawBones(doc, p.world), slots: p.slots, drawOrder: p.drawOrder, ...drawn, events, shown: p.shown };
+  },
+};
+
+/** The scan's pose (`ScanPose`), in the raw shape's order: the scan's walk is a looping one, which fires no event. */
+function scanShape(scanPlant: ScanPlant): PoseShape<ScanPose> {
+  return {
+    rows: false,
+    setup: (doc, world, slots, drawOrder, shown, plant, mode) => {
+      const bones = scanBones(doc, world);
+      return { animationTime: 0, bones, slots, drawn: scanDrawn(doc, shown, world, drawOrder, plant, mode, scanPlant) };
+    },
+    step: (doc, p, plant, mode) => {
+      const drawn = scanDrawn(doc, p.shown, p.world, p.drawOrder, plant, mode, scanPlant);
+      return { animationTime: p.animationTime, bones: scanBones(doc, p.world), slots: p.slots, drawn };
+    },
+  };
+}
+const SCAN_SHAPE: PoseShape<ScanPose> = scanShape({});
+
+/** `walkIn`'s walk, each pose assembled in `shape` and handed to `visit` in order as it is posed (`poseRawAnimationEach`). */
+function walkEach<P>(doc: CompiledDocument, animation: string, steps: readonly number[], plant: TimelinePlant, reset: RawReset, mode: WalkMode, shape: PoseShape<P>, visit: (pose: P, index: number) => void): void {
   const anim = doc.animations.find((a) => a.name === animation);
   if (anim === undefined) throw new CoreInputError(`animation "${animation}" is not one of this document's [${doc.animations.map((a) => a.name).join(', ')}]`);
   const bad = steps.findIndex((s) => !Number.isFinite(s) || s < 0);
@@ -408,7 +606,7 @@ function walkEach(doc: CompiledDocument, animation: string, steps: readonly numb
     if (absent.length > 0) throw new CoreInputError(`the raw walk's reset pose leaves ${absent.map(([b, w]) => `${b} out (${w})`).join('; ')}`);
     if (setup.world === null || setup.shown === null || setup.setup.slots === null || setup.setup.drawOrder === null) throw new CoreInputError('the raw walk\'s reset pose was not posed');
     ctx.phase = 'update';
-    visit({ trackTime: 0, animationTime: 0, bones: rawBones(doc, setup.world), slots: setup.setup.slots, drawOrder: setup.setup.drawOrder, ...rawDrawn(doc, setup.shown, setup.world, setup.setup.drawOrder, plant, mode), events: [], shown: drawOrderOf(setup.shown, setup.setup.drawOrder) }, visited++);
+    visit(shape.setup(doc, setup.world, setup.setup.slots, setup.setup.drawOrder, setup.shown, plant, mode), visited++);
   }
   for (let i = reset === 'setup' ? 1 : 0; i <= steps.length; i++) {
     const dt = i === 0 ? 0 : steps[i - 1];
@@ -417,7 +615,7 @@ function walkEach(doc: CompiledDocument, animation: string, steps: readonly numb
     const before = ctx.time;
     ctx.time += mode.clock === undefined ? dt : mode.clock(dt, t - (i === 0 ? 0 : Math.max(last, 0)));
     const sliders: SliderApplication[] = [];
-    const posed = posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before });
+    const world = shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before });
     if (i === 0) ctx.phase = 'update';
     const placeholders = new Map<string, string | null>();
     const slots = posedSlots(doc, anim.timelines, t, raw, sliders, placeholders);
@@ -430,12 +628,13 @@ function walkEach(doc: CompiledDocument, animation: string, steps: readonly numb
     if (states.why.length > 0) throw new CoreInputError(`the raw walk leaves the attachments out: ${states.why.join('; ')}`);
     const rank = new Map(drawOrder.map((n, r) => [n, r]));
     const shown = [...states.shown].sort((a, b) => (rank.get(a.slot) ?? 0) - (rank.get(b.slot) ?? 0));
-    const drawn = rawDrawn(doc, shown, posed.world, drawOrder, plant, mode);
     // A looping walk fires no event here: what fires across the wrap was not measured, and the walk's one reader (A10) reads none. Nor does it cut its
     // drawn attachments through a clip (`NO_CLIPPED_ROWS`), so its `clipped` rows are empty.
-    const events = mode.loop ? [] : (plant.events ?? eventsFired)(anim.timelines.events, last, t, rawNumber).map((e): RawEvent => [e[0], finite(e[1], 'event time'), e[2], finite(e[3], 'event float'), e[4]]);
+    const from = last;
+    const events = (): RawEvent[] => (mode.loop ? [] : (plant.events ?? eventsFired)(anim.timelines.events, from, t, rawNumber).map((e): RawEvent => [e[0], finite(e[1], 'event time'), e[2], finite(e[3], 'event float'), e[4]]));
+    const pose = shape.step(doc, { trackTime, animationTime: t, world, slots: slots.rows, drawOrder, shown, events }, plant, mode);
     last = t;
-    visit({ trackTime, animationTime: t, bones: rawBones(doc, posed.world), slots: slots.rows, drawOrder, ...drawn, events, shown }, visited++);
+    visit(pose, visited++);
   }
 }
 

package/src/core/walk.ts

@@ -76,7 +76,7 @@
  * poses the class as the raw entry does, and refuses nothing the raw entry
  * does not.
  */
-import { setupPoseIn, walkIn, type RawBone, type RawDrawn, type WalkMode } from './raw.ts';
+import { scanSetupIn, scanWalkIn, setupPoseIn, walkIn, type RawBone, type RawDrawn, type ScanPlant, type ScanPose, type WalkMode } from './raw.ts';
 import { activeBones, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
 import { historyTaint } from './constraints.ts';
 import type { TimelinePlant } from './animation.ts';
@@ -175,3 +175,23 @@ export function poseLoopingWalk(doc: CompiledDocument, animation: string, steps:
   const mode: WalkMode = { ...LOOPING, ...(walkPlant.time === undefined ? {} : { time: walkPlant.time }), ...(walkPlant.clock === undefined ? {} : { clock: walkPlant.clock }), ...(walkPlant.wrapResets === undefined ? {} : { wrapResets: walkPlant.wrapResets }) };
   return walkIn(doc, animation, steps, plant, 'setup', mode).map((p) => narrow(p, walkPlant.number));
 }
+
+/**
+ * The scan's walk (issue #1179, the second part): `poseLoopingWalk` and
+ * `poseWalkSetup` as A10 reads them, each pose a `ScanPose` — the bones' world
+ * matrix and origin, the slot rows and the drawn attachments, and nothing the
+ * walk forms beside them for other readers (the bones' oracle rows and getter
+ * readings). The same walk: `walkIn`'s body in `./raw.ts`, posing each step by
+ * the same operations in the same order and refusing at the same places, with
+ * another assembler (`PoseShape`). `src/assertions/model/stepped_poses.ts` is
+ * its one caller; the public entries above are unchanged, and the core suite
+ * holds the two to the same numbers (`CO43`, `CO44`, `CO45`).
+ */
+export function scanLoopingWalk(doc: CompiledDocument, animation: string, steps: readonly number[], scanPlant: ScanPlant = {}): ScanPose[] {
+  return scanWalkIn(doc, animation, steps, {}, 'setup', LOOPING, scanPlant);
+}
+
+/** `poseWalkSetup` as the scan reads it (`scanLoopingWalk`). */
+export function scanWalkSetup(doc: CompiledDocument): ScanPose {
+  return scanSetupIn(doc, {}, LOOPING);
+}

package/src/rig.ts

@@ -59,6 +59,7 @@
  * `slots` below for the join rule) and leaves `skins` empty. A foreign skeleton
  * with no manifest at all declares them here.
  */
+import { ikShapeFault } from './assertions/bodies/a47.ts';
 import { CompileError, NotImplementedError } from './errors.ts';
 import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys, refuseValuesOfTheWrongType, refuseValuesOutsideTheirSet } from './keys.ts';
 import type { ShapeVisit, SpecEnumTable, SpecValueType } from './keys.ts';
@@ -1352,7 +1353,13 @@ export type RigScaleYMode = 'none' | 'uniform' | 'volume' | 'None' | 'Uniform' |
 /** `type: "ik"` (`:149-176`). `scaleY` is 4.3's replacement for 4.2's `uniform`. */
 export interface RigIkConstraint extends RigConstraintCommon {
   type: 'ik';
-  /** At least one, resolved by name; a miss throws in the parser. */
+  /**
+   * One bone, or two where the second's parent is the first; resolved by
+   * name, and a miss throws in the parser. Any other shape is refused by name
+   * (issue #1205): the runtime applies nothing for three or more, and solves
+   * a pair through the first bone's matrix from the second's local offset, so
+   * a bone standing between them is left out of the triangle it solves.
+   */
   bones: string[];
   target: string;
   /** `ConstraintData.ts:50`. Absent → `None`. */
@@ -2682,6 +2689,20 @@ export function parseRigSpec(raw: unknown, where: string): RigSpec {
     constraintsDeclared.push(declared);
     constraintFacts.set(constraintAt(declared.type, declared.name), declared);
     constraintKinds.set(declared.name, [...(constraintKinds.get(declared.name) ?? []), declared.type]);
+    // An ik's `bones` as a shape (issue #1205): more than two, or a pair that is
+    // not a parent and its child, both load and build green and the solver then
+    // moves nothing or solves a triangle nobody drew — `ikShapeFault` says which.
+    // Read only once every name resolves to a declared bone, so a misspelling is
+    // still the compiler's refusal by name rather than a shape it does not have.
+    const ikBones = constraint.type === 'ik' ? constraint.bones : undefined;
+    if (Array.isArray(ikBones) && ikBones.every((b): b is string => typeof b === 'string' && seen.has(b))) {
+      const secondAncestors: string[] = [];
+      if (ikBones.length === 2) {
+        for (let at = spec.bones.find((b) => b.name === ikBones[1])?.parent; at !== undefined; at = spec.bones.find((b) => b.name === at)?.parent) secondAncestors.push(at);
+      }
+      const fault = ikShapeFault(constraint.name, ikBones, secondAncestors);
+      if (fault !== null) throw new CompileError(`${where}: ${fault}`);
+    }
   }
 
   // `invariants.consumerDrivenMix` — the second field in `invariants` that TURNS

package/src/validate.ts

@@ -1641,7 +1641,9 @@ export function spineConstraintFacts(data: ReturnType<SkeletonJson['readSkeleton
       };
     }
     if (c instanceof IkConstraintData) {
-      return { kind: 'ik', name: c.name, runtimeClass, ik: { bones: c.bones.map((b) => b.name), target: c.target.name, mix: c.setupPose.mix } };
+      const secondAncestors: string[] = [];
+      if (c.bones.length === 2) for (let at = c.bones[1].parent; at !== null; at = at.parent) secondAncestors.push(at.name);
+      return { kind: 'ik', name: c.name, runtimeClass, ik: { bones: c.bones.map((b) => b.name), target: c.target.name, mix: c.setupPose.mix, secondAncestors } };
     }
     if (c instanceof TransformConstraintData) {
       const pose = c.setupPose;

package/tools/editor_roundtrip.ts

@@ -20,6 +20,22 @@
  * It ran from a shell script in a local scratch directory. A tool nobody can
  * find is not a tool, hence this file.
  *
+ * ## Which editor the report names
+ *
+ * Step 0's version line is the one place the report says which editor the trip
+ * ran on. It is read from the editor's `--version` started with the SAME `-u`
+ * the import and the export carry (`--editor-version`), so a pinned run names
+ * the pinned editor, and says so on that line: `(read from --version under -u
+ * <v>, …)`. An unpinned run prints the line alone, read from `--version` with no
+ * `-u` — the editor the launcher starts by default. Once the export exists,
+ * step 2 holds that version against the export's own `skeleton.spine`, prints
+ * one line saying which it read and that the two agree, and when they DISAGREE
+ * prints a `FAIL` naming both values and ends the run non-zero: a version line
+ * that names an editor the trip did not export on is a fault in the instrument,
+ * and a green run carrying it would be a measurement naming the wrong
+ * instrument (issue #1199, where a bare `--version` named the launcher's
+ * default, 4.3.26, on a trip pinned to and exported by 4.3.23).
+ *
  * ## What it is not
  *
  * 🔒 **It is not a way to get Spine data without the editor** — it is the
@@ -182,10 +198,82 @@ function bundleName(plist: string): string | null {
  */
 const EDITOR_VERSION_LINE = /^Spine[ \t]+\d+\.\d+\.\d+\b[^\n]*$/m;
 
-/** What step 0 prints for the editor's version: its own line, or a sentence saying it was not there. */
-function editorVersionLine(output: string): string {
-  const line = EDITOR_VERSION_LINE.exec(output);
-  return line === null ? 'editor version: not found in --version output' : line[0].trim();
+/**
+ * What step 0 prints for the editor's version — its own line, or a sentence
+ * saying it was not there — and the `x.y.z` that line names, which is what the
+ * export's own `skeleton.spine` is checked against once the export exists
+ * (issue #1199). `version` is null exactly when `line` is the absence.
+ */
+function editorVersion(output: string): { line: string; version: string | null } {
+  const found = EDITOR_VERSION_LINE.exec(output);
+  if (found === null) return { line: 'editor version: not found in --version output', version: null };
+  return { line: found[0].trim(), version: /^Spine[ \t]+(\d+\.\d+\.\d+)/.exec(found[0])?.[1] ?? null };
+}
+
+/**
+ * Where step 0 read the editor's version, in the words the report prints it in
+ * (issue #1199): the `--version` call, and the `-u` it carried or the absence of
+ * one — which on an unpinned run means the editor the launcher starts by default.
+ */
+function versionSource(pinned: string | null): string {
+  return pinned === null
+    ? "read from --version with no -u: the editor the launcher starts by default"
+    : `read from --version under -u ${pinned}, the pin every editor call of this trip carries`;
+}
+
+/**
+ * The `skeleton.spine` an export declares, or null when it declares none or the
+ * file cannot be read as a skeleton — read off the FILE, as `shapeOf` reads it,
+ * because it is the editor's own statement of the data version it exported.
+ * Null is not swallowed: the caller states that nothing was there to check.
+ */
+function declaredSpineVersion(path: string): string | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isRecord(parsed) || !isRecord(parsed.skeleton)) return null;
+    const spine = parsed.skeleton.spine;
+    return typeof spine === 'string' ? spine : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The line step 2 prints once the export exists: the version step 0 read held
+ * against the export's own `skeleton.spine` (issue #1199). `fail` is true only
+ * when both are there and differ — a disagreement is a finding about the
+ * INSTRUMENT, not a pass, so it fails the trip; a side with nothing to compare is
+ * stated and fails nothing, the way an absent version line has never been a
+ * refusal (#1077).
+ */
+export function versionAgreement(
+  read: string | null,
+  pinned: string | null,
+  declared: string | null,
+): { line: string; fail: boolean } {
+  const source = versionSource(pinned);
+  if (declared === null) {
+    return {
+      line: `  the export declares no skeleton.spine, so the version step 0 ${read === null ? 'did not find' : `read (${read}, ${source})`} is not checked against it`,
+      fail: false,
+    };
+  }
+  if (read === null) {
+    return {
+      line: `  the export declares skeleton.spine "${declared}"; step 0 found no version line (${source}) to check it against`,
+      fail: false,
+    };
+  }
+  if (read === declared) {
+    return { line: `  the export declares skeleton.spine "${declared}", the version step 0 read (${source})`, fail: false };
+  }
+  return {
+    line:
+      `  FAIL  step 0 read the editor as ${read} (${source}) and the export declares skeleton.spine "${declared}" — ` +
+      'the version line names an editor this trip did not export on, which is a fault in the instrument rather ' +
+      'than in the rig, so the trip is not green',
+    fail: true,
+  };
 }
 
 /** The trial naming itself in its own `--version` output, or null. */
@@ -1286,6 +1374,10 @@ function main(): void {
   emit(`  ${run(rigc.cmd, [...rigc.prefix, '--version'], 60).stdout.trim()}`);
 
   let exportedJson: string;
+  /** The `x.y.z` step 0 read off the editor, held against the export at step 2 (issue #1199). */
+  let editorRead: string | null = null;
+  /** True when the export's `skeleton.spine` and step 0's version both exist and differ. */
+  let versionDisagrees = false;
   if (opts.exported !== null) {
     exportedJson = opts.exported;
     emit(`  editor   NOT RUN — measuring an export the editor already made: ${opts.exported}`);
@@ -1309,16 +1401,26 @@ function main(): void {
     const named = trialSignalsFromPath(opts.editor);
     if (named.length > 0) fail(trialRefusal(opts.editor, named));
 
-    const ver = run(opts.editor, ['--version'], 60);
+    const pin = opts.editorVersion === null ? [] : ['-u', opts.editorVersion];
+    // 🚨 Under the same `-u` the import and the export carry (issue #1199). The
+    // call used to be a bare `--version`, which names the editor the LAUNCHER
+    // starts by default: measured 2026-10-07 on a launcher whose default is
+    // 4.3.26, a trip pinned with `-u 4.3.23` exported `"spine": "4.3.23"` and
+    // step 0 printed `Spine 4.3.26 Professional` — the one line that says which
+    // editor the trip ran on, naming one it did not run on.
+    const ver = run(opts.editor, [...pin, '--version'], 60);
     emit(`  editor   ${opts.editor}`);
     // One line, never the output's tail: the tail is the licensee's (issue #1077).
-    emit(`           ${editorVersionLine(`${ver.stdout}\n${ver.stderr}`)}`);
+    // A pinned run says where the line came from; an unpinned run prints the line
+    // alone, as it always has, and step 2 states its source beside the export's.
+    const stated = editorVersion(`${ver.stdout}\n${ver.stderr}`);
+    editorRead = stated.version;
+    emit(`           ${stated.line}${opts.editorVersion === null ? '' : `  (${versionSource(opts.editorVersion)})`}`);
     // The second signal, and the only one that works on a platform whose trial
     // path this repository has never seen: the binary's own banner. It costs no
     // extra call — `--version` above is one the tool already made.
     const introduced = trialSignalFromVersion(`${ver.stdout}\n${ver.stderr}`);
     if (introduced !== null) fail(trialRefusal(opts.editor, [introduced]));
-    const pin = opts.editorVersion === null ? [] : ['-u', opts.editorVersion];
 
     emit('');
     emit('## 1 import  (json -> project)');
@@ -1353,6 +1455,11 @@ function main(): void {
       );
     }
     exportedJson = join(opts.out, 'export', written[0]);
+    // 🔒 The version line checked against what the trip measured, once there is
+    // an export to read (issue #1199): the editor's own `skeleton.spine`.
+    const agreement = versionAgreement(editorRead, opts.editorVersion, declaredSpineVersion(exportedJson));
+    emit(agreement.line);
+    versionDisagrees = agreement.fail;
   }
 
   // The candidate: the export beside the build's atlas and pages, which were
@@ -1518,7 +1625,9 @@ function main(): void {
   // The verdict is the gate's and EVERY skin's check, not this tool's opinion of
   // them: one skin coming back wrong is the whole run coming back wrong, which
   // is the half a single un-skinned check could not say.
-  process.exit(gate.status === 0 && checksClean && rosterClean ? 0 : 1);
+  // A version line that disagrees with the export is red too (issue #1199): the
+  // report would otherwise name an editor the trip did not run on, green.
+  process.exit(gate.status === 0 && checksClean && rosterClean && !versionDisagrees ? 0 : 1);
 }
 
 // ⭐ Guarded so `shapeOf`, `shapeDiff`, `skinsDeclaredBy` and `skinBlocks` can be