spine-parts 0.8.0 → 0.8.2

package/README.md

@@ -86,7 +86,7 @@ page** (issue #2):
 
 | path under `--out` | what |
 | --- | --- |
-| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack --page-edges free --pack-shape polygon` and gated under `spine-html`, which holds every rule `spine` measures (on the demo, rigc 2.1.3: the 14 rules `validate --profile spine` measures are among the build's 24; 16 are not in `spine`) |
+| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack --page-edges free --pack-shape polygon` and gated under `spine-html`, which holds every rule `spine` measures (on the demo, rigc 2.1.3 and 2.10.1: the 14 rules `validate --profile spine` measures are among the build's 24; 16 are not in `spine`) |
 | `parts/*.png`, `parts.json`, `recomposite_rig.png`, `recomposite_error_rig.png` | the loose parts, each cropped to its alpha box; the record of where every part came from, how many of its pixels were re-taken from the painting, and the recomposite's uncovered holes with their boxes; the flat stack of parts; its error map — red where no part covers a pixel the painting has, blue where a part covers it in the wrong colour |
 | `rig/` | `rig.json` and `motion.json` in spine-rigc's spec, `mesh_report.json`, the padded `images/` |
 | `check/` | both gate files verbatim, the idle's frames and their `geometry.json` (skinned vertices per frame), `contact.png`, `motion_heat.png`, `check.json` (with `pack_mode`, the `--page-edges` and `--pack-shape` the page was packed under) |

package/cli.ts

@@ -108,7 +108,8 @@ usage:
       (RIG_BLINK_HOLD_SPANS_A_FRAME otherwise); no blink when the config
       states no motion.blink, and a blink group that names no bone, or one
       bone twice, is refused by the loader, CONFIG_BLINK_GROUP_MEMBERS or
-      CONFIG_BLINK_GROUP_UNIQUE, before rigc starts. --parts is the
+      CONFIG_BLINK_GROUP_UNIQUE, before rigc starts, as are two tracks on one
+      bone property, CONFIG_BONE_PROPERTY_KEYED_ONCE. --parts is the
       directory holding parts.json and parts/<name>.png. The result is built
       through spine-rigc (profile spine-html, packed with --page-edges and
       --pack-shape as for check; rigc's build gates the compile and the packed pages on disk) in a

package/docs/AUTHORING.md

@@ -75,7 +75,7 @@ read by no CPU stage).
 | `meshes.<part>` | rig | **proposed**, then corrected. `grid` (lattice cell size, px), `r` (added to every distance before weighting: `w = 1/(d + r)²`), `segments` (a chain name, a bone name with a `tip`, or `[bone, [x0,y0], [x1,y1]]`). The segment list is the one authored decision about a layer: which bones may pull it. The slot's bone is the first segment's |
 | `regions.<part>` | rig | **proposed**: the bone a rigid part rides. Every plan part is exactly one of a mesh or a region (`CONFIG_PART_ATTACHED`) |
 | `motion.duration` | rig; check (the loop is measured at this time) | proposed as 4 s; a whole number of 1/12 s ticks, because `check` renders at 12 fps |
-| `motion.tracks` | rig | **proposed**, then tuned. Single `{bone, prop, amp, period, phase, base?}` or chain `{chain, amps, period, phase, lag}` — one amplitude per link, link `i` at phase `phase + lag·i`. Every `period` must divide `duration` (`CONFIG_PERIOD_DIVIDES_DURATION`) |
+| `motion.tracks` | rig | **proposed**, then tuned. Single `{bone, prop, amp, period, phase, base?}` or chain `{chain, amps, period, phase, lag}` — one amplitude per link, link `i` at phase `phase + lag·i`. Every `period` must divide `duration` (`CONFIG_PERIOD_DIVIDES_DURATION`). A bone property is keyed by one track (`CONFIG_BONE_PROPERTY_KEYED_ONCE`): a chain keys `rotate` on every link, the blink's `eyes` group `scaley` and its `brows` group `translatey` on every member, so a single track on any of those is a second track on it — rigc would refuse it one stage later, `animation "idle" has two tracks on eye.scaley` |
 | `motion.blink` | rig | **proposed**: `{t, eyes, brows, squash, brow_drop}`; the whole blink, `t` to `t + 0.364` s (`t + 0.314` s without brows: the brows' keys are the ones that end last), must fit inside the idle (`RIG_BLINK_INSIDE_IDLE`). The `eyes` group's `scaley` squashes every part on the eye bones about the bone's origin, the eyewhite's centre. Optional: a figure with no `eyewhite-r`/`-l` part has no eye bone, so `propose` writes no `blink` and notes `no blink: no eyewhite part (looked for: eyewhite-r, eyewhite-l), …`; with eyes and no `eyebrow-r`/`-l` part it writes the blink without `brows` and `brow_drop` and notes `blink without brows: …`. `brows` and `brow_drop` are stated together or not at all (`CONFIG_BLINK_BROWS_PAIRED`), and a group that names no bone is refused (`CONFIG_BLINK_GROUP_MEMBERS`) — rigc would refuse it one stage later, `group "eyes" declares no members` — as is a group that names one bone twice (`CONFIG_BLINK_GROUP_UNIQUE`; rigc: `group "eyes" names member "eye" twice`). An `irides-*` or `eyelash-*` part on a side with no eyewhite has no eye bone to ride: `propose` places it on `head` as a region, which the blink does not move, and notes `no eyewhite part for eye_r (looked for: eyewhite-r): iris (head:irides-r) is placed on head as a region, …`. The timing is fixed, not a field (table below) |
 | `motion.blink.still` | rig | **proposed** only for a lash `propose` notes (below), then checked: `{<part>: {row, bone}}` — the rows of that region part above `row` (rig px, y down) are drawn by a second slot `<part>_still` on `bone` and do not blink; rows from `row` down keep the part's slot and blink. The part must be a region on a bone `eyes` names, `bone` one it does not (`CONFIG_STILL_OFF_THE_BLINK`), and `row` a row of the part with no art across its whole width (`RIG_STILL_ROW_CLEAR`) |
 
@@ -282,9 +282,10 @@ max for the APNG); a figure is a measurement of the file, not a bar. On the demo
 13,645,503 B lossless, 1,706,719 B indexed and 1,812,288 B GIF, both palette files at
 max 57, mean 1.601 — the two share one quantiser, so their error is the same by
 construction and the size is the difference. That is `--seam silhouette` (the README's
-animation, spine-rigc 2.1.3); with `--pack-shape rect` the same build writes 13,645,350,
-1,706,520 and 1,812,238 B, and with `--page-edges pot --pack-shape rect` 13,645,519,
-1,706,785 and 1,812,625 B, all at the same error. The loop shows the blink closed: the
+animation, spine-rigc 2.1.3, and 2.10.1 to the byte); with `--pack-shape rect` the same
+build writes 13,645,350, 1,706,520 and 1,812,238 B, and with `--page-edges pot
+--pack-shape rect` 13,645,519, 1,706,785 and 1,812,625 B, all at the same error (2.10.1
+reproduces both). The loop shows the blink closed: the
 eyes' hold is at least one 12 fps frame (below), so whatever `motion.blink.t` is, one
 idle frame lands inside it, and `check.json`'s `BLINK_NO_HOLE.idle_frames_closed`
 names it — `[29]` on both examples.
@@ -303,9 +304,10 @@ the least-area page the parts need. `--page-edges pot` is the opt-out: a power o
 two on both edges, which is the page every build wrote before this flag. The pack
 line says which one ran, because rigc writes `, page edges free` after the padding under
 `free`. Measured on the two examples by `tools/atlas_population.ts` with rigc 1.5.1, and
-again with rigc 2.0.3 and with rigc 2.1.3 under `--pack-shape rect` (the frames table
+again with rigc 2.0.3, 2.1.3 and 2.10.1 under `--pack-shape rect` (the frames table
 by the same idle render), which reproduced every figure in both tables and the one
-check figure below:
+check figure below (2.10.1: pages, atlases, idle frames and `check.json` byte-identical
+to 2.1.3's):
 
 | build | page | covered | page opaque | page / figure |
 | --- | --- | --- | --- | --- |
@@ -339,9 +341,11 @@ attachment stays its rectangle. rigc gates the result on the packed pages with
 `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` (SKIP on the compile pass, where every part has
 its own page; PASS on the packed pass, both shapes, both examples). The pack line ends
 `, shape rect` or `, shape polygon` under either, and `check.json`'s `pack_mode` records
-both flags. Measured on the two examples with spine-rigc 2.1.3 (the full entry,
-spine-core 4.3.13 beside it), `spine-parts build` with `--page-edges free` and each
-shape, the table columns by `tools/atlas_population.ts`:
+both flags. Measured on the two examples with spine-rigc 2.1.3, and again with 2.10.1,
+whose pages, atlases, idle frames and `check.json` are byte-identical to 2.1.3's under
+both shapes and both edges (the full entry, spine-core 4.3.13 beside it),
+`spine-parts build` with `--page-edges free` and each shape, the table columns by
+`tools/atlas_population.ts`:
 
 | build | page | page area | covered | page opaque | page / figure |
 | --- | --- | --- | --- | --- | --- |
@@ -377,8 +381,11 @@ The hull ceiling (spine-parts #58: hull area over rectangle area, 0.812 on demo
 rectangles are worth only what fits into them. On the polygon pages, read off the
 atlas, demo's packed rectangles overlap in 21 pairs (17 a region attachment inside a
 mesh's rectangle, 4 a mesh inside another's) and sample's in 12 (10 and 2); no two
-region attachments overlap. More would take tighter hulls, meshes in place of
-regions, or a stronger nesting search in rigc, each its own card.
+region attachments overlap. Meshes in place of regions would be rigc's stage 2 of
+polygon packing (firejune/rigc#1093), which rigc measured and folded: on the three
+production rigs most favourable to it, it adds 0.15 % of the rectangle area over
+stage 1 at tolerance 0, and nothing at the mesher's tolerance 1 or under `pot`; on
+these two examples −0.3 to −1.3 points. No build converts a region attachment.
 
 `--project core` (the default) is the reference's projection rule: a layer takes the
 painting's pixel only inside its top-most `alpha >= 250` area eroded by a 5x5 square,
@@ -574,6 +581,7 @@ See-through with another seed.
 | `CONFIG_PERIOD_DIVIDES_DURATION` | a period that is not a whole fraction of the idle — the loop could not close | that track's `period`, or `motion.duration` |
 | `CONFIG_BLINK_GROUP_MEMBERS` | `motion.blink.eyes` or `motion.blink.brows` is `[]`: a group with no members, which rigc refuses at the gate | a figure with no eyewhite part has nothing to blink: leave `motion.blink` out; one with no eyebrow part: leave `brows` and `brow_drop` out |
 | `CONFIG_BLINK_GROUP_UNIQUE` | `motion.blink.eyes` or `motion.blink.brows` names one bone more than once; the detail gives the bone and every index it sits at. rigc refuses it at the gate (`group "eyes" names member "eye" twice`) | name each bone once: the group keys every member it names |
+| `CONFIG_BONE_PROPERTY_KEYED_ONCE` | two tracks key one bone property: two single tracks, a single track on a chain link's `rotate`, or a single track on a blink member's `scaley` (`eyes`) or `translatey` (`brows`); the detail names the property and every track by its config path. rigc refuses it at the gate (`animation "idle" has two tracks on eye.scaley; merge them into one track`) | merge them into one track, or key another property or bone |
 | `CONFIG_BLINK_BROWS_PAIRED` | `motion.blink.brows` without `brow_drop`, or `brow_drop` without `brows` | state both or neither |
 | `CONFIG_STILL_OFF_THE_BLINK` | a `motion.blink.still` entry names a region on a bone the blink's `eyes` does not name (nothing to hold still), or its `bone` is one the blink's `eyes` names (the still piece would blink) | that entry's part, or its `bone` — the eye bone's parent, `head` as proposed |
 
@@ -642,7 +650,7 @@ See-through with another seed.
 | `CHECK_RIGC_PRESENT` | no `rigc` binary found (every place looked is listed) | `bun install` |
 | `CHECK_INPUT_PRESENT` on `…/parts.json` | `--parts` named a directory without `parts.json` — most often `parts/` itself. The detail says it: "--parts names the directory holding parts.json and parts/, not parts/ itself (after build, that is build's --out, whose rig is <out>/rig); without --parts it is --rig", and names the parent when the parent holds `parts.json` | `--parts` — the directory above `parts/` |
 | `CHECK_INPUT_PRESENT`, `CHECK_INPUT_IS_JSON`, `CHECK_PART_PNG_PRESENT`, `CHECK_PART_PNG_MATCHES_BOX`, `CHECK_PART_SLOT_PRESENT`, `CHECK_RIG_STAGE_PRESENT`, `CHECK_RIG_STAGE_IS_THE_CANVAS`, `CHECK_RIG_ROOT_BONE`, `CHECK_IDLE_PRESENT` | the rig directory is incomplete or disagrees with `parts.json` (`CHECK_PART_SLOT_PRESENT`: a part with no slot of its own name, which the judgement lines render it by) | re-run rig (`build` does both) |
-| `CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on spine-rigc ^2.1.3), or put a newer `rigc` first on `PATH` |
+| `CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on spine-rigc ^2.10.1), or put a newer `rigc` first on `PATH` |
 | `CHECK_RIGC_ENTRY`, `CHECK_RIGC_ENTRY_READS` | `rigc --version` names no entry (a rigc below 2.0.0), or names one in neither launcher form (`entry: cli.ts — @esotericsoftware/spine-core <v> present`, `entry: cli_core.ts — @esotericsoftware/spine-core absent — …`); `check.json`'s `rigc_entry` records the one that gated the build | `bun install` |
 | `CHECK_RIGC_GREEN` | a rigc step failed; its line is quoted | as `RIG_RIGC_GREEN` |
 | `CHECK_LOOP_LAST_FRAME_AT_DURATION` | the idle's last frame does not sit at `duration` | `motion.duration` — a whole number of 1/12 s |
@@ -658,7 +666,7 @@ See-through with another seed.
 | `LOOP_ENCODE` | the loop encoder refused a frame (translucent pixel in a GIF, a size change) | the frames; for a translucent frame write the lossless or the indexed APNG, which keep alpha |
 | `CHECK_PACK_LINE_READS` | rigc printed a `pack:` line that is not `pack: <page> <W>x<H>, <N> region(s), <P>% covered, padding <D>`, then `, page edges free` or nothing, then `, shape rect`, `, shape polygon` or nothing (spine-rigc 2.1 prints the shape; 1.5–2.0 printed none, read as `rect`); an unknown shape is this refusal; the line is quoted | a rigc this package does not know the output of; report it, with `rigc --version` |
 | `CHECK_PACK_PAGE_EDGES` | the pack line disagrees with the `--page-edges` the build was run with — its `, page edges free` clause is there under `pot` or missing under `free`, or a `pot` page is not a power of two on both edges | a rigc problem; report it, with `rigc --version` |
-| `CHECK_PACK_SHAPE` | the pack line disagrees with the `--pack-shape` the build was run with — it ends `, shape rect` under `polygon` or `, shape polygon` under `rect`, or it has no shape clause (the 1.5–2.0 form, read as `rect`) under `polygon` | a rigc older than 2.1.0 on `PATH`: rigc 2.0.3 takes `--pack-shape` without a word, packs by rectangles and prints the form with no shape clause, so this refusal is what catches it — `bun install` (this package depends on spine-rigc ^2.1.3); otherwise a rigc problem, report it with `rigc --version` |
+| `CHECK_PACK_SHAPE` | the pack line disagrees with the `--pack-shape` the build was run with — it ends `, shape rect` under `polygon` or `, shape polygon` under `rect`, or it has no shape clause (the 1.5–2.0 form, read as `rect`) under `polygon` | a rigc older than 2.1.0 on `PATH`: rigc 2.0.3 takes `--pack-shape` without a word, packs by rectangles and prints the form with no shape clause, so this refusal is what catches it — `bun install` (this package depends on spine-rigc ^2.10.1); otherwise a rigc problem, report it with `rigc --version` |
 | `BUILD_ARTIFACT_PRESENT` | the packed build lacks its `.json`, `.atlas` or page | a rigc problem; report it |
 
 ## 7. The bars `check` enforces, and what only an eye answers today
@@ -671,7 +679,7 @@ implementation's bars):
   pages on disk. There is no `spine` gate of its own: `spine-html` holds every rule
   `spine` measures (on the demo, rigc 1.5.1 and 2.0.3: `validate --profile spine`'s 14
   measured rules are all among the build's 23, the 15 others not in `spine`; rigc
-  2.1.3: the same 14 among the build's 24, which adds
+  2.1.3 and 2.10.1: the same 14 among the build's 24, which adds
   `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` on the packed pass, 16 not in `spine`; `CH09`
   holds it on every fetched example);
 - **seam**: the setup-pose render against the flat composite of `parts/`: mean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-parts",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "AI-authored Spine 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through spine-rigc before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {
@@ -57,7 +57,7 @@
   },
   "dependencies": {
     "ag-psd": "^31.0.2",
-    "spine-rigc": "^2.1.3"
+    "spine-rigc": "^2.10.1"
   },
   "devDependencies": {
     "@esotericsoftware/spine-core": "4.3.13",

package/src/check.ts

@@ -196,7 +196,7 @@ export const SPINEBOY_YARDSTICK = '1024x256, 40 region(s), 45.8% opaque (alpha >
  * `free` is the default here although rigc's own default is `pot`: the packed
  * page is this package's final artifact, and on the two public examples `free`
  * takes the page from 1024x2048 to 967x1338 (covered 56.3 % -> 91.2 %) and
- * from 512x2048 to 479x1166 (49.7 % -> 93.4 %), rigc 1.5.1, 2.0.3 and 2.1.3 (`rect`) alike. The cost was
+ * from 512x2048 to 479x1166 (49.7 % -> 93.4 %), rigc 1.5.1, 2.0.3, 2.1.3 and 2.10.1 (`rect`) alike. The cost was
  * measured on the same two builds. Each of the 49 idle frames differs from the
  * `pot` build's, by at most 1 level in any channel (demo 2,373 px, sample 651
  * px over all 49). On sample that moves STILL_REGIONS_DARK's reported
@@ -212,7 +212,7 @@ export const DEFAULT_PAGE_EDGES: PageEdges = 'free';
 /**
  * What two packed rectangles may share: spine-rigc's `build --pack
  * --pack-shape`, handed to it verbatim (in spine-rigc's CLI since 2.1.0; this
- * package's range starts at 2.1.3). `rect` keeps every region's cell apart;
+ * package's range starts at 2.10.1). `rect` keeps every region's cell apart;
  * `polygon` packs a region that only meshes draw by its emitted hull, so a
  * neighbour may sit inside its rectangle where the hull is not, with the
  * padding kept between footprints — a region attachment stays its rectangle
@@ -222,7 +222,8 @@ export const DEFAULT_PAGE_EDGES: PageEdges = 'free';
  * reason {@link DEFAULT_PAGE_EDGES} is `free`: the packed page is this
  * package's final artifact, rigc gates the footprints on the pages on disk
  * (`A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP`), and the cost is the class already
- * accepted for `free`. Measured with spine-rigc 2.1.3 (the full entry,
+ * accepted for `free`. Measured with spine-rigc 2.1.3, and again with 2.10.1,
+ * whose pages, atlases and idle frames are byte-identical to it (the full entry,
  * spine-core 4.3.13 beside it), `spine-parts build` on the two public examples
  * under `--page-edges free`: `polygon` takes demo's page from 967x1338 (91.2 %
  * covered) to 922x1348 (95.0 %), 3.9 % less area, and sample's from 479x1166

package/src/config.ts

@@ -840,6 +840,13 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
   const m = c.object('config.motion', v, ['duration', 'tracks'], ['blink']);
   if (m === null) return;
   const p = 'config.motion';
+  // Every bone property the idle will key, and the tracks that key it, in the
+  // order idleMotion writes them: single and chain tracks, then the eyes
+  // group, then the brows group.
+  const claims = new Map<string, string[]>();
+  const claim = (target: string, by: string): void => {
+    claims.set(target, [...(claims.get(target) ?? []), by]);
+  };
   const duration = 'duration' in m && c.number(`${p}.duration`, m.duration, 'positive') ? (m.duration as number) : null;
   const periodFits = (at: string, period: Json): void => {
     if (!c.number(at, period, 'positive') || duration === null) return;
@@ -863,6 +870,8 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
         if ('lag' in t) c.number(`${at}.lag`, t.lag);
         const links = typeof t.chain === 'string' ? chains.get(t.chain) : undefined;
         if (links === undefined) c.fail('CONFIG_NAME_RESOLVES', `${at}.chain`, `is ${show(t.chain)}; a chain declared in config.bones is required`);
+        // A chain track keys rotate on every link (idleMotion), one link per point.
+        else for (let k = 0; k < links; k++) claim(`${String(t.chain)}${k}.rotate`, `${at} (chain "${String(t.chain)}", link ${k})`);
         if ('amps' in t && c.array(`${at}.amps`, t.amps, true)) {
           const amps = t.amps as Json[];
           amps.forEach((a, k) => c.number(`${at}.amps[${k}]`, a));
@@ -877,7 +886,7 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
       if (typeof t.bone !== 'string' || !bones.has(t.bone)) c.fail('CONFIG_NAME_RESOLVES', `${at}.bone`, `is ${show(t.bone)}; a declared bone is required`);
       if ('prop' in t && !(SINGLE_PROPS as readonly string[]).includes(t.prop as string)) {
         c.fail('CONFIG_FIELD_TYPE', `${at}.prop`, `is ${show(t.prop)}; one of ${SINGLE_PROPS.join(', ')} is required`);
-      }
+      } else if ('prop' in t && typeof t.bone === 'string' && bones.has(t.bone)) claim(`${t.bone}.${String(t.prop)}`, at);
       if ('amp' in t) c.number(`${at}.amp`, t.amp);
       if ('period' in t) periodFits(`${at}.period`, t.period);
       if ('phase' in t) c.number(`${at}.phase`, t.phase);
@@ -886,7 +895,7 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
   }
   if ('blink' in m) {
     const b = c.object(`${p}.blink`, m.blink, ['t', 'eyes', 'squash'], ['brows', 'brow_drop', 'still']);
-    if (b === null) return;
+    if (b === null) return refuseSharedTargets(c, claims);
     if ('t' in b) c.number(`${p}.blink.t`, b.t, 'non-negative');
     if ('squash' in b) c.number(`${p}.blink.squash`, b.squash, 'positive');
     if ('brow_drop' in b) c.number(`${p}.blink.brow_drop`, b.brow_drop);
@@ -908,6 +917,15 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
           if (typeof name !== 'string' || !bones.has(name)) c.fail('CONFIG_NAME_RESOLVES', `${p}.blink.${key}[${k}]`, `is ${show(name)}; a declared bone is required`);
           if (typeof name === 'string') at.set(name, [...(at.get(name) ?? []), k]);
         });
+        // The group track keys one property on every member: scaley for the
+        // eyes, translatey for the brows — and the brows track is written only
+        // when brow_drop is stated beside them (idleMotion). A member named
+        // twice is CONFIG_BLINK_GROUP_UNIQUE's, so each bone claims once, at
+        // its first index.
+        const prop = key === 'eyes' ? 'scaley' : 'translatey';
+        if (key === 'eyes' || 'brow_drop' in b) {
+          for (const [name, ks] of at) if (bones.has(name)) claim(`${name}.${prop}`, `${p}.blink.${key}[${ks[0]}] (the blink's ${key} group, which keys ${prop} on every member)`);
+        }
         // rigc refuses a member named twice (`group "eyes" names member "eye"
         // twice`) at the gate, one stage late — issue #45, the sibling of the
         // empty group above. One refusal per repeated name, in first-seen order.
@@ -924,4 +942,27 @@ function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string,
     }
     if ('still' in b) checkBlinkStill(c, b.still, b.eyes, bones, regions);
   }
+  refuseSharedTargets(c, claims);
+}
+
+/**
+ * Two tracks keying one bone property — two single tracks, a single track
+ * beside a chain link's rotate or a blink group's member — are one refusal
+ * per property, naming every track that keys it (issue #49). rigc refuses the
+ * pair at the rig gate (`animation "idle" has two tracks on eye.scaley`), one
+ * stage after the input that was wrong; the loader knows every track it
+ * writes. The control bones the rig stage adds (`<bone>_ctl`) cannot make two
+ * distinct targets one: the rename is the same suffix on every key of a bone,
+ * and a declared bone already holding the control's name is the rig stage's
+ * refusal, `RIG_CONTROL_NAME_FREE`.
+ */
+function refuseSharedTargets(c: Check, claims: ReadonlyMap<string, string[]>): void {
+  for (const [target, by] of claims) {
+    if (by.length < 2) continue;
+    c.fail(
+      'CONFIG_BONE_PROPERTY_KEYED_ONCE',
+      `bone property "${target}"`,
+      `is keyed by ${by.length} tracks: ${by.join(' and ')}; one track per bone property is required — the idle would hold ${by.length} timelines on ${target}, and rigc refuses two tracks on one bone property. Merge them into one track, or key another property or bone`,
+    );
+  }
 }

package/src/raster/png.ts

@@ -12,11 +12,11 @@
  * refuses by name rather than misreading. So adding `pngjs` would have been a
  * second codec for the same bytes, and two codecs are two answers.
  *
- * 🔌 **The deep path is the interface, for now.** spine-rigc's package.json has
- * no `exports` map, so `spine-rigc/tools/plate.ts` is how a consumer reaches the
- * codec and it is what the installed package resolves. If rigc adds an
- * `exports` map that omits these paths, this import is what breaks, by name,
- * and `bun run smoke` is where that is seen first.
+ * 🔌 **The deep path is the interface.** spine-rigc's `exports` map carries
+ * `./*.ts`, so `spine-rigc/tools/plate.ts` is how a consumer reaches the codec
+ * and it is what the installed package resolves. If a rigc release narrows the
+ * map to omit these paths, this import is what breaks, by name, and
+ * `bun run smoke` is where that is seen first.
  */
 import { assertPng } from 'spine-rigc/src/png.ts';
 import { decodePng, encodePng } from 'spine-rigc/tools/plate.ts';