spine-rigc 2.0.2 → 2.0.3

package/README.md

@@ -680,7 +680,9 @@ none of it; a skin only one side declares is a FAIL naming it as **lost** (or
 **added**) **by the export**, with `diff`'s `attachments.skins` beside it, and is
 rendered on neither side — and a
 field-by-field list of what the editor rewrote. Every step quotes what its child
-said when that child did not do what it was for, the renderers included; a skin
+said when that child did not do what it was for, the renderers included — the
+editor's words in full and in order, except its `Licensed to:` line, which names
+the licence holder and is replaced by a line saying it was withheld; a skin
 **neither** side can draw — a hit-box rig, say — is a **SKIP** naming that, not a
 red, because `check` had nothing to compare and `diff` and `validate` have
 already measured the rig. One side drawing where the other does not is the

package/docs/AUTHORING.md

@@ -1008,6 +1008,24 @@ bun cli.ts pose     --images path/to/parts --frame poseA.png [--out pose.json]
   [INGEST.md](INGEST.md) §1.3.1, and *The measure inventory* in
   [BENCHMARK.md](https://github.com/firejune/rigc/blob/main/docs/BENCHMARK.md),
   which is repository material rather than part of this package.
+
+  🔍 **The wiring is compared by name too, not only the rosters** (issue #1085).
+  `constraints.order` reads the order of the one constraint array, which is the
+  order the runtime applies it in; `animations.targets` reads what each timeline
+  keys and `animations.keyed_names` what each key names — an attachment key's
+  attachment, a draw-order offset's slot, an event key's event; `attachments.refs`
+  reads the region an attachment draws, a clipping polygon's `end` and a linked
+  mesh's `source`; `attachments.skin_members` reads what each skin activates.
+  Every one of those, changed alone, poses or draws differently, and every one read
+  1.000 before. Each note names what differs, candidate first —
+  `candidate only: "heavy|bones|root"; reference only: "heavy|bones|bone"` is a
+  rotate timeline moved from `bone` to `root`, and `attachment
+  "default/clipping/clipping": end "portal-flare6" vs "head-bb"` is a clipping that
+  stops at another slot. A region's `path` is read as the runtime resolves it —
+  `path`, else `name`, else the key — so stating the path an attachment already
+  resolves is no difference. These are name-matched: your own names read low here
+  exactly as they do on `names`, and a low figure with `names` at 1.000 is the
+  wiring that moved.
 - **`check`** renders your candidate into the reference frames' own pixel grid and
   compares pixels — the only thing here that can see a wrong animation. **§9.**
   🚨 What it certifies is the **default skin** unless you pass `--skin <name>`:

package/docs/INGEST.md

@@ -64,7 +64,7 @@ an upstream `license.txt` (Appendix, and [NOTICE.md](../NOTICE.md)).
 | **`preview --candidate <skeleton.json>`** | ✅ **yes** | one self-contained `.html` that plays it in the official Spine Web Player. Needs a network the first time it is opened ([NOTICE.md](../NOTICE.md)) |
 | **`vote --candidate <a> --candidate <b>`** | ✅ **yes, on either side** | a ballot page. Pairing a foreign export against your own transcription is a legitimate ballot, and the panes carry no paths |
 | **`check --candidate <skeleton.json> --frames <dir>`** | ✅ **yes** | ⭐ it reads **frames and never a reference skeleton**, so a foreign export enters this one *twice over*: as the candidate, or — via `render` — as the source of the frames. §1.4 |
-| **`diff <candidate.json> <reference.json>`** | ✅ **yes, both sides** | 49 structural measures over bones, slots, attachments, constraints, animations and events. ⛔ **Blind to every coordinate** — §1.3 |
+| **`diff <candidate.json> <reference.json>`** | ✅ **yes, both sides** | 54 structural measures over bones, slots, attachments, constraints, animations and events. ⛔ **Blind to every coordinate** — §1.3 |
 | **`ingest <skeleton.json> --out <dir>`** | ✅ **yes — and it is the only reader that WRITES specs** | the `.json` alone; no atlas, no art, no project file. Out come `rig.json`, `motion.json` and a findings report, such that `build`ing them reproduces the skeleton it read **byte for byte — for a skeleton rigc emitted**. ⚠️ For an editor export the claim is identity in canonical form apart from `hash` and `spine`, which §2.3 states in full. The seventh reader, and the one that ends §2's hand work — §2.0 and §5 |
 | **`pose --images <dir> --frame <png>`** | ⛔ **not the skeleton** | loose part PNGs and one picture. A packed atlas page is not loose parts, and pointing it at one produces a confident answer about nothing — §5 |
 | **`explain --rig … --motion … --out …`** | ⛔ **no** | rig spec + motion spec. It explains **what you wrote**, which makes it a transcription instrument rather than a reading one — §1.5 |
@@ -215,7 +215,7 @@ Spine runtime plays it, whatever rigc's own rasteriser or validator thinks.
 
 ### 1.3 `diff` — and the two things it cannot see
 
-`diff` takes two compiled skeletons and reports 49 measures in eight groups, plus two
+`diff` takes two compiled skeletons and reports 54 measures in eight groups, plus two
 blocks that report and gate nothing: the `(reported)` measures beside `attachments`
 and `animations`, and the `skeleton` header block at the top, which measures the stage.
 A ninth group of six joins them when something has paired the two sides'
@@ -250,7 +250,7 @@ rigc diff
 
   bones (name-agnostic) mean 1.000  over 5 measures  — the same two skeletons compared with names thrown away
   …
-  animations            mean 1.000  over 9 measures
+  animations            mean 1.000  over 11 measures
       1.000  count                        2/2         how many animations
       1.000  names                        2/2         the animation names
       1.000  duration                     2/2         each animation runs as long (last key time, within one frame)
@@ -267,7 +267,7 @@ it does not say *which* side has three. The `..` line above is where you read th
 ⛔ **`diff` is blind to every coordinate a bone, an attachment or a key carries.** No
 measure reads a bone's `x`/`y`/`rotation`, an attachment's offset, or a key's value —
 only *presence*, *names*, *counts*, *order* and *kinds*. §4.1 moves a pivot 236.5
-units and every one of the 49 measures still reads **1.000**. ⇒ Never take a green
+units and every one of the 54 measures still reads **1.000**. ⇒ Never take a green
 `diff` as evidence that a geometric edit did not land, and never take it as evidence
 that one did.
 
@@ -325,7 +325,7 @@ two sections, the second over the paired shots — `duration`, `timeline_kinds`,
 it used:
 
 ```
-  animations            mean 0.222  over 9 measures
+  animations            mean 0.182  over 11 measures
       1.000  count                        1/1         how many animations
       0.000  names                        0/2         the animation names
       …
@@ -475,8 +475,8 @@ no field of the file).
 📊 **For an editor export the claim is weaker, and measured.** Every
 `examples/*/export/*.json` ingested with `--art none`, rebuilt through the pack
 beside it, and `diff`ed against the file it was read from: **12 of 12 come back with 0
-blockers and 1.000 on all 49 ratio-bearing measures and all 5 reported ones** — and on
-all **nine value measures** too, over **193,927** compared values. Byte
+blockers and 1.000 on all 54 ratio-bearing measures and all 6 reported ones** — and on
+all **nine value measures** too, over **195,363** compared values. Byte
 identity is not the claim there and the reason is the input, not the round trip — §2.3
 has the pass line, and what the value measures do and do not reach. ⚠️ Which pack is "the one beside it" is
 resolved rather than guessed, for §0.2's reason: `spineboy/export` holds two, and
@@ -702,7 +702,7 @@ State the ambition in the right units, because three different things get called
 
 | Ambition | Reachable? | What it costs, and what it proves |
 | --- | --- | --- |
-| **Structural agreement** — same bones, slots, attachments, timelines, key counts, curve kinds | ✅ yes, and `diff` measures it | the 3-timing transcription reads **1.000 on all 49 measures**. Aim here first |
+| **Structural agreement** — same bones, slots, attachments, timelines, key counts, curve kinds | ✅ yes, and `diff` measures it | the 3-timing transcription reads **1.000 on all 54 measures**. Aim here first |
 | **Geometric agreement** — the same drawn pixels, allowing for the atlas | ✅ yes, and `check` measures it | see below |
 | **Byte-identical JSON** | ✅ **for a rebuild, in canonical form, apart from `hash` and `spine`** — the pass line below | a **rebuild** of an editor export (`ingest`, then `build`) is the export. A **transcription** by hand is not held to it: what differs there is what a person chose to write, not the emitter |
 
@@ -745,7 +745,7 @@ keys**, which is why a moved value is invisible to it.
 ⭐ **The values are measured by a second comparison rather than by `diff`.**
 Structure at 1.000 is silent about the numbers inside it: a decompiler that halved
 every rotation, dropped every bone's `length` or mirrored every vertex would read
-1.000 on all 49 measures and on every `(reported)` one. So the example round trip is
+1.000 on all 54 measures and on every `(reported)` one. So the example round trip is
 also compared **value by value**,
 with the format's defaults taken from the parser rather than from a table — both files
 are read through `spine-core` and the parsed forms are compared path by path, under a
@@ -755,12 +755,12 @@ storage. Nine measures — here is the `6-arcs` export's, wrapped to fit this
 page:
 
 ```
-values: 9/9 measure(s) at 1.000 over 13865 compared value(s); skeleton 1.000 ·
+values: 9/9 measure(s) at 1.000 over 13977 compared value(s); skeleton 1.000 ·
 bones 1.000 · slots 1.000 · attachments 1.000 · constraints 1.000 · events 1.000 ·
 key_times 1.000 · key_values 1.000 · curves 1.000
 ```
 
-Over the twelve exports that is **193,927 values** compared, and all twelve read
+Over the twelve exports that is **195,363 values** compared, and all twelve read
 1.000 on all nine.
 
 `docs/BENCHMARK.md`'s *The nine value measures* is the full statement. What it still
@@ -1082,7 +1082,7 @@ same displacement evaluated across the bone's own rotation:
 **What the instruments say about it** — and this pair is why §1.3 carries its warning:
 
 - **`diff` sees nothing.** `rigc diff work/t3b/skeleton.json <the export>` reads
-  **1.000 on all 49 measures**: same bones, names, parents, order, slots, draw order,
+  **1.000 on all 54 measures**: same bones, names, parents, order, slots, draw order,
   attachments, animations, timelines, key counts, curve kinds. All true, and all silent
   about a 236.5-unit move.
 - **`check` sees it loudly**, with the framing pinned so the comparison is of pictures
@@ -1192,28 +1192,35 @@ slots to `arm-art`/`block-art` and their attachments to match:
       1.000  bone_binding_shape           2/2         as many slots hang off a bone of each shape (`?` = no such bone is declared)
       1.000  order_shape                  2/2         the draw order is the same order of `<attachment type>@<bone shape>`
 
-  attachments           mean 0.889  over 9 measures
+  attachments           mean 0.818  over 11 measures
       1.000  skins                        1/1         the skin names
       1.000  count                        2/2         how many attachments
       0.000  names                        0/4         skin/slot/attachment keys
       1.000  type_counts                  2/2         as many of each attachment type
       …
-  animations            mean 1.000  over 9 measures
+      0.000  refs                         0/2         each attachment resolves the same region, clipping end and linked-mesh source  — 2 on one side only, which `attachments.names` names
+      1.000  skin_members                 1/1         each skin activates the same skin-required bones and constraints
+  …
+  animations            mean 0.909  over 11 measures
+      …
+      0.000  targets                      0/8         each timeline keys the same bone, slot, constraint or attachment  — …
 ```
 
 Three things to read out of that, in order:
 
 - **The name-keyed collapse is the task, not a defect.** `bones` 0.567, `slots` 0.143,
-  `attachments` 0.889. Note that several *non*-name measures fall with them —
+  `attachments` 0.818, `animations` 0.909. Note that several *non*-name measures fall with them —
   `slots.bone`, `slots.blend`, `bones.parent_by_name` — because they are keyed **by**
   the name that changed. They are not saying the binding changed.
 - 🚨 **`bones (name-agnostic)` and `slots (name-agnostic)` must stay 1.000.** They
   measure the rig with the vocabulary thrown away, so a rename that changed only names
   leaves them untouched. **A drop there is a structural mistake wearing a rename's
   clothes**, and it is the only assertion this recipe really has.
-- **`animations` stays 1.000** because animation *names* were not part of the ask.
-  Under the same edit `bones.names` reads `1/5` — `root` survived, and the total is the
-  union of both vocabularies.
+- **`animations` moves on one measure only, `targets`**, because animation *names*
+  were not part of the ask but every timeline keys a renamed bone — `targets` is keyed
+  by the name that changed, as `slots.bone` is. Every other `animations` measure stays
+  1.000. Under the same edit `bones.names` reads `1/5` — `root` survived, and the total
+  is the union of both vocabularies.
 
 ⛔ And remember §1.3: `diff` reads no coordinates either way. A rename that also moved
 something is invisible to every measure in that report. Pair it with a `check` against
@@ -1255,7 +1262,7 @@ that already round-trips.
 4. **Read `diff` knowing what it is about to say.**
 
    ```
-     animations            mean 0.793  over 9 measures
+     animations            mean 0.821  over 11 measures
          0.667  count                        2/3         how many animations
          0.667  names                        2/3         the animation names
          0.667  duration                     2/3         each animation runs as long (last key time, within one frame)
@@ -1265,10 +1272,12 @@ that already round-trips.
          1.000  event_keys                   0/0         as many event firings  — neither side has any
          0.667  draw_order                   2/3         a draw-order timeline is present or absent alike
          0.667  deform                       2/3         a deform timeline is present or absent alike
+         0.889  targets                      8/9         each timeline keys the same bone, slot, constraint or attachment  — …
+         1.000  keyed_names                  0/0         each key names the same attachment, draw-order slot or event  — neither side has any
    ```
 
    🚨 **Every one of those got worse, and that is the correct result.** The
-   `animations` section went 1.000 → 0.793 because the candidate now has something the
+   `animations` section went 1.000 → 0.821 because the candidate now has something the
    reference does not. `diff` measures agreement with a reference; you were asked to
    *disagree* with it, in one specific way. ⇒ **Check that the drop is confined to the
    `animations` section and is the size the addition explains** — one animation of

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "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/compile.ts

@@ -7482,7 +7482,10 @@ function buildMesh(
   );
 
   return {
-    kind: geometry.kind,
+    // `kind` is what chose the builder above, so it is the claim; `geometry.kind`
+    // is the wider `MeshKind`, which a strict tsc refuses here (and a dependant
+    // with `strict: true` reads this file through `src/render.ts`).
+    kind,
     attachment: {
       kind: 'mesh',
       uvs: geometry.uvs.map(f32),

package/src/diff.ts

@@ -689,6 +689,43 @@ interface AttachmentFact {
    * — see `attachments.runtime_name`.
    */
   runtimeName: string;
+  /**
+   * Every name the attachment resolves, as `<field>:<name>` and sorted — see
+   * `attachmentRefTokens` for which fields and why.
+   */
+  refs: string;
+  /** The same tokens as a list, for the note that spells a disagreement out. */
+  refList: string[];
+}
+
+/**
+ * The names an attachment resolves (issue #1085): the atlas region a region or
+ * a mesh draws, a clipping polygon's end slot, and the mesh a linked mesh takes
+ * its geometry from — with the skin and slot it is found under, where stated.
+ *
+ * ⭐ The region is read as the runtime resolves it, `path`, else the stated
+ * `name`, else the placeholder (SPEC_COVERAGE §1.5's three-level indirection),
+ * for the reason `runtime_name` reads its name that way: a file that spells the
+ * path out and one that leaves it to the parser name the same region, and a
+ * measure that called those different would score every export against every
+ * writer that states its paths. Every other field is a token only when the file
+ * states it — absent is no token, never a default, as in `constraints.refs`.
+ *
+ * Measured on public builds through spine-core: a region's `path` moved to the
+ * other eye of `spineboy-pro` changes 94 of its 99 sampled draws, its clipping
+ * polygon's `end` moved six slots on changes the clipping of 9, and a linked
+ * mesh on `gallery/nod` taking `ear_r` instead of `ear_l` as its source changes
+ * all 18 of its sampled poses. `diff` compared none of the three, and two of them occur in
+ * none of the twelve editor exports (a stated `path` and a linked mesh).
+ */
+function attachmentRefTokens(type: string, key: string, att: Json): string[] {
+  const out: string[] = [];
+  if (type === 'region' || type === 'mesh' || type === 'linkedmesh') out.push(`path:${str(att.path) ?? str(att.name) ?? key}`);
+  for (const field of ['end', 'source', 'skin', 'slot'] as const) {
+    const s = str(att[field]);
+    if (s !== null) out.push(`${field}:${s}`);
+  }
+  return out.sort();
 }
 
 function attachmentFacts(root: Json): { skins: Set<string>; byKey: Map<string, AttachmentFact> } {
@@ -725,6 +762,8 @@ function attachmentFacts(root: Json): { skins: Set<string>; byKey: Map<string, A
           edgesPresent: type === 'mesh' ? 'edges' in att : null,
           size: num(att.width) !== null && num(att.height) !== null ? `${num(att.width)}x${num(att.height)}` : 'unstated',
           runtimeName: str(att.name) ?? attName,
+          refs: attachmentRefTokens(type, attName, att).join(' '),
+          refList: attachmentRefTokens(type, attName, att),
         });
       }
     }
@@ -795,6 +834,22 @@ function diffAttachments(c: Json, r: Json): DiffSection {
       counted([...ar.values()].map((f) => f.size)),
       counted([...br.values()].map((f) => f.size)),
     ),
+    wiringAgreement(
+      'attachments.refs',
+      'each attachment resolves the same region, clipping end and linked-mesh source',
+      a.byKey,
+      b.byKey,
+      (key) => `attachment ${JSON.stringify(key)}`,
+      '`attachments.names`',
+    ),
+    wiringAgreement(
+      'attachments.skin_members',
+      'each skin activates the same skin-required bones and constraints',
+      skinMembers(c),
+      skinMembers(r),
+      (skin) => `skin ${JSON.stringify(skin)}`,
+      '`attachments.skins`',
+    ),
   ],
   undefined,
   // ── reported (issue #46) ────────────────────────────────────────────────
@@ -853,6 +908,67 @@ function diffAttachments(c: Json, r: Json): DiffSection {
   ]);
 }
 
+/**
+ * What each skin activates (issue #1085): the `bones` and the per-kind
+ * constraint lists a skin declares, as `<list>:<name>` tokens, sorted — a skin's
+ * MEMBERSHIP, which is what decides whether a bone or constraint marked
+ * `skin: true` is active under it.
+ *
+ * Measured on public builds through spine-core: a `gallery/look` bone made
+ * skin-required and left out of the skin's `bones` moves every one of its 27
+ * sampled poses, and `gallery/walk`'s `leg_b_ik` left out of the skin's `ik`
+ * moves all 9. None of the twelve editor exports declares a membership list, so
+ * every one of them reads `1/1` per skin here — two empty lists agree — which is
+ * the comparison being made rather than an absence of one.
+ */
+function skinMembers(root: Json): Map<string, { refs: string; refList: string[] }> {
+  const out = new Map<string, { refs: string; refList: string[] }>();
+  for (const skin of objs(root.skins)) {
+    const name = str(skin.name) ?? 'default';
+    const refList: string[] = [];
+    for (const list of ['bones', 'ik', 'transform', 'path', 'physics', 'slider'] as const) {
+      for (const member of arr(skin[list])) {
+        const s = str(member);
+        if (s !== null) refList.push(`${list}:${s}`);
+      }
+    }
+    refList.sort();
+    out.set(name, { refs: refList.join(' '), refList });
+  }
+  return out;
+}
+
+/**
+ * `agreement` over the larger roster on a `refs` string, with the note
+ * `constraints.refs` writes: each entry both sides hold whose names differ,
+ * field by field and candidate first, then a count of the entries one side holds
+ * alone, which `elsewhere` is the measure that names.
+ */
+function wiringAgreement<T extends { refs: string; refList: string[] }>(
+  id: string,
+  what: string,
+  a: Map<string, T>,
+  b: Map<string, T>,
+  label: (key: string) => string,
+  elsewhere: string,
+): DiffMeasure {
+  const base = agreement(id, what, a, b, (x, y) => x.refs === y.refs);
+  const missed = base.total - base.matched;
+  if (missed === 0) return base;
+  const differ: string[] = [];
+  for (const [key, fact] of a) {
+    const other = b.get(key);
+    if (other !== undefined && other.refs !== fact.refs) differ.push(refsDisagreement(label(key), fact, other));
+  }
+  const oneSided = missed - differ.length;
+  const spelled = differ.slice(0, REFS_SPELLED_OUT);
+  const note =
+    (differ.length === 0 ? '' : `${differ.length} differ: ${spelled.join('; ')}`) +
+    (differ.length > spelled.length ? `; …and ${differ.length - spelled.length} more` : '') +
+    (oneSided === 0 ? '' : `${differ.length === 0 ? '' : '; '}${oneSided} on one side only, which ${elsewhere} names`);
+  return { ...base, note };
+}
+
 /**
  * `attachments.runtime_name`: of the skin/slot/placeholder keys both sides
  * hold, how many answer to the same runtime name — see the note at its call.
@@ -921,7 +1037,8 @@ interface ConstraintFact {
  * property fields were blinder still: measured on `gallery/look` and `6-arcs-pro`,
  * a slider moved from `rotate` to `x` and a transform remapped from `x>x` to
  * `x>y` moved no measure here and no value in the value walk either (its skip
- * list names `properties`), so nothing in the tree compared them at all.
+ * list named `properties`), so nothing in the tree compared them at all. Since
+ * issue #1084 the walk reads both, by class (`property/kind`, `properties/FromX/to/ToY`).
  *
  * ⚠️ Absent is no token, never a default: a transform with no `properties` maps
  * nothing, and two sides that both omit a field agree about it. And the tokens
@@ -967,8 +1084,8 @@ const REFS_SPELLED_OUT = 3;
  * "5" vs "-a"` — the candidate's names for each field that differs, then the
  * reference's, `none` where a side has none.
  */
-function refsDisagreement(at: string, a: ConstraintFact, b: ConstraintFact): string {
-  const byField = (f: ConstraintFact): Map<string, string[]> => {
+function refsDisagreement(at: string, a: { refList: string[] }, b: { refList: string[] }): string {
+  const byField = (f: { refList: string[] }): Map<string, string[]> => {
     const m = new Map<string, string[]>();
     for (const token of f.refList) {
       const colon = token.indexOf(':');
@@ -1024,9 +1141,43 @@ function constraintRefs(a: Map<string, ConstraintFact>, b: Map<string, Constrain
   return { ...base, note };
 }
 
+/**
+ * The constraints in the order the file declares them, by kind and name — the
+ * key `constraintFacts` uses, so that `leg` as an ik and as a transform are two
+ * entries here as well.
+ *
+ * 🔍 **Why the order is data** (issue #1085). 4.3 folds every constraint into one
+ * array and applies them in its order, so two files with the same constraints
+ * wired the same way can pose differently. Measured by reversing the array and
+ * posing both through spine-core: `spineboy-pro` moves 98 of its 99 sampled
+ * poses, `6-arcs-pro` 8 of 9 and `sack-pro` 8 of 36 (33 of 36 with physics
+ * stepped); swapping `aim-torso-ik` and `aim-torso-transform` alone moves the 9
+ * samples of `aim`. Before this nothing in the tree compared it — the value walk
+ * keys constraints by name, so it is blind to the order by construction.
+ *
+ * ⚠️ Not every swap poses differently, and the measure does not pretend to know
+ * which do: `gallery/look`'s two sliders and `gallery/walk`'s two legs drive
+ * disjoint bones and read the same pose either way. A reordering is reported as
+ * what the file states, the way `bones.order` reports one.
+ */
+function constraintOrder(root: Json): string[] {
+  const out: string[] = [];
+  for (const con of objs(root.constraints)) {
+    const name = str(con.name);
+    if (name !== null) out.push(constraintAt(str(con.type) ?? '(none)', name));
+  }
+  return out;
+}
+
 function diffConstraints(c: Json, r: Json): DiffSection {
   const a = constraintFacts(c);
   const b = constraintFacts(r);
+  const ao = constraintOrder(c);
+  const bo = constraintOrder(r);
+  const shared = ao.filter((n) => b.has(n));
+  const sharedOther = bo.filter((n) => a.has(n));
+  const inOrder = lcs(shared, sharedOther);
+  const max = Math.max(a.size, b.size);
   return sectionOf('constraints', [
     measure('constraints.count', 'how many constraints', Math.min(a.size, b.size), Math.max(a.size, b.size)),
     jaccard('constraints.names', 'the constraint names', new Set(a.keys()), new Set(b.keys())),
@@ -1038,9 +1189,32 @@ function diffConstraints(c: Json, r: Json): DiffSection {
     ),
     agreement('constraints.type_by_name', 'each constraint is the same type', a, b, (x, y) => x.type === y.type),
     constraintRefs(a, b),
+    measure(
+      'constraints.order',
+      'the constraints are declared, and so applied, in the same order',
+      inOrder,
+      max,
+      [
+        ...(inOrder === shared.length ? [] : [outOfOrder(shared, sharedOther)]),
+        ...(shared.length === max ? [] : [`${max - shared.length} of the larger roster not on both sides, which \`constraints.names\` names`]),
+      ].join('; ') || undefined,
+    ),
   ]);
 }
 
+/**
+ * `constraints.order`'s note when the shared constraints are not in one order:
+ * both sides' order of them, candidate first, spelled out to a limit.
+ */
+function outOfOrder(a: string[], b: string[]): string {
+  const spell = (list: string[]): string =>
+    list.slice(0, ORDER_SPELLED_OUT).join(', ') + (list.length > ORDER_SPELLED_OUT ? `, …and ${list.length - ORDER_SPELLED_OUT} more` : '');
+  return `${a.length - lcs(a, b)} out of order: candidate ${spell(a)}; reference ${spell(b)}`;
+}
+
+/** How many constraints `constraints.order`'s note lists per side before it counts the rest. */
+const ORDER_SPELLED_OUT = 6;
+
 interface AnimationFacts {
   names: string[];
   /** `<anim>` -> last key time. Skeleton JSON has no duration field. */
@@ -1098,6 +1272,136 @@ function animationFacts(root: Json): AnimationFacts {
   return facts;
 }
 
+/**
+ * The names the animations resolve, as two multisets of tokens (issue #1085).
+ *
+ * `animationFacts` keeps each timeline's kind and drops its target on purpose —
+ * a candidate's own vocabulary would otherwise be counted against it a second
+ * time inside `timeline_kinds` (#21) — and reads no key's contents beyond its
+ * time and curve. So until this, a bone timeline moved onto another bone, an
+ * attachment key naming another attachment, a draw-order key naming another slot
+ * and an event key firing another event each moved no measure in this file, and
+ * every one of them poses or draws differently: measured on public builds
+ * through spine-core, a retargeted bone timeline moves 7 of `gallery/look`'s 27
+ * sampled poses, two slots' attachment keys swapped move 9 of `spineboy-pro`'s
+ * 99, a draw-order offset moved to the next slot moves 9 of `spineboy-ess`'s 72
+ * and an event key renamed to a second event moves the event block of one sample.
+ *
+ * - `targets`: one token per timeline, `<animation>|<group>|<target>` — the
+ *   bone, slot or constraint it keys, a deform's or sequence's
+ *   `skin/slot/attachment`, and each slot a draw-order folder holds. The
+ *   timeline's own kind is left out on purpose: it is `timeline_kinds`'
+ *   subject, and a rotate keyed as a scale on the same bone moves that measure
+ *   and must not move this one too.
+ * - `keyed`: one token per name a KEY carries, with its position in the
+ *   timeline — an attachment key's attachment (`(none)` for a key that clears
+ *   the slot), each draw-order offset's slot, an event key's event.
+ *
+ * Both are names, so both are name-matched, and a candidate with its own names
+ * reads low here exactly as it does on `names` — the name-agnostic block is
+ * where that rig is read. ⚠️ No key VALUE is read: a key's time, an offset's
+ * distance and an event's payload are the value walk's.
+ */
+interface AnimationRefs {
+  targets: Map<string, number>;
+  keyed: Map<string, number>;
+}
+
+/** The physics group's empty name, which applies a timeline to every physics constraint. */
+const EVERY_PHYSICS_CONSTRAINT = '(every physics constraint)';
+
+function animationRefs(root: Json): AnimationRefs {
+  const targets = new Map<string, number>();
+  const keyed = new Map<string, number>();
+  const bump = (m: Map<string, number>, k: string): void => {
+    m.set(k, (m.get(k) ?? 0) + 1);
+  };
+  if (!isObj(root.animations)) return { targets, keyed };
+  for (const [anim, body] of Object.entries(root.animations)) {
+    if (!isObj(body)) continue;
+    for (const group of ['bones', 'slots', 'path', 'physics', 'slider'] as const) {
+      const held = body[group];
+      if (!isObj(held)) continue;
+      for (const [target, timelines] of Object.entries(held)) {
+        if (!isObj(timelines)) continue;
+        const named = group === 'physics' && target === '' ? EVERY_PHYSICS_CONSTRAINT : target;
+        for (const [timeline, keys] of Object.entries(timelines)) {
+          if (!Array.isArray(keys)) continue;
+          bump(targets, `${anim}|${group}|${named}`);
+          if (group === 'slots' && timeline === 'attachment') {
+            keys.forEach((key, i) => {
+              if (isObj(key)) bump(keyed, `${anim}|attachment key ${i}|${target}: ${str(key.name) ?? '(none)'}`);
+            });
+          }
+        }
+      }
+    }
+    for (const group of ['ik', 'transform'] as const) {
+      const held = body[group];
+      if (!isObj(held)) continue;
+      for (const [target, keys] of Object.entries(held)) if (Array.isArray(keys)) bump(targets, `${anim}|${group}|${target}`);
+    }
+    if (isObj(body.attachments)) {
+      for (const [skin, bySlot] of Object.entries(body.attachments)) {
+        if (!isObj(bySlot)) continue;
+        for (const [slot, byAttachment] of Object.entries(bySlot)) {
+          if (!isObj(byAttachment)) continue;
+          for (const [attachment, timelines] of Object.entries(byAttachment)) {
+            if (!isObj(timelines)) continue;
+            for (const keys of Object.values(timelines)) {
+              if (Array.isArray(keys)) bump(targets, `${anim}|attachments|${skin}/${slot}/${attachment}`);
+            }
+          }
+        }
+      }
+    }
+    const offsets = (label: string, keys: unknown): void => {
+      arr(keys).forEach((key, i) => {
+        if (!isObj(key)) return;
+        for (const offset of objs(key.offsets)) bump(keyed, `${anim}|${label} key ${i}|${str(offset.slot) ?? '(none)'}`);
+      });
+    };
+    offsets('drawOrder', body.drawOrder);
+    objs(body.drawOrderFolder).forEach((folder, f) => {
+      for (const slot of arr(folder.slots)) bump(targets, `${anim}|drawOrderFolder ${f}|${str(slot) ?? '(none)'}`);
+      offsets(`drawOrderFolder ${f}`, folder.keys);
+    });
+    arr(body.events).forEach((key, i) => {
+      if (isObj(key)) bump(keyed, `${anim}|event key ${i}|${str(key.name) ?? '(none)'}`);
+    });
+  }
+  return { targets, keyed };
+}
+
+/** How many tokens a names histogram's note spells out per side before it counts the rest. */
+const TOKENS_SPELLED_OUT = 3;
+
+/**
+ * `histogram`, with a note naming what each side holds that the other does not —
+ * the figure alone says some name moved, and a reader acting on it needs which.
+ */
+function namesHistogram(id: string, what: string, a: Map<string, number>, b: Map<string, number>): DiffMeasure {
+  const base = histogram(id, what, a, b);
+  if (base.matched === base.total) return base;
+  // A token one side holds more often than the other, with how many more — a
+  // bone keyed by three timelines on one side and one on the other is `×2`.
+  const only = (x: Map<string, number>, y: Map<string, number>): string[] => {
+    const out: string[] = [];
+    for (const [k, v] of x) {
+      const extra = v - (y.get(k) ?? 0);
+      if (extra > 0) out.push(`${JSON.stringify(k)}${extra > 1 ? ` ×${extra}` : ''}`);
+    }
+    return out;
+  };
+  const spell = (side: string, list: string[]): string =>
+    list.length === 0
+      ? ''
+      : `${side} only: ${list.slice(0, TOKENS_SPELLED_OUT).join(', ')}` +
+        (list.length > TOKENS_SPELLED_OUT ? `, …and ${list.length - TOKENS_SPELLED_OUT} more` : '');
+  const parts = [spell('candidate', only(a, b)), spell('reference', only(b, a))].filter((p) => p !== '');
+  return { ...base, note: `${base.total - base.matched} differ — ${parts.join('; ')}` };
+}
+
 /**
  * What a side's keying costs, in the two shapes that separate the two ways a
  * key total can differ: more timelines, or more keys inside a timeline.
@@ -1266,6 +1570,8 @@ function diffAnimations(c: Json, r: Json, pairsStated: readonly DiffAnimationPai
   const at = keyingTotals(a);
   const bt = keyingTotals(b);
   const paired = pairAnimations(a, b, pairsStated);
+  const refsA = animationRefs(c);
+  const refsB = animationRefs(r);
   const perSecond = (t: KeyingTotals): number => (t.seconds === 0 ? 0 : t.keys / t.seconds);
   const perTimeline = (t: KeyingTotals): number => (t.timelines === 0 ? 0 : t.keys / t.timelines);
   return sectionOf('animations', [
@@ -1284,6 +1590,18 @@ function diffAnimations(c: Json, r: Json, pairsStated: readonly DiffAnimationPai
     histogram('animations.event_keys', 'as many event firings', a.events, b.events),
     agreement('animations.draw_order', 'a draw-order timeline is present or absent alike', a.hasDrawOrder, b.hasDrawOrder, (x, y) => x === y),
     agreement('animations.deform', 'a deform timeline is present or absent alike', a.hasDeform, b.hasDeform, (x, y) => x === y),
+    namesHistogram(
+      'animations.targets',
+      'each timeline keys the same bone, slot, constraint or attachment',
+      refsA.targets,
+      refsB.targets,
+    ),
+    namesHistogram(
+      'animations.keyed_names',
+      'each key names the same attachment, draw-order slot or event',
+      refsA.keyed,
+      refsB.keyed,
+    ),
   ],
   // ── the same two skeletons' shots, paired rather than named (issue #720) ──
   //
@@ -1628,7 +1946,7 @@ export const VALUE_PARSED_ULP = 2 ** -23;
  * Both terms are derived rather than fitted: the first is rigc's models' grid,
  * the second is the parser's storage. Measured over the twelve editor exports
  * in `examples/`, the widest gap between a rebuild and the file it was read
- * from is **0** — none of 188,339 numeric values differs at all, since issue
+ * from is **0** — none of 189,699 numeric values differs at all, since issue
  * #716 made every emitted number its float's own name (it was 0.81 of this
  * bound, over 56,951 values that differed, while rigc emitted six decimals) —
  * so the corpus sits inside a bound that was not drawn around it, and no
@@ -1657,7 +1975,11 @@ const VALUE_MEASURES: ReadonlyArray<{ id: string; what: string; prefix: string }
   { id: 'values.bones', what: 'every bone setup pose, its length and its colour', prefix: 'bones/' },
   { id: 'values.slots', what: 'every slot colour, dark colour, blend mode and setup attachment', prefix: 'slots/' },
   { id: 'values.attachments', what: 'every attachment offset, size, vertex, weight, uv and triangle', prefix: 'skins/' },
-  { id: 'values.constraints', what: 'every constraint pose field and flag', prefix: 'constraints/' },
+  {
+    id: 'values.constraints',
+    what: 'every constraint field the parser reads: pose, flags, offsets, and the property map and its kinds',
+    prefix: 'constraints/',
+  },
   { id: 'values.events', what: 'every event payload in the setup pose', prefix: 'events/' },
   { id: 'values.key_times', what: 'every key time, and each animation\'s duration', prefix: 'animations/' },
   { id: 'values.key_values', what: 'every keyed value: poses, deform vertices, draw orders, event payloads', prefix: 'animations/' },

package/src/validate.ts

@@ -3466,10 +3466,70 @@ const NOT_A_VALUE_IN_THE_FILE: Record<string, string> = {
   index: 'the array position this walk already iterates by name',
   timelineIds: 'derived from the timelines',
   timelineSlots: 'derived from the skin',
-  properties: 'derived from the constraint',
   propertyIds: 'carries an attachment id, which is a counter (see above)',
 };
 
+/**
+ * The keys above that ARE a value the file carries on these owners, by the
+ * owner's class name (issue #1084).
+ *
+ * The skip list is keyed by field name alone, and four of its names are also
+ * the name of a field the parser reads off the file on a different class. Each
+ * owner below was found by walking the parsed form of the twelve editor exports
+ * and the seven gallery builds for every class carrying a key the list names,
+ * and each field was planted and posed before it was let back in:
+ *
+ * - `a`, `b` — a `Color`'s alpha and blue channels, which share their names with
+ *   two entries of a bone's world matrix. Every slot colour, dark colour, bone
+ *   colour and attachment colour lost half its channels to that: a slot's alpha
+ *   `ff` → `80` moved no value at all, and posed, it changes every slot row.
+ * - `local` — a slider's `local` flag, which shares its name with a bone pose's
+ *   derived `local`. Flipped on `gallery/look`'s `yaw`, it moves the posed bones.
+ * - `offsets` — a transform constraint's six offsets (`rotation`, `x`, `y`,
+ *   `scaleX`, `scaleY`, `shearY` in the file), which share their name with a
+ *   sequence's region offsets. A `y` offset moved on `6-arcs-pro`'s `tail`
+ *   moved no value and moves the posed bones.
+ *
+ * A fifth entry, `properties` (*derived from the constraint*), is gone rather
+ * than excepted: the one class measured carrying it is the transform constraint,
+ * where it is the file's from/to map, so the reason was not true of anything.
+ *
+ * ⚠️ An exception rather than a rewrite of the list: the list's design — a
+ * field the parser starts reading is compared the day it starts — is right,
+ * and what was wrong was that a name stood for every class carrying it.
+ */
+const VALUE_ON_THESE_OWNERS: Record<string, readonly string[]> = {
+  a: ['Color'],
+  b: ['Color'],
+  local: ['SliderData'],
+  offsets: ['TransformConstraintData'],
+};
+
+/** Whether the walk leaves `key` out on an object of class `owner`. */
+function notAValue(owner: string, key: string): boolean {
+  return key in NOT_A_VALUE_IN_THE_FILE && !(VALUE_ON_THESE_OWNERS[key] ?? []).includes(owner);
+}
+
+/**
+ * The class an object was parsed into when that class is one of several sharing
+ * a shape — it extends another class — or `null`.
+ *
+ * Reflection reads fields, and two classes with the same fields are the same
+ * object to it: a slider reading `rotate` holds a `FromRotate` and one reading
+ * `x` a `FromX`, both `{ offset, to }`, so moving a slider to another property
+ * moved no value (issue #1084). Measured over the parsed corpus, the only
+ * unnamed objects the walk expands whose class extends another are the
+ * transform and slider property classes (`From*`, `To*`); a pose, a colour and a
+ * sequence are classes of their own, so this adds nothing under them.
+ */
+function sharedShapeKind(obj: object): string | null {
+  const proto = Object.getPrototypeOf(obj) as object | null;
+  if (proto === null || proto === Object.prototype) return null;
+  const parent = Object.getPrototypeOf(proto) as object | null;
+  if (parent === null || parent === Object.prototype) return null;
+  return (obj.constructor as { name?: string } | undefined)?.name ?? null;
+}
+
 /** How deep a chain of unnamed objects may go before the walk says so and stops. */
 const VALUE_WALK_DEPTH = 10;
 
@@ -3501,7 +3561,24 @@ function pushValue(value: unknown, path: string, out: SkeletonValue[], depth: nu
   if (typeof value === 'function') return;
   if (ArrayBuffer.isView(value) || Array.isArray(value)) {
     const list = value as ArrayLike<unknown>;
-    for (let i = 0; i < list.length; i++) pushValue(list[i], `${path}/${i}`, out, depth + 1);
+    // A list whose every entry is an unnamed object of its own shared-shape
+    // class — a transform's `properties` and each one's `to` — is keyed by those
+    // classes rather than by position: the file writes them as an object keyed
+    // by property name, any writer may key it in its own order, and the
+    // parser's list follows that order. By position, the same map written
+    // backwards would read as every property moved (issue #1084).
+    const kinds: string[] = [];
+    for (let i = 0; i < list.length; i++) {
+      const entry = list[i];
+      const kind =
+        typeof entry === 'object' && entry !== null && typeof (entry as Record<string, unknown>).name !== 'string'
+          ? sharedShapeKind(entry)
+          : null;
+      if (kind === null || kinds.includes(kind)) break;
+      kinds.push(kind);
+    }
+    const byKind = list.length > 0 && kinds.length === list.length;
+    for (let i = 0; i < list.length; i++) pushValue(list[i], `${path}/${byKind ? kinds[i] : i}`, out, depth + 1);
     return;
   }
   if (typeof value !== 'object') return;
@@ -3514,8 +3591,12 @@ function pushValue(value: unknown, path: string, out: SkeletonValue[], depth: nu
     out.push({ path, value: '(deeper than the walk goes)' });
     return;
   }
+  const owner = (obj.constructor as { name?: string } | undefined)?.name ?? '';
+  // The class, where it is the one thing the fields cannot say — see `sharedShapeKind`.
+  const kind = depth > 0 ? sharedShapeKind(obj) : null;
+  if (kind !== null) out.push({ path: `${path}/kind`, value: kind });
   for (const key of Object.keys(obj).sort()) {
-    if (key in NOT_A_VALUE_IN_THE_FILE) continue;
+    if (notAValue(owner, key)) continue;
     pushValue(obj[key], `${path}/${key}`, out, depth + 1);
   }
 }
@@ -3570,7 +3651,9 @@ function timelineKey(timeline: Timeline, data: ReturnType<SkeletonJson['readSkel
  * and setup attachment, every attachment in every skin (a region's offsets,
  * rotation, scale and size; a mesh's vertices, weights, `regionUVs`,
  * triangles, hull and edges; a bounding box's, path's and clipping shape's
- * vertices), every constraint's pose and flags, every event's payload, and for
+ * vertices), every constraint's pose, flags and modes — a transform's offsets
+ * and its property map, each entry by its class, and a slider's property by its
+ * class (issue #1084) — every event's payload, and for
  * every timeline every frame — time and values, from the runtime's own
  * `getFrameEntries()` — its curve type and Bezier samples, and its deform
  * vertices, attachment names, draw orders and event payloads.
@@ -3605,7 +3688,7 @@ export function skeletonValues(skeletonText: string, atlasText: string): Skeleto
     const at = `bones/${bone.name}`;
     const rec = bone as unknown as Record<string, unknown>;
     for (const key of Object.keys(rec).sort()) {
-      if (key in NOT_A_VALUE_IN_THE_FILE || key === 'name') continue;
+      if (notAValue('BoneData', key) || key === 'name') continue;
       pushValue(rec[key], `${at}/${key === 'setupPose' ? 'setup' : key}`, out, 1);
     }
   }
@@ -3613,7 +3696,7 @@ export function skeletonValues(skeletonText: string, atlasText: string): Skeleto
     const at = `slots/${slot.name}`;
     const rec = slot as unknown as Record<string, unknown>;
     for (const key of Object.keys(rec).sort()) {
-      if (key in NOT_A_VALUE_IN_THE_FILE || key === 'name') continue;
+      if (notAValue('SlotData', key) || key === 'name') continue;
       pushValue(rec[key], `${at}/${key === 'setupPose' ? 'setup' : key}`, out, 1);
     }
   }
@@ -3681,7 +3764,7 @@ export function skeletonValues(skeletonText: string, atlasText: string): Skeleto
         }
         const rec = timeline as unknown as Record<string, unknown>;
         for (const field of Object.keys(rec).sort()) {
-          if (field in NOT_A_VALUE_IN_THE_FILE || field === 'frames') continue;
+          if (notAValue(timeline.constructor?.name ?? '', field) || field === 'frames') continue;
           // The owner is in the path already; comparing the index as well would
           // report one reordering twice, in a measure that is not about order.
           if (field === 'boneIndex' || field === 'slotIndex' || field === 'constraintIndex') continue;

package/tools/editor_roundtrip.ts

@@ -308,6 +308,61 @@ interface Ran {
   timedOut: boolean;
 }
 
+/**
+ * The indices of the lines in one stream of editor output that carry the
+ * licence holder, and nothing else (issue #1082).
+ *
+ * Measured on a licensed 4.3 editor on macOS 2026-10-02, through this tool, on
+ * four failing calls. Every one exited 1, wrote everything to stdout and nothing
+ * to stderr, and printed one of two shapes:
+ *
+ *   an input path that does not exist (import, and export) — refused by the
+ *   LAUNCHER before the editor starts, and no licence line at all:
+ *
+ *     the launcher's banner, the copyright line, the operating system
+ *     (blank)  `Parameter: --input <path>`  (blank)
+ *     `ERROR: Input path does not exist:`
+ *     the path
+ *
+ *   a file the editor cannot read (a skeleton JSON naming a parent bone it does
+ *   not declare; a `.spine` that is not a project) — the editor starts, names
+ *   itself and its licence holder, and then the failure:
+ *
+ *     the launcher's banner, the copyright line, the operating system
+ *     `Starting: Spine <x.y.z> Professional`
+ *     `Spine <x.y.z> Professional`
+ *     `Licensed to: <name> <<e-mail>>`         <- ONE line, withheld
+ *     import: `Project import: …`, `ERROR: Unable to import skeleton.`, then
+ *     export: `ERROR: Unable to export.`, then
+ *     `[error] …` lines, a stack, and `Cause: …` lines
+ *
+ * 🚨 So on a failure the block is one line, not the three `--version` prints
+ * (`Licensed to:` alone, then the name, then the e-mail — issue #1077), and
+ * the lines straight after it are the editor's own error: a rule that took
+ * "the header and the two lines after it" would have quoted the licence holder
+ * not at all and the reason for the failure not at all either.
+ *
+ * ⚠️ Both shapes are held, each by what bounds it. A header with a value on the
+ * same line is that one line. A bare header takes the two lines after it only
+ * when the second of them is an e-mail (`@`), which is the `--version` shape;
+ * anything else after a bare header is the editor talking and is quoted.
+ */
+function licenceLines(lines: readonly string[]): Set<number> {
+  const withheld = new Set<number>();
+  for (let i = 0; i < lines.length; i++) {
+    const header = /^[ \t]*Licensed to:(.*)$/.exec(lines[i]);
+    if (header === null) continue;
+    withheld.add(i);
+    if (header[1].trim() !== '') continue;
+    if (i + 2 < lines.length && lines[i + 2].includes('@')) {
+      withheld.add(i + 1);
+      withheld.add(i + 2);
+      i += 2;
+    }
+  }
+  return withheld;
+}
+
 /**
  * Everything the editor printed on a step that did not do what it was for.
  *
@@ -336,6 +391,11 @@ interface Ran {
  * softening the verdict. What it prints is the editor's own words, quoted and
  * attributed to the stream they came off, and never rewritten — a harness that
  * summarised them would be the same defect with a smaller radius.
+ *
+ * 🚨 With one exception, which is not the editor's words but the licence
+ * holder's (issue #1082): the licence line, which `licenceLines` names and
+ * which is replaced by one line saying it was withheld. Every other line is
+ * quoted as printed, in order.
  */
 function editorSaid(ran: Ran): string[] {
   const lines: string[] = [];
@@ -346,7 +406,21 @@ function editorSaid(ran: Ran): string[] {
     const body = text.replace(/\s+$/, '');
     if (body === '') continue;
     lines.push(`  the editor's ${stream}:`);
-    for (const line of body.split('\n')) lines.push(`    | ${line}`);
+    const printed = body.split('\n');
+    const withheld = licenceLines(printed);
+    for (let i = 0; i < printed.length; i++) {
+      if (!withheld.has(i)) {
+        lines.push(`    | ${printed[i]}`);
+        continue;
+      }
+      // One note per run of withheld lines, in the place they were printed, so
+      // the quotation still reads in the editor's order and the omission is
+      // stated rather than left to look like an editor that said less.
+      let span = 1;
+      while (withheld.has(i + span)) span++;
+      lines.push(`    ~ ${span} line(s) withheld here: the editor's licence block names the licence holder (issue #1082)`);
+      i += span - 1;
+    }
   }
   // Silence is a finding too, and it has to be stated rather than left to look
   // like a harness that forgot to print. The card above is what an unstated one