spine-parts 0.3.0 → 0.4.0

package/README.md

@@ -43,9 +43,12 @@ is taken from the full run, because the twin tails leave the head crop sideways
 blouse (recomposite error pixels 11,050 → 9,540); the default stays
 <code>near-white</code>, the reference implementation's rule, so the examples stay
 comparable with it. The loop is <code>spine-parts loop --palette</code>'s indexed APNG, 48 frames at
-12 fps, 1,706,468 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
+12 fps, 1,706,785 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
 per channel over every frame (the lossless APNG beside it, the exactness record, is
-13,645,611 bytes; the GIF, at the same error, 1,812,041); the painting is shown at half size, resampled and written
+13,645,519 bytes; the GIF, at the same error, 1,812,625). Frame 29 (2.417 s) is the
+closed eye: the blink holds for 0.084 s, one 12 fps frame rounded up, where the
+reference implementation held 0.04 s and no frame of its loop showed the eyes shut
+(issue #32); the painting is shown at half size, resampled and written
 by this package's PNG codec (nothing here encodes JPEG). <code>spine-parts sheet</code>
 made the contact sheet.
 </em></p>
@@ -218,7 +221,7 @@ agent skill.
 | `propose --head-box --full <run> --canvas WxH` | propose `seethrough.head_box` from the full run, held inside the painting |
 | `propose --parts --source --out [--compare <config>]` | propose bones, meshes, regions and an idle; draw the overlay |
 | `propose … --from-config <config>` | draw and LINT the config's current bones |
-| `rig --config --parts --out` | author `rig.json` + `motion.json`, written only after spine-rigc's round trip is green |
+| `rig --config --parts --out [--idle-keys ctl\|direct]` | author `rig.json` + `motion.json`, written only after spine-rigc's round trip is green; `--idle-keys` says whether the idle's keys on mesh-driving bones go through `<bone>_ctl` parents (default) or stay on the bones with `invariants.idleDrivesMeshes` declared |
 | `check --rig --out [--parts]` | build packed, gate under both profiles, render the idle, measure seam, loop and the five judgement lines, and report the recomposite's holes from `parts.json` |
 | `loop --frames <dir> --out <file.gif \| file.png> [--palette]` | encode a rendered idle as a looping GIF, lossless APNG, or indexed APNG (`--palette`) |
 | `build --config --source --full --head --out [--seam] [--project] [--loop]` | assemble, rig and check in one process, stopping at the first refusal |

package/cli.ts

@@ -24,6 +24,7 @@ import { type CharacterConfig, loadConfig, loadEarlyConfig } from './src/config.
 import { PartsError, problemLine } from './src/errors.ts';
 import { proposeHeadBox } from './src/headbox.ts';
 import { makeInputs } from './src/inputs.ts';
+import { DEFAULT_IDLE_KEYS, IDLE_KEYS, type IdleKeys } from './src/rig.ts';
 import { figuresPhrase, implausibleRules, layerFigures, type LayerSet, pct, readLayers, ruleSummary, times } from './src/layers.ts';
 import { checkProposal, compare, compareLines, drawLandmarks, HIP_MIN_FRACTION, lint, lintLine, type PartSet, propose, readPartSet, serializeProposal } from './src/propose.ts';
 import { readPng, writePng } from './src/raster/png.ts';
@@ -74,7 +75,9 @@ usage:
       holds parts.json and parts/). Roles come from each part's See-through tag,
       never its name. Writes <out>/proposal.json (config-shaped: bones, meshes,
       regions, motion with its blink — and a blink.still cut for a lash that
-      reaches far above its eyewhite, when a clear row allows one — and notes)
+      reaches far above its eyewhite, when a clear row allows one; no blink
+      when no part is an eyewhite, and no brows in it when no part is an
+      eyebrow, each said in a note — and notes)
       and the overlay to correct against, <out>/render/landmarks.png and
       landmarks_head.png. Prints every
       note and a LINT line for each chain link that lies off its mesh's art, for a
@@ -93,18 +96,29 @@ usage:
       layers for a painting of WxH px, held inside the painting; a shift is
       printed when one was needed.
 
-  spine-parts rig --config <config.json> --parts <dir> --out <dir>
+  spine-parts rig --config <config.json> --parts <dir> --out <dir> [--idle-keys ctl|direct]
       Author the rig: unrotated bones at the config's landmarks (a chain makes
       <chain>0..n), a square lattice mesh over every part in config.meshes
       weighted by distance to its candidate bone segments, a region for every
       part in config.regions (a motion.blink.still part as two: the rows above
       its row on a second slot <part>_still, which the blink does not move),
-      and one idle of sines and a blink. --parts is the
+      and one idle of sines and a blink whose closed hold is at least one
+      12 fps frame, so the idle frames and the loop show the eyes shut
+      (RIG_BLINK_HOLD_SPANS_A_FRAME otherwise); no blink when the config
+      states no motion.blink, and a blink group that names no bone is refused
+      by the loader, CONFIG_BLINK_GROUP_MEMBERS, before rigc starts. --parts is the
       directory holding parts.json and parts/<name>.png. The result is built
       through spine-rigc (profile spine-html, packed, then validated under
       profile spine) in a scratch directory first, and --out receives
       images/*.png, rig.json, motion.json and mesh_report.json only when both
       are green. Prints one line per mesh and the rigc gate lines.
+      --idle-keys says where the idle's keys on a bone a mesh is weighted to go:
+      ctl (the default) keys a same-origin <bone>_ctl parent instead, which
+      passes A15_IDLE_NO_MESH_BONE_KEYS on any spine-rigc; direct keys the bone
+      itself and declares invariants.idleDrivesMeshes in rig.json, which needs
+      spine-rigc 1.3.0 or later and makes A15 a SKIP that prints its cost (the
+      stage prints that SKIP line). The pose is the same to one level of float
+      rounding, and so is the per-frame mesh work (AUTHORING §5).
   spine-parts check --rig <dir> --out <dir> [--parts <dir>]
       Build, gate, render and measure a rig through spine-rigc's CLI (the rigc at
       node_modules/.bin/rigc, or on PATH). --rig holds rig.json and motion.json
@@ -375,22 +389,28 @@ function cmdRig(args: string[]): number {
   let config: string | null = null;
   let partsDir: string | null = null;
   let out: string | null = null;
+  let idleKeys: string | null = null;
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     const value = args[i + 1];
-    if (!['--config', '--parts', '--out'].includes(flag)) return usage(`rig does not take "${flag}"`);
+    if (!['--config', '--parts', '--out', '--idle-keys'].includes(flag)) return usage(`rig does not take "${flag}"`);
     if (value === undefined) return usage(`${flag} needs a value`);
     i++;
     if (flag === '--config') config = value;
     else if (flag === '--parts') partsDir = value;
-    else out = value;
+    else if (flag === '--idle-keys') {
+      if (idleKeys !== null) return usage('--idle-keys is given twice');
+      idleKeys = value;
+    } else out = value;
   }
   if (config === null) return usage('rig needs --config <config.json>');
   if (partsDir === null) return usage('rig needs --parts <dir> (the directory holding parts.json and parts/)');
   if (out === null) return usage('rig needs --out <dir>');
+  const keys = idleKeys ?? DEFAULT_IDLE_KEYS;
+  if (!(IDLE_KEYS as readonly string[]).includes(keys)) return usage(`--idle-keys ${keys}; one of ${IDLE_KEYS.join(', ')} is required`);
   const scratch = mkdtempSync(join(tmpdir(), 'spine-parts-rig-'));
   try {
-    rigStage({ config, parts: partsDir, out }, rigGateRunner(), scratch, console.log);
+    rigStage({ config, parts: partsDir, out, idleKeys: keys as IdleKeys }, rigGateRunner(), scratch, console.log);
     return EXIT_OK;
   } catch (err) {
     return printRefusal(err);

package/docs/AUTHORING.md

@@ -76,9 +76,30 @@ read by no CPU stage).
 | `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.blink` | rig | **proposed**: `{t, eyes, brows, squash, brow_drop}`; the whole blink 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 |
+| `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`. 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`) |
 
+The blink's timing is the tree's (`BLINK` in `src/motion.ts`), in seconds after
+`motion.blink.t`:
+
+| phase | eyes (`scaley` 1 → `squash` → 1) | brows (`translatey` 0 → `-brow_drop` → 0) | easing |
+| --- | --- | --- | --- |
+| shut | 0.07 | 0.08 | `shut` |
+| hold | **0.084** (the reference: 0.04) | **0.084** (the reference: 0.04) | none |
+| open | 0.16 | 0.20 | `open` |
+
+The holds are the one departure from the reference implementation, and the reason is
+the loop (issue #32). `check` renders the idle at 12 fps, a frame every 0.083333 s, and
+the loop is encoded from those frames. A 0.04 s hold is shorter than a frame, so it
+held a frame only for some `t`: at the examples' 2.3 s the eyes were shut from 2.37 s to
+2.41 s, between frames 28 (2.333 s, `scaley` 0.8356) and 29 (2.417 s, 0.2435), and over
+every key time the 6-decimal grid can write, 129,999 of the 250,000 phases against the
+frame grid showed no closed frame. A closed window at least one frame long holds a frame
+wherever it starts, so the hold is 1/12 s rounded up to the third place; the brows' hold
+grew by the same 0.044 s, so they still reach their drop 0.01 s after the lids shut and
+leave it 0.01 s after the lids open. The rig stage refuses a hold under one frame by
+name (`RIG_BLINK_HOLD_SPANS_A_FRAME`, §6), counted over the same 250,000 phases.
+
 The proposer's reach (from `src/propose.ts`): roles come from each part's tag —
 `face` makes `hip`/`chest`/`neck`/`head`, the eyewhites make the eye bones, brows are
 told apart by position, `bottomwear` makes the hip and three skirt chains,
@@ -239,8 +260,8 @@ proposal in as the steps above say (`RL01`); every step must exit 0.
 | `layers` | the table, then the `WARN` lines | every tag the plan will need has opaque pixels; one `face` in the head run; `0 WARN line(s)` | a run whose layer PNG is not its box's size (`LAYERS_PNG_MATCHES_BBOX`); a `WARN  PLAN_LAYER_…` line (§6, *Plausibility*) |
 | `sheet` of both runs | the tile list (and the sheet, if you can see) | eyes, irises, lashes and brows as left/right pairs in the head run | a head box that cut off an ornament: move `head_box`, re-run the head crop |
 | `assemble` | one line per part, the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`; and look at `render/recomposite_error_rig.png` | on the examples: `sample` 0.84 / 98.0 % / 4,512 / 1,185, 259 holes, the largest 94 px; `demo` 2.39 / 95.8 % / 11,050 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (the demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
-| `propose` | `note:` lines, `LINT` lines, `landmarks.png` | no LINT line: every chain link lies on its mesh's art, and the hip is below the chest and the figure's top quarter | a link off the art (a bone on the background) — move it onto the layer; `LINT hip at [x, y] is not below chest at [x, y]: …` or `LINT hip at [x, y] is above 0.25 of the figure height (figure y T..B, so hip y must be at least L): a hip at the shoulders` — move `hip` down to the waist (and `chest` between it and the neck); a `hanging strand … -- no chain proposed` note — that strand hangs stiff until you add a chain down the x and rows it names (§3) |
-| `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; then rigc's gate lines | `cover 1.00000` on every mesh, both gates `0 failed` | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
+| `propose` | `note:` lines, `LINT` lines, `landmarks.png` | no LINT line: every chain link lies on its mesh's art, and the hip is below the chest and the figure's top quarter | a link off the art (a bone on the background) — move it onto the layer; `LINT hip at [x, y] is not below chest at [x, y]: …` or `LINT hip at [x, y] is above 0.25 of the figure height (figure y T..B, so hip y must be at least L): a hip at the shoulders` — move `hip` down to the waist (and `chest` between it and the neck); a `hanging strand … -- no chain proposed` note — that strand hangs stiff until you add a chain down the x and rows it names (§3); a `no blink: …` or `blink without brows: …` note — the idle will not blink (or its brows will not drop), because no part came from an `eyewhite` (or `eyebrow`) layer; the note names the tags looked for |
+| `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; the `bones` line; the `idle keys` line; then rigc's gate lines (with A15's declared SKIP under `--idle-keys direct`) | `cover 1.00000` on every mesh, both gates `0 failed` | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
 | `check` (inside `build`) | the gate lines verbatim, the pack line, `loop:`, `seam:`, the five judgement lines and `RECOMPOSITE_HOLES` (§7), `check.json` | `check: PASS`, and a judgement line SKIP only where the character lacks what it reads | `CHECK_SEAM_WITHIN_BAR` or `CHECK_LOOP_CLOSES` (§6) |
 | `loop` (inside `build --loop`, or `loop --frames … --out …`) | the dropped-duplicate line, each file's line, then `loop: idle.png N B (lossless); idle-indexed.png N B (max …, mean …); idle.gif N B (max …, mean …)` | `f0048.png equals f0000.png byte for byte, so it is dropped` | `LOOP_ENCODE` (§6) |
 
@@ -253,9 +274,12 @@ entry, no dithering, filter None) — and is the small file to show. `idle.gif`
 (`loop --out x.gif`) is the same median cut in a GIF. The indexed APNG and the GIF
 print their palette error, per channel over R, G and B of every frame (and alpha's
 max for the APNG); a figure is a measurement of the file, not a bar. On the demo:
-13,645,611 B lossless, 1,706,468 B indexed and 1,812,041 B GIF, both palette files at
+13,645,519 B lossless, 1,706,785 B indexed and 1,812,625 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.
+construction and the size is the difference. 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.
 
 `--seam near-white` (the default) is the reference implementation's rule: where the
 flat stack of parts differs from the painting by more than 60, the top part takes the
@@ -276,6 +300,29 @@ error pixels from 4,512 to 4,116 and 11,050 to 9,820, and the check seam from 0.
 0.206 and 0.326 to 0.325, with no other check figure changed. The default stays the
 reference's so the examples stay comparable with it. `build` takes both flags.
 
+**`rig --idle-keys ctl|direct`.** spine-rigc's `A15_IDLE_NO_MESH_BONE_KEYS`
+(profile `spine-html`) refuses an idle that keys a bone a mesh is weighted to. `ctl`
+(the default, the reference's answer) gives every such bone a same-origin
+`<bone>_ctl` parent and moves its keys there, which passes A15 on any spine-rigc;
+the stage prints `idle keys ctl: N mesh-driving bone(s) keyed …`. `direct` keys the
+bones themselves and writes `invariants.idleDrivesMeshes: { "why": … }` into
+`rig.json` (spine-rigc 1.3.0 or later), so A15 reports
+`SKIP  A15_IDLE_NO_MESH_BONE_KEYS: declared by the rig (…): idle keys N bone(s) that
+drive M mesh attachment(s) totalling V vertices …`, which the stage prints; with no
+mesh-driving bone keyed it declares nothing, because rigc refuses a declaration
+that switches nothing off. The two write the same slots, skins and keys (`RG18`).
+Measured on the examples with `bun tools/idle_cost.ts` (spine-parts #13): `direct`
+has 41 bones for the demo's 72 and 32 for the sample's 56; every shown mesh moves on
+every idle frame under both (8 of 8 and 6 of 6, so 0 a dirty-skip renderer could
+skip); the pose costs 14.8 against 15.3 us per frame (demo) and 8.3 against 8.8 us
+(sample), the difference all in `updateWorldTransform`; the rendered idle frames
+differ by at most one level in a channel. The default stays `ctl`: the examples'
+`expected/rig.json` and `motion.json` are the reference's output, and the
+declaration is in the rig spec only, so `rigc validate <build> --profile spine-html`
+run on a `direct` build (it has no rig spec to read) refuses A15 once per keyed
+bone. `check` validates the build under `spine` only, where A15 is not in the
+profile, and is green on both.
+
 **Patching a hole no layer holds.** When an `uncovered hole` stays large after the
 plan is right — both See-through runs dropped a piece of the figure, red in
 `recomposite_error_rig.png` — add an `assemble.patches` entry:
@@ -434,6 +481,8 @@ See-through with another seed.
 | `CONFIG_PATCH_BOX` | an `assemble.patches` box with `x1 <= x0` or `y1 <= y0` | that patch's `box` (`x1`, `y1` are exclusive) |
 | `CONFIG_AMPS_MATCH_CHAIN` | a chain track's `amps` is not one per link | that track's `amps` |
 | `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_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 |
 
 ### inputs
@@ -490,6 +539,7 @@ See-through with another seed.
 | `RIG_LATTICE_ONE_LOOP` | the lattice over a part does not close into one outline even after the repair passes | that mesh's `grid` |
 | `RIG_CONTROL_NAME_FREE` | a keyed, mesh-weighted bone needs `<bone>_ctl` and that name is taken | rename the declared bone |
 | `RIG_BLINK_INSIDE_IDLE` | the blink runs outside the idle | `motion.blink.t` |
+| `RIG_BLINK_HOLD_SPANS_A_FRAME` | the tree's `BLINK.hold` is shorter than one frame at `IDLE_FPS`, so for some `motion.blink.t` no idle frame — and no frame of the loop — shows the closed eye; the detail counts the phases that miss and names the first | nothing in the config: `BLINK.hold` in `src/motion.ts`, at least `1/IDLE_FPS` s (§3) |
 | `RIG_STILL_ROW_INSIDE_PART`, `RIG_STILL_ROW_CLEAR`, `RIG_STILL_PIECES_HAVE_ART`, `RIG_STILL_NAME_FREE` | a `motion.blink.still` row that is not strictly inside the part, that crosses art (a cut through art changes the render even at rest), that leaves one piece with no art, or whose `<part>_still` slot name another part already has | that entry's `row` — a row with no art between the crease and the lash line — or rename the other part |
 | `RIG_RIGC_GREEN` | spine-rigc refused the rig; its own FAIL or compile-error line is quoted, and nothing was written | the field rigc's line names — spine-rigc's own AUTHORING §5 maps each of its assertions (`node_modules/spine-rigc/docs/AUTHORING.md`) |
 
@@ -575,13 +625,15 @@ What each figure is, and is not:
   layers".** A gap shows the page, a rim a colour no part has there, a doubled line a
   part drawn off its place; each changes the setup-pose render against the flat stack,
   which is what the seam bar measures. No separate line is written for it.
-- **The blink is measured at the setup pose, not in an idle frame.** On both examples
-  the eyes are fully shut from 2.37 s to 2.41 s, and no 12 fps idle frame falls inside
-  that window (`idle_frames_closed` is empty: frames 28 and 29 are 2.333 s and
-  2.417 s), so the idle render and the loop encoded from it never show the closed eye.
-  rigc's `render` takes no time, so the closed pose is a throwaway animation holding
-  the blink tracks' closed value, built and rendered beside the seam's still on the
-  same grid — the comparison is then of what the blink alone changed.
+- **The blink is measured at the setup pose, not in an idle frame.** Since issue #32
+  an idle frame does fall inside the closed window — on both examples the eyes are
+  fully shut from 2.37 s to 2.454 s and `idle_frames_closed` is `[29]` (2.417 s) — but
+  that frame also carries the idle's sway, so it is not a comparison of what the blink
+  alone changed. rigc's `render` takes no time, so the closed pose is a throwaway
+  animation holding the blink tracks' closed value, built and rendered beside the
+  seam's still on the same grid. `idle_frames_closed` is what says the loop shows the
+  closed eye; before #32 it was `[]` on both examples, with the 0.04 s hold between
+  frames 28 and 29.
 - **The colour-patch figure is not reliable enough for a bar.** "Nearest colour in the
   open eye's box" counts a legitimate colour the open eye never showed (skin under the
   lid) as a patch, and a patch the open eye happened to contain as none. It is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-parts",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "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": "^1.2.3"
+    "spine-rigc": "^1.3.0"
   },
   "devDependencies": {
     "@types/bun": "^1.4.2",

package/src/build.ts

@@ -53,7 +53,7 @@ import { type LayerSet, readLayers } from './layers.ts';
 import { readParts, writeParts } from './parts.ts';
 import { encodePngBytes, readPng, writePng } from './raster/png.ts';
 import type { Raster } from './raster/types.ts';
-import { buildRig, rigJsonText, type RigOutput } from './rig.ts';
+import { buildRig, DEFAULT_IDLE_KEYS, type IdleKeys, rigJsonText, type RigOutput } from './rig.ts';
 
 /** Where a stage's lines go. The commands hand it `console.log`; `build` hands it a prefixing wrapper. */
 export type Log = (line: string) => void;
@@ -162,13 +162,22 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
 interface GateRun {
   label: string;
   status: number;
-  /** rigc's FAIL lines and its assertion summary, as it printed them. */
+  /** rigc's FAIL lines, its assertion summary and the one SKIP this stage's own declaration causes, as it printed them. */
   lines: string[];
 }
 
+/**
+ * `A15_IDLE_NO_MESH_BONE_KEYS`'s SKIP under `invariants.idleDrivesMeshes` —
+ * the line in which rigc states what `--idle-keys direct` declared and what it
+ * costs. It is the one SKIP the rig stage prints: every other SKIP is a check
+ * with nothing to measure, while this one is switched off by a field this
+ * stage wrote, so it is shown rather than folded into the skipped count.
+ */
+const DECLARED_SKIP = /^ {2}SKIP {2}A15_IDLE_NO_MESH_BONE_KEYS: declared by the rig/;
+
 function gateRun(label: string, rigc: RigcRunner, args: string[]): GateRun {
   const r = rigc(args);
-  const lines = r.out.split('\n').filter((l) => /^ {2}FAIL {2}/.test(l) || /assertions: \d+ measured/.test(l) || /^rigc compile error/.test(l));
+  const lines = r.out.split('\n').filter((l) => /^ {2}FAIL {2}/.test(l) || /assertions: \d+ measured/.test(l) || /^rigc compile error/.test(l) || DECLARED_SKIP.test(l));
   return { label, status: r.status, lines };
 }
 
@@ -201,6 +210,8 @@ export interface RigStageInput {
   /** The directory holding parts.json and parts/<name>.png. */
   parts: string;
   out: string;
+  /** Where the idle's keys on mesh-driving bones go; `ctl` when absent. See `IDLE_KEYS` in `src/rig.ts`. */
+  idleKeys?: IdleKeys;
 }
 
 /** Author the rig, gate it through rigc in `scratch`, and write `out` only when both gates are green. */
@@ -212,7 +223,7 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
     const png = join(input.parts, 'parts', `${p.name}.png`);
     if (existsSync(png)) images.set(p.name, readPng(png));
   }
-  const rig = buildRig(cfg, parts, images);
+  const rig = buildRig(cfg, parts, images, undefined, input.idleKeys ?? DEFAULT_IDLE_KEYS);
   const texts: Array<[string, string]> = [
     ['rig.json', rigJsonText(rig.rig)],
     ['motion.json', rigJsonText(rig.motion)],
@@ -233,6 +244,11 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
   log(
     `  bones ${rig.rig.bones.length} (${rig.controls.length} control) slots ${rig.rig.slots.length} meshes ${rig.meshReport.length} regions ${regions} vertices ${vertices}; idle ${rig.motion.animations.idle.duration} s, ${tracks.length} track(s), ${keys} key(s)`,
   );
+  log(
+    rig.idleKeys === 'ctl'
+      ? `  idle keys ctl: ${rig.meshKeyed.length} mesh-driving bone(s) keyed by the idle, each keyed through a same-origin <bone>_ctl parent`
+      : `  idle keys direct: ${rig.meshKeyed.length} mesh-driving bone(s) keyed in place, ${rig.rig.invariants === undefined ? 'so no invariants.idleDrivesMeshes is declared (it would switch nothing off)' : 'invariants.idleDrivesMeshes declared'}`,
+  );
   const gate = gateThroughRigc(rig, texts, rigc, scratch);
   for (const g of gate) {
     log(`  rigc ${g.label}: exit ${g.status}`);

package/src/check.ts

@@ -64,6 +64,7 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync,
 import { basename, delimiter, dirname, join, resolve } from 'node:path';
 import { cropToSpineY } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
+import { framesInside, IDLE_FPS } from './motion.ts';
 import {
   bandExcursion,
   blinkFigures,
@@ -107,8 +108,8 @@ export const SEAM_PX_LEVEL_HIGH = 80;
 /** Loop: frame 0 vs the frame at t = duration, largest |d|, exactly this. */
 export const LOOP_MAX_BAR = 0;
 
-/** The idle render the reference makes, and the one issue #1's loop is encoded from. */
-export const IDLE_FPS = 12;
+/** The idle render the reference makes, and the one issue #1's loop is encoded from. Defined beside the blink it has to see (`src/motion.ts`). */
+export { IDLE_FPS };
 export const IDLE_MAX_PX = 640;
 /** The throwaway setup-pose animation: one key at 0 and one at this time, rendered at this rate. */
 const STILL_DURATION = 0.1;
@@ -1085,8 +1086,7 @@ function blinkLine(
   const b = blinkFigures(open.frames[0].image, closed.frames[0].image, open.background, box, BLINK_PATCH_LEVEL);
   const from = Math.max(...shut.map((s) => s.window[0]));
   const to = Math.min(...shut.map((s) => s.window[1]));
-  const frames: number[] = [];
-  for (let k = 0; k < idle.sampled; k++) if (k / idle.fps >= from - 1e-9 && k / idle.fps <= to + 1e-9) frames.push(k);
+  const frames = framesInside(from, to, idle.fps, idle.sampled);
   if (b.holePx > BLINK_HOLE_BAR) {
     problems.push({
       code: 'CHECK_BLINK_NO_HOLE',

package/src/config.ts

@@ -175,12 +175,19 @@ export interface BlinkStill {
   bone: string;
 }
 
+/**
+ * The idle's one blink. `eyes` names at least one bone; `brows` and
+ * `brow_drop` are stated together or not at all, and a stated `brows` names
+ * at least one bone — rigc refuses a group with no members, and a
+ * `brow_drop` with no brows is a value nothing reads. A figure with no eye
+ * bone has no blink: leave `blink` out (`CONFIG_BLINK_GROUP_MEMBERS`).
+ */
 export interface Blink {
   t: number;
   eyes: string[];
-  brows: string[];
+  brows?: string[];
   squash: number;
-  brow_drop: number;
+  brow_drop?: number;
   still?: Record<string, BlinkStill>;
 }
 
@@ -823,6 +830,12 @@ function checkCoverage(c: Check, parts: string[], patches: string[], meshes: Jso
   }
 }
 
+/** What an empty blink group is told: the tags whose parts make its bones, and what to write instead. */
+const BLINK_GROUP_EMPTY: Readonly<Record<'eyes' | 'brows', string>> = {
+  eyes: 'is []; the eyes group must name at least one bone (rigc refuses a group with no members). The eye bones come from eyewhite-r / eyewhite-l parts; a figure with none has nothing to blink, so leave config.motion.blink out',
+  brows: 'is []; the brows group must name at least one bone (rigc refuses a group with no members). The brow bones come from eyebrow-r / eyebrow-l parts; a figure with none has nothing to drop, so leave brows and brow_drop out',
+};
+
 function checkMotion(c: Check, v: Json, bones: Set<string>, chains: Map<string, number>, regions: Json): void {
   const m = c.object('config.motion', v, ['duration', 'tracks'], ['blink']);
   if (m === null) return;
@@ -872,14 +885,25 @@ 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', 'brows', 'squash', 'brow_drop'], ['still']);
+    const b = c.object(`${p}.blink`, m.blink, ['t', 'eyes', 'squash'], ['brows', 'brow_drop', 'still']);
     if (b === null) return;
     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);
+    if ('brows' in b && !('brow_drop' in b)) {
+      c.fail('CONFIG_BLINK_BROWS_PAIRED', `${p}.blink.brow_drop`, 'is absent while config.motion.blink.brows is stated; the brows group drops by brow_drop, so state both or neither');
+    }
+    if ('brow_drop' in b && !('brows' in b)) {
+      c.fail('CONFIG_BLINK_BROWS_PAIRED', `${p}.blink.brows`, `is absent while config.motion.blink.brow_drop is ${show(b.brow_drop)}; nothing would drop, so state both or neither`);
+    }
     for (const key of ['eyes', 'brows'] as const) {
       if (key in b && c.array(`${p}.blink.${key}`, b[key], false)) {
-        (b[key] as Json[]).forEach((name, k) => {
+        const list = b[key] as Json[];
+        // rigc refuses a group with no members (`group "eyes" declares no
+        // members`) one stage later, at the gate; the stage whose input is
+        // wrong is this one.
+        if (list.length === 0) c.fail('CONFIG_BLINK_GROUP_MEMBERS', `${p}.blink.${key}`, BLINK_GROUP_EMPTY[key]);
+        list.forEach((name, k) => {
           if (typeof name !== 'string' || !bones.has(name)) c.fail('CONFIG_NAME_RESOLVES', `${p}.blink.${key}[${k}]`, `is ${show(name)}; a declared bone is required`);
         });
       }

package/src/motion.ts

@@ -24,10 +24,25 @@
  * ## Blink
  *
  * The `eyes` group's `scaley` goes 1 -> `squash` -> 1 and the `brows`
- * group's `translatey` 0 -> `-brow_drop` -> 0, with the reference's fixed
- * timing: eyes shut over {@link BLINK.shut} s, hold {@link BLINK.hold} s, open
- * over {@link BLINK.open} s; brows 0.08 / 0.04 / 0.20 s. The two named easings
- * are the reference's. A blink whose window does not fit strictly inside the
+ * group's `translatey` 0 -> `-brow_drop` -> 0 (no brows group and no brow
+ * track when the config states no `brows`; no blink groups or tracks at all
+ * when it states no `blink`), with a fixed timing: eyes shut
+ * over {@link BLINK.shut} s, hold {@link BLINK.hold} s, open over
+ * {@link BLINK.open} s; brows 0.08 / 0.084 / 0.20 s. The shut and open times
+ * and the two named easings are the reference's; the holds are not (issue
+ * #32). The reference held 0.04 s, under one frame of the idle the loop is
+ * encoded from ({@link IDLE_FPS} fps, a frame every 0.083333 s), so whether
+ * any frame showed the closed eye depended on `blink.t`: at the examples'
+ * 2.3 s the eyes were shut from 2.37 s to 2.41 s, between frames 28
+ * (2.333 s, scaley 0.8356) and 29 (2.417 s, 0.2435), and over every key time
+ * the 6-decimal grid can write, 129,999 of 250,000 phases against the frame
+ * grid showed none. A closed interval at least one frame period long holds a
+ * frame wherever it starts, so the hold is 1/12 s rounded up to the third
+ * place, 0.084 s; {@link blinkHoldMisses} counts the phases and the rig stage
+ * refuses a hold with any miss (`RIG_BLINK_HOLD_SPANS_A_FRAME`). The brows'
+ * hold grew by the same 0.044 s, so they still reach their drop 0.01 s after
+ * the lids shut and leave it 0.01 s after the lids open, as the reference
+ * ordered them. A blink whose window does not fit strictly inside the
  * idle would write keys out of order, and is refused (`RIG_BLINK_INSIDE_IDLE`).
  * The squash pivots at each eye bone's origin, so a part's rows above it move
  * down by (1 - squash) times their height above it; the rows a
@@ -38,15 +53,22 @@
  *
  * spine-rigc's `spine-html` profile refuses an `idle` that keys a bone a mesh
  * is weighted to (the player skips idle work on meshes). The reference's
- * answer, ported as is: for every keyed bone that some mesh names among its
- * candidates, add a parent `<bone>_ctl` at the SAME origin, re-parent the bone
- * under it, and move the keys to the control. The pose is identical.
+ * answer, ported as is and still the default (`rig --idle-keys ctl`): for
+ * every keyed bone that some mesh names among its candidates, add a parent
+ * `<bone>_ctl` at the SAME origin, re-parent the bone under it, and move the
+ * keys to the control. The pose is the same up to float rounding: the
+ * extra bone in each chain moves the rendered idle frames by at most one
+ * level in a channel (measured on both public examples, spine-parts #13).
  *
  * ⚠️ **This satisfies the rule's wording only.** The meshes are still
  * deformed every frame — by the control's motion, through the bone they are
  * weighted to — so whatever cost `A15` exists to keep off the player is paid
- * all the same. How a weighted-mesh painting rig should meet that rule is an
- * open question about the rule, not something this function settles.
+ * all the same. Measured (spine-parts #13): on both public examples every
+ * shown mesh has a driving bone whose world transform changes on every idle
+ * frame, with the controls and without them, so a dirty-skip renderer can
+ * skip none either way. spine-rigc 1.3.0 answered the rule's side
+ * (`invariants.idleDrivesMeshes`); `rig --idle-keys direct` keys the bones in
+ * place and declares it (`src/rig.ts`, `IDLE_KEYS`).
  *
  * One correction to the reference: it moved single-bone tracks to the control
  * but left the blink GROUPS naming the original bone, so a mesh-bound eye or
@@ -58,13 +80,20 @@ import { pyRound } from './round.ts';
 
 export const KEYS_PER_PERIOD = 8;
 
-/** The blink's fixed timing, in seconds after `blink.t`. */
+/**
+ * The rate the idle is rendered at — `check`'s `idle_frames/`, its contact
+ * sheet, and the loop `build --loop` encodes from them. The reference renders
+ * at it too.
+ */
+export const IDLE_FPS = 12;
+
+/** The blink's fixed timing, in seconds after `blink.t`. The holds are 1/{@link IDLE_FPS} s rounded up (see the Blink section above). */
 export const BLINK = {
   shut: 0.07,
-  hold: 0.04,
+  hold: 0.084,
   open: 0.16,
   browShut: 0.08,
-  browHold: 0.04,
+  browHold: 0.084,
   browOpen: 0.2,
 } as const;
 
@@ -141,7 +170,9 @@ export function idleMotion(cfg: CharacterConfig, chains: ReadonlyMap<string, str
   if (bl !== undefined) {
     const tb = bl.t;
     groups.eyes = [...bl.eyes];
-    groups.brows = [...bl.brows];
+    // A blink without brows (no eyebrow part) writes no brows group: rigc
+    // refuses a group with no members, and the loader refuses an empty one.
+    if (bl.brows !== undefined) groups.brows = [...bl.brows];
     const at = (dt: number): number => pyRound(tb + dt, 6);
     tracks.push({
       group: 'eyes',
@@ -155,18 +186,21 @@ export function idleMotion(cfg: CharacterConfig, chains: ReadonlyMap<string, str
         { t: T, v: [1] },
       ],
     });
-    tracks.push({
-      group: 'brows',
-      property: 'translatey',
-      keys: [
-        { t: 0, v: [0] },
-        { t: tb, v: [0], ease: 'shut' },
-        { t: at(BLINK.browShut), v: [-bl.brow_drop] },
-        { t: at(BLINK.browShut + BLINK.browHold), v: [-bl.brow_drop], ease: 'open' },
-        { t: at(BLINK.browShut + BLINK.browHold + BLINK.browOpen), v: [0] },
-        { t: T, v: [0] },
-      ],
-    });
+    const drop = bl.brow_drop;
+    if (bl.brows !== undefined && drop !== undefined) {
+      tracks.push({
+        group: 'brows',
+        property: 'translatey',
+        keys: [
+          { t: 0, v: [0] },
+          { t: tb, v: [0], ease: 'shut' },
+          { t: at(BLINK.browShut), v: [-drop] },
+          { t: at(BLINK.browShut + BLINK.browHold), v: [-drop], ease: 'open' },
+          { t: at(BLINK.browShut + BLINK.browHold + BLINK.browOpen), v: [0] },
+          { t: T, v: [0] },
+        ],
+      });
+    }
   }
   const name = `${cfg.key}_painting`;
   return {
@@ -179,9 +213,72 @@ export function idleMotion(cfg: CharacterConfig, chains: ReadonlyMap<string, str
   };
 }
 
-/** The last time any blink key sits at before the closing key, in seconds after `blink.t`. */
+/**
+ * The idle frames `0 .. count - 1` at `fps` whose time lies in the closed
+ * window `[from, to]` — the frames that show a held key. The same reading
+ * `check` writes as `BLINK_NO_HOLE.idle_frames_closed`.
+ */
+export function framesInside(from: number, to: number, fps: number, count: number): number[] {
+  const out: number[] = [];
+  for (let k = 0; k < count; k++) if (k / fps >= from - 1e-9 && k / fps <= to + 1e-9) out.push(k);
+  return out;
+}
+
+export interface HoldMisses {
+  /** The phases tried: every microsecond key time over one period of the frame grid against the 6-decimal grid. */
+  phases: number;
+  /** Of those, the ones whose closed window holds no frame. */
+  misses: number;
+  /** The first missing `blink.t`, in seconds, or null. */
+  first: number | null;
+}
+
+/**
+ * Over every `blink.t` the idle can write, how many put no frame at `fps`
+ * inside the eyes' closed window `[t + shut, t + shut + hold]`, both ends
+ * rounded to 6 decimals as {@link idleMotion} writes them.
+ *
+ * Key times are 6-decimal numbers, and a frame falls at `k * 10^6 / fps`
+ * microseconds, so the pattern of frames against the microsecond grid
+ * repeats every `10^6 / gcd(fps, 10^6)` microseconds (250,000 at 12 fps).
+ * Trying every `t` over one such period is therefore every case, not a
+ * sample. A 1/120 s step was the brief's first choice and was rejected: it
+ * tries 30 of those 250,000 phases.
+ */
+export function blinkHoldMisses(shut: number, hold: number, fps: number): Readonly<HoldMisses> {
+  const key = `${shut} ${hold} ${fps}`;
+  const known = HOLD_MISSES.get(key);
+  if (known !== undefined) return known;
+  const gcd = (a: number, b: number): number => (b === 0 ? a : gcd(b, a % b));
+  const period = 1e6 / gcd(fps, 1e6);
+  let misses = 0;
+  let first: number | null = null;
+  for (let j = 0; j < period; j++) {
+    const t = j / 1e6;
+    const from = pyRound(t + shut, 6);
+    const to = pyRound(t + shut + hold, 6);
+    const k = Math.ceil((from - 1e-9) * fps);
+    if (!(k / fps >= from - 1e-9 && k / fps <= to + 1e-9)) {
+      misses++;
+      if (first === null) first = pyRound(t, 6);
+    }
+  }
+  const out = { phases: period, misses, first };
+  HOLD_MISSES.set(key, out);
+  return out;
+}
+
+/** {@link blinkHoldMisses} is a pure function of its three numbers and costs a quarter of a million roundings; the rig stage asks it the same question on every build. */
+const HOLD_MISSES = new Map<string, Readonly<HoldMisses>>();
+
+/** The last time any blink key sits at before the closing key, in seconds after `blink.t`, for a blink with brows. */
 export const BLINK_SPAN = Math.max(BLINK.shut + BLINK.hold + BLINK.open, BLINK.browShut + BLINK.browHold + BLINK.browOpen);
 
+/** {@link BLINK_SPAN} for this blink: without brows, only the eyes' keys have to fit inside the idle. */
+export function blinkSpan(bl: { brows?: readonly string[] }): number {
+  return bl.brows === undefined ? BLINK.shut + BLINK.hold + BLINK.open : BLINK_SPAN;
+}
+
 /**
  * The bones that get a `<bone>_ctl`: keyed by a single track or named by a
  * blink group, AND named by some mesh's candidates. Sorted, as the reference

package/src/propose.ts

@@ -8,7 +8,8 @@
  * makes it the skirt is that it came from `bottomwear`. The rules, by tag:
  *
  * - `face` (head run first) -> `hip`/`chest`/`neck`/`head`; `eyewhite-r/-l`
- *   -> `eye_r`/`eye_l`; `mouth` -> `mouth` at the centroid of its biggest blob
+ *   -> `eye_r`/`eye_l`, the blink's `eyes` group — no eyewhite, no blink, and
+ *   no eyebrow, no `brows` in it, each said in a note (issue #35); `mouth` -> `mouth` at the centroid of its biggest blob
  *   (stray pixels inflate a box); `eyebrow-*` -> `brow_r`/`brow_l` by POSITION
  *   left or right of the eye axis, never by tag, because the head run has been
  *   observed to swap the two brow tags.
@@ -93,6 +94,21 @@ export interface ProposedChainTrack {
   lag: number;
 }
 
+/** `brows` and `brow_drop` are absent together when no eyebrow part exists: rigc refuses a group with no members. */
+export interface ProposedBlink {
+  t: number;
+  eyes: string[];
+  brows?: string[];
+  squash: number;
+  brow_drop?: number;
+  still?: Record<string, { row: number; bone: string }>;
+}
+
+/** The tags whose parts make the eye bones, the blink's `eyes` group. Nothing else does: irides and lashes ride those bones as regions. */
+export const EYE_GROUP_TAGS: readonly string[] = ['eyewhite-r', 'eyewhite-l'];
+/** The tags whose parts make the brow bones, the blink's `brows` group. */
+export const BROW_GROUP_TAGS: readonly string[] = ['eyebrow-r', 'eyebrow-l'];
+
 export interface Proposal {
   bones: BoneEntry[];
   meshes: Record<string, MeshSpec>;
@@ -100,7 +116,8 @@ export interface Proposal {
   motion: {
     duration: number;
     tracks: Array<ProposedSingleTrack | ProposedChainTrack>;
-    blink: { t: number; eyes: string[]; brows: string[]; squash: number; brow_drop: number; still?: Record<string, { row: number; bone: string }> };
+    /** Absent when no part feeds the `eyes` group ({@link EYE_GROUP_TAGS}): a blink with nothing to blink is not written. */
+    blink?: ProposedBlink;
   };
   notes: string[];
 }
@@ -671,15 +688,22 @@ export function propose(P: PartSet): Proposal {
     if (browOf.has(p.name)) role = browOf.get(p.name);
     if (role !== undefined) regions[p.name] = role;
   }
-  const blink: Proposal['motion']['blink'] = {
-    t: 2.3,
-    eyes: (['r', 'l'] as const).filter((s) => eyes.has(s)).map((s) => `eye_${s}`),
-    brows: (['r', 'l'] as const).filter((s) => bySide.has(s)).map((s) => `brow_${s}`),
-    squash: 0.12,
-    brow_drop: 1.2,
-  };
-  const still = lashStills(P, ew, notes);
-  if (Object.keys(still).length > 0) blink.still = still;
+  // A blink group rigc is handed must name a member (rigc refuses `group
+  // "eyes" declares no members`), so a group with none is not written, and a
+  // blink with no eyes is not written at all: a value with nothing to act on
+  // would be invented. Each omission is a note naming the tags looked for.
+  const eyeBonesProposed = (['r', 'l'] as const).filter((s) => eyes.has(s)).map((s) => `eye_${s}`);
+  const browBonesProposed = (['r', 'l'] as const).filter((s) => bySide.has(s)).map((s) => `brow_${s}`);
+  let blink: ProposedBlink | undefined;
+  if (eyeBonesProposed.length === 0) {
+    const brows = browBonesProposed.length === 0 ? '' : `; ${browBonesProposed.join(', ')} ${browBonesProposed.length === 1 ? 'is' : 'are'} placed and nothing drops ${browBonesProposed.length === 1 ? 'it' : 'them'}`;
+    notes.push(`no blink: no eyewhite part (looked for: ${EYE_GROUP_TAGS.join(', ')}), so the blink's eyes group would name no bone${brows}`);
+  } else {
+    blink = browBonesProposed.length === 0 ? { t: 2.3, eyes: eyeBonesProposed, squash: 0.12 } : { t: 2.3, eyes: eyeBonesProposed, brows: browBonesProposed, squash: 0.12, brow_drop: 1.2 };
+    const still = lashStills(P, ew, notes);
+    if (Object.keys(still).length > 0) blink.still = still;
+    if (browBonesProposed.length === 0) notes.push(`blink without brows: no eyebrow part (looked for: ${BROW_GROUP_TAGS.join(', ')}), so the blink has no brows group and no brow_drop`);
+  }
   tracks.push(
     { bone: 'chest', prop: 'translatey', amp: 1.3, period: 4.0, phase: 0.0, base: 1.3 },
     { bone: 'chest', prop: 'scalex', amp: 0.004, period: 4.0, phase: 0.0, base: 1.004 },
@@ -1069,7 +1093,7 @@ export function propose(P: PartSet): Proposal {
       } else notes.push(`${p.name} (${p.from}): no rule -> region on ${regions[p.name]}`);
     }
   }
-  return { bones, meshes, regions, motion: { duration: 4.0, tracks, blink }, notes };
+  return { bones, meshes, regions, motion: blink === undefined ? { duration: 4.0, tracks } : { duration: 4.0, tracks, blink }, notes };
 }
 
 // ---------------------------------------------------------------------------

package/src/rig.ts

@@ -28,7 +28,15 @@
  *   changes no pixel outside the blink (issue #26, `RG16`). A `painting:`
  *   patch (`assemble.patches`) is always a region; its slot sits where
  *   parts.json puts it, which is where its `draw` put it.
- * - **The idle** and its control bones (`src/motion.ts`).
+ * - **The idle** and, under `idleKeys: 'ctl'` (the default), its control
+ *   bones (`src/motion.ts`). Under `idleKeys: 'direct'` the keys stay on the
+ *   bones the meshes are weighted to, no `<bone>_ctl` is added, and the rig
+ *   spec declares `invariants.idleDrivesMeshes` with
+ *   {@link IDLE_DRIVES_MESHES_WHY} — spine-rigc 1.3.0's statement that this
+ *   idle deforms meshes on purpose, which `A15_IDLE_NO_MESH_BONE_KEYS` then
+ *   reports as a SKIP with its cost instead of refusing each bone. The
+ *   declaration is written only when the idle keys at least one mesh-driving
+ *   bone: rigc refuses a declaration that switches nothing off.
  *
  * Every part image is padded by {@link PAD} transparent pixels on each side
  * before it is meshed or placed, and the padded image is what `images/`
@@ -47,7 +55,7 @@ import { type BoneEntry, type CharacterConfig, type Point, ROOT_BONE } from './c
 import { cropToSpineY } from './coords.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { artCoverage, ART_ALPHA, latticeMesh, ONE_LOOP_PASSES } from './mesh.ts';
-import { BLINK_SPAN, CONTROL_SUFFIX, controlledBones, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
+import { BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
 import { PAINTING_RUN, type PartsFile, readFrom } from './parts.ts';
 import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
@@ -102,8 +110,40 @@ export interface RigSpec {
   bones: RigBone[];
   slots: Array<{ name: string; bone: string; attachment: string }>;
   skins: { default: Record<string, Record<string, MeshAttachment | RegionAttachment>> };
+  /** Written only under `idleKeys: 'direct'`, and only when the idle keys a mesh-driving bone. */
+  invariants?: { idleDrivesMeshes: { why: string } };
 }
 
+/**
+ * Where the idle's keys on a mesh-driving bone go (`rig --idle-keys`).
+ *
+ * - `ctl`: onto a same-origin `<bone>_ctl` parent, which passes
+ *   `A15_IDLE_NO_MESH_BONE_KEYS` under every spine-rigc this package has run
+ *   on. It satisfies the rule's wording only — see `src/motion.ts`.
+ * - `direct`: onto the bone itself, with `invariants.idleDrivesMeshes`
+ *   declared, which needs spine-rigc 1.3.0 or later (an older rigc refuses
+ *   the unknown invariant by name).
+ *
+ * Measured on the two public examples (spine-parts #13, `tools/idle_cost.ts`):
+ * `direct` removes 31 of 72 bones (demo) and 24 of 56 (sample); every shown
+ * mesh (8 and 6) has a driving bone whose world transform changes on every
+ * idle frame under both, so the meshes a dirty-skip renderer could skip are 0
+ * in both; and the per-frame pose time differs only in
+ * `updateWorldTransform` (1.2 against 0.7 us on the demo), about 3 % of a
+ * frame dominated by `computeWorldVertices`. The controls buy no renderer
+ * work. `ctl` stays the default because the examples' expected `rig.json` and
+ * `motion.json` are the reference implementation's output, and because the
+ * declaration lives in the rig spec only: `rigc validate <build> --profile
+ * spine-html`, which has no rig spec to read, refuses a `direct` build once
+ * per keyed mesh bone.
+ */
+export const IDLE_KEYS = ['ctl', 'direct'] as const;
+export type IdleKeys = (typeof IDLE_KEYS)[number];
+export const DEFAULT_IDLE_KEYS: IdleKeys = 'ctl';
+
+/** The `why` of the `invariants.idleDrivesMeshes` that `idleKeys: 'direct'` declares. */
+export const IDLE_DRIVES_MESHES_WHY = 'painting rig: the idle is meant to deform the meshes it keys (spine-parts rig --idle-keys direct)';
+
 export interface MeshReport {
   part: string;
   vertices: number;
@@ -122,12 +162,38 @@ export interface RigOutput {
   meshReport: MeshReport[];
   /** The padded images, by file name (`<part>.png`), in parts.json order. */
   images: Array<[string, Raster]>;
-  /** The bones that got a `<bone>_ctl`, sorted. */
+  /** The bones that got a `<bone>_ctl`, sorted; empty under `idleKeys: 'direct'`. */
   controls: string[];
+  /** The idle-keyed bones some mesh is weighted to, sorted — the bones `ctl` moves the keys off, and `direct` keys in place. */
+  meshKeyed: string[];
+  idleKeys: IdleKeys;
   /** The one-loop passes each mesh took, for the printed report. */
   loopPasses: Record<string, number>;
 }
 
+/**
+ * `RIG_BLINK_HOLD_SPANS_A_FRAME` (issue #32): the eyes' hold must put an
+ * idle frame inside the closed window for every `blink.t`, or the idle
+ * frames, the contact sheet and the loop show a blink that never closes. The
+ * three numbers are the tree's own constants (`BLINK.shut`, `BLINK.hold`,
+ * `IDLE_FPS`), which the rig stage passes on every build that has a blink;
+ * they are parameters so the refusal can be planted without editing them.
+ */
+export function blinkHoldProblems(shut: number, hold: number, fps: number): Problem[] {
+  const m = blinkHoldMisses(shut, hold, fps);
+  if (m.misses === 0) return [];
+  return [
+    {
+      code: 'RIG_BLINK_HOLD_SPANS_A_FRAME',
+      object: 'BLINK.hold (src/motion.ts)',
+      detail:
+        `is ${hold} s; the idle is rendered at IDLE_FPS = ${fps}, a frame every ${pyRound(1 / fps, 6)} s, so the closed window [t + ${shut}, t + ${pyRound(shut + hold, 6)}] s holds no frame ` +
+        `for ${m.misses} of the ${m.phases} phases a 6-decimal blink.t takes against the frame grid (the first at t = ${m.first} s), and the idle frames and the loop show no closed eye there; ` +
+        `a hold of at least one frame, 1/${fps} s, is required`,
+    },
+  ];
+}
+
 /** The slot, attachment and image name suffix of a `motion.blink.still` part's upper piece. */
 export const STILL_SUFFIX = '_still';
 
@@ -150,7 +216,13 @@ function pt(p: Point): string {
  * Build the rig. `images` holds every parts.json part's PNG by part name.
  * Every problem found is thrown at once, as one `PartsError`.
  */
-export function buildRig(cfg: CharacterConfig, parts: PartsFile, images: ReadonlyMap<string, Raster>, maxLoopPasses: number = ONE_LOOP_PASSES): RigOutput {
+export function buildRig(
+  cfg: CharacterConfig,
+  parts: PartsFile,
+  images: ReadonlyMap<string, Raster>,
+  maxLoopPasses: number = ONE_LOOP_PASSES,
+  idleKeys: IdleKeys = DEFAULT_IDLE_KEYS,
+): RigOutput {
   const problems: Problem[] = [];
   const fail = (code: string, object: string, detail: string): void => {
     problems.push({ code, object, detail });
@@ -261,13 +333,15 @@ export function buildRig(cfg: CharacterConfig, parts: PartsFile, images: Readonl
 
   // ---- motion ------------------------------------------------------------
   const bl = cfg.motion.blink;
-  if (bl !== undefined && !(bl.t > 0 && bl.t + BLINK_SPAN < cfg.motion.duration)) {
+  const span = bl === undefined ? 0 : blinkSpan(bl);
+  if (bl !== undefined && !(bl.t > 0 && bl.t + span < cfg.motion.duration)) {
     fail(
       'RIG_BLINK_INSIDE_IDLE',
       'config.motion.blink.t',
-      `is ${bl.t} s; the blink's keys run from t to t + ${pyRound(BLINK_SPAN, 6)} s between the idle's first key at 0 and its last at ${cfg.motion.duration} s, so 0 < t < ${pyRound(cfg.motion.duration - BLINK_SPAN, 6)} is required`,
+      `is ${bl.t} s; the blink's keys run from t to t + ${pyRound(span, 6)} s between the idle's first key at 0 and its last at ${cfg.motion.duration} s, so 0 < t < ${pyRound(cfg.motion.duration - span, 6)} is required`,
     );
   }
+  if (bl !== undefined) problems.push(...blinkHoldProblems(BLINK.shut, BLINK.hold, IDLE_FPS));
   // ---- blink.still: a blinking region cut at a row ----------------------
   const stills = bl?.still ?? {};
   const partNames = new Set(parts.parts.map((p) => p.name));
@@ -307,7 +381,8 @@ export function buildRig(cfg: CharacterConfig, parts: PartsFile, images: Readonl
   const motion = idleMotion(cfg, chains);
   const meshBones = new Set<string>();
   for (const segs of meshSegments.values()) for (const s of segs) meshBones.add(s.bone);
-  const controls = controlledBones(motion, meshBones);
+  const meshKeyed = controlledBones(motion, meshBones);
+  const controls = idleKeys === 'ctl' ? meshKeyed : [];
   for (const k of controls) {
     const ctl = `${k}${CONTROL_SUFFIX}`;
     if (B.has(ctl)) {
@@ -440,7 +515,8 @@ export function buildRig(cfg: CharacterConfig, parts: PartsFile, images: Readonl
     slots,
     skins: { default: skin },
   };
-  return { rig, motion, meshReport, images: outImages, controls, loopPasses };
+  if (idleKeys === 'direct' && meshKeyed.length > 0) rig.invariants = { idleDrivesMeshes: { why: IDLE_DRIVES_MESHES_WHY } };
+  return { rig, motion, meshReport, images: outImages, controls, meshKeyed, idleKeys, loopPasses };
 }
 
 /**