spine-rigc 0.16.0 → 0.18.0

package/docs/FACE.md

@@ -245,6 +245,167 @@ shape the drawing only implies. Two readings that help:
    measured 5.406 on the artifact. If the fringe does not read as separate,
    this is the one number to move, and moving it moves nothing else.
 
+### 2.1 One depth per part, and the limit of that
+
+Everything above states **one depth per part** — a stand-off the whole plate
+shares. That is the right resolution for a part list: the fringe is 26 in front
+of the skull, and arguing about which *pixel* of the fringe is 26 would be
+arguing past what the drawing says.
+
+It stops being the right resolution the moment a part's own surface is the
+subject. §4 meshes the face plate into columns precisely because the plate is not
+flat, and §4.2 then finds that refining those columns makes the fold **worse**,
+not better — the columns are sampling a cylinder that was never the shape of a
+face. A cylinder is one number pretending to be a surface, and past a certain
+density the pretence is what fails.
+
+⭐ **Two things had to arrive together, and both are now generated rather than
+written.** The lattice itself was hand-numbered — this example's 25 vertex pairs,
+32 triangles and hull walk were a person's arithmetic — and
+[AUTHORING §3.4](AUTHORING.md#grid--a-lattice-over-the-part-window)'s `grid`
+generator now builds it from the column positions alone, reproducing this one
+exactly. That is the prerequisite: a turn needs interior vertices to move, and
+§4.3's contour has none.
+
+⭐ **And a depth map is the number above becoming a surface.** A greyscale sheet in the
+part's own pixel grid gives every mesh vertex its own `z`, sampled where the
+vertex actually is, and `yaw`/`pitch` project off it with the same closed form as
+§1 — only the source of `z` changes. What it buys is stated where it is authored:
+[AUTHORING §3.4](AUTHORING.md#depth--give-every-vertex-its-own-z-instead-of-one-cylinder-radius),
+with the sampling order, the refusals and the one that matters most (a sheet cut
+to the art covers **none** of a contour mesh's vertices, because they all sit on
+the silhouette and outside it).
+
+⭐ **And the mesh really is evaluating the pixels' model — measured, not
+asserted.** A consumer that renders the same sheet in a shader displaces every
+PIXEL by its own depth; a mesh displaces vertices and interpolates across
+triangles. On a dome (a ramp would prove nothing — linear interpolation is exact
+on a linear field) at 18°, the two evaluations converge as the lattice refines:
+
+| lattice | 3×3 | 5×5 | 9×9 | 17×17 | 33×33 |
+| --- | --- | --- | --- | --- | --- |
+| mean disagreement, px | 6.4141 | 1.8452 | 0.5887 | 0.2276 | **0.0926** |
+| the same lattice reading a **cylinder** instead | 3.8972 | 3.1628 | 3.2558 | 3.3429 | **3.3777** |
+
+🚨 **Read the second row before the first.** A mesh evaluating the wrong surface
+does not converge — it settles at ~3.4px however dense it gets — and at 3×3 it
+reads *better* than the right one. So one measurement at one density cannot tell
+the two models apart, and would have picked the wrong one. The claim is the
+convergence, never a single number. (`CS01`–`CS03` in `selftest.ts`; the worst
+case falls more slowly than the mean and is expected to, because the dome's rim
+has an unbounded depth gradient.)
+
+⚠️ **This is not the same quantity as §4.2's fold angle, which refining makes
+WORSE.** Both are true: a finer lattice buys fidelity to the model and costs the
+angle at which a column pair inverts. This measures the first; `A39` refuses the
+second.
+
+⚠️ **It does not make depth measurable.** The map is relative — 8 bits of level
+say nothing about world units — so `zScale` is authored exactly as the fringe's
+26 was, and the two warnings above survive intact: get it right and the parallax
+is free, get it wrong and nothing complains. What the map removes is the
+*resolution* limit, not the judgement.
+
+### 2.2 The angle belongs to the map, not to the mesh
+
+§2.1 leaves an open question and it has now been measured. §4.2 finds that
+refining the lattice makes the fold **worse**, and read that as the cylinder's
+error surfacing — so per-vertex depth ought to have bought the angle back. ⛔ **It
+does not, and it never could have.**
+
+Two neighbouring vertices swap places when the turn tips one past the other,
+which is `tan t ≥ Δu/Δz` — so the largest turn a part supports is
+
+    tan t_max = 1 / max |dz/du|
+
+**the reciprocal of the steepest slope anywhere in its depth map**, and there is
+no mesh in that formula at all. Refining the lattice does not change the angle;
+it changes which slopes the lattice is close enough to *find*. A map with a
+vertical edge has an infinite slope there, so a fine enough mesh folds at any
+angle you name.
+
+⭐ **Which is exactly what a dome is.** `z = Z√(1 − r²)` is vertical at its rim,
+and an even lattice over it folds at `tan t = √h·√(R/2)/Z` for spacing
+`h = W/(side−1)` — a **√h** that goes to zero. Measured against that closed form
+over a 1,300× range of vertex counts, agreeing to ≤ 1.2°:
+
+| lattice | 5×5 | 17×17 | 33×33 | 65×65 | 129×129 | 181×181 |
+| --- | --- | --- | --- | --- | --- | --- |
+| **dome**, largest turn admitted | 62° | 41° | 31° | 23° | 17° | **14°** |
+| the closed form above | 59.0° | 39.8° | 30.5° | 22.6° | 16.4° | **14.0°** |
+| **raised cosine**, slope bounded | 73° | 65° | 64° | 64° | 64° | **63°** |
+| its closed form, `atan(2R/Zπ)` | 64.8° | 64.8° | 64.8° | 64.8° | 64.8° | **64.8°** |
+
+⇒ **Author the map so its slope is bounded, and the angle stops depending on the
+mesh.** A raised cosine — flat at the centre, flat again at the rim — holds
+63–64° from 289 vertices to 32,761. The dome loses three quarters of its angle
+over the same refinement. Both are "correct" depth; only one of them is a
+*surface a turn can be built on*, and the difference is entirely in the input.
+
+🚨 **So a map traced straight off a rendered normal or a photogrammetry pass is
+the dome case, not the cosine case.** Where the part curves away to its
+silhouette is where every such map goes vertical. Flattening it there — letting
+z reach its floor *before* the outline rather than at it — is the edit that buys
+the angle, and it is an edit to the sheet. rigc will not do it for you: the
+compiler never invents a value that is not in the spec, and a depth map is a
+measurement.
+
+⚠️ **This does not touch §2.1's convergence.** A finer lattice still evaluates
+the map's own surface more faithfully; it also finds steeper slopes in it. Those
+are two different quantities and both are true — §2.1 measures the first, `A39`
+refuses the second. What is new here is that the second is a fact about the
+sheet, and can be fixed there.
+
+⭐ **And you no longer have to find the ceiling by building into it.** `build`
+and `explain` print it for any mesh with a depth map — per axis, per direction,
+naming the triangle that goes first — from `tan t = A₀/A_axis` on the mesh's own
+geometry ([AUTHORING §3.4](AUTHORING.md)):
+
+```
+        turn ceiling  yaw +31.41° / -32.01°   pitch +32.01° / -31.41°
+          1st pct     yaw +31.55° x1.004 of 1004 / -32.10° x1.003 of 1044   pitch +32.10° x1.003 of 1044 / -31.55° x1.004 of 1004
+                      first to fold: yaw + at 31.41°, triangle 960 [113,112,593], the sheet steps 12.52 level(s) across it
+```
+
+Read it as a fact about **the sheet**. If the number is too small, the fix is in
+the map — flatten it where the part curves away — and not in the lattice.
+
+📐 Method, harness and the full ladders live in the repository rather than in
+this package, as
+[`bench/studies/2026-09-05-density`](https://github.com/firejune/rigc/tree/main/bench/studies/2026-09-05-density) —
+the same study also measures why `contour` is the wrong generator for a turn: it
+saturates at 868 vertices however fine the tolerance, its vertices all sit on the
+silhouette so it samples **2 %** of the depth range, and its ear-clipped interior
+holds triangles three orders of magnitude apart in area, the smallest of which
+reverse under a fraction of a pixel.
+
+🚨 **The sheet's grain is a slope too, and the ceiling reads it.** Because
+`max|dz/du|` is a maximum over sampled gradients, there is no averaging anywhere
+in it. On a sheet whose true ceiling is 64.77°, measured at 4,225 vertices:
+**±1 level** of noise reports 61.37°, **±8 levels** reports 45.34°, and **one
+stray pixel out of 160,000** reports 6.08° — and `A39` refuses at each of those
+angles, so the rig is as damaged as the report says. Refining the lattice makes
+every one of them worse. Two hard bounds follow, both independent of the form:
+a sheet can never report above `atan(255·h / zScale)` for cell size `h`, and
+below one texel per cell the answer saturates at the steepest adjacent-texel
+step. ⇒ **Author the sheet so it changes by at least ~8 levels across one mesh
+cell**, and spend its whole 0–255 range on the part — a map using an eighth of
+the range describes the same surface and reports 5.8° less of it. Method and
+ladders:
+[`bench/studies/2026-09-05-noise`](https://github.com/firejune/rigc/tree/main/bench/studies/2026-09-05-noise).
+
+⭐ **And you do not have to guess which of the two you are looking at.** The two
+lines under the ceiling say it ([#412](https://github.com/firejune/rigc/issues/412)):
+the **1st percentile over the ceiling** is near 1 when a band of the mesh reaches
+the limit together, which is a form, and near 10 when one triangle does, which is
+a texel — 1.003 against 10.652 for the two sheets above. The **depth step across
+the triangle that folds first**, in levels, is the other half: below about 3 the
+ceiling is quantisation, and at 1 it is `atan(255·h / zScale)` and carries nothing
+about the form at all. Both are reports and neither moves the ceiling — ⛔ rigc
+will not filter a depth map, because a smoothed measurement would describe a
+surface the deform key is not built from and `A39` would go on refusing at the
+raw angle. [AUTHORING §3.4](AUTHORING.md) has the reading table.
+
 ---
 
 ## 3. One shared shift, then residuals
@@ -478,6 +639,30 @@ above the 16° §8 calls the instrument's ceiling. ⇒ **Then let the last band
 single wide one** — that is the direction that buys safety, and it is the
 opposite of refining.
 
+🎭 **The fourth way out, and the one a Live2D-style face actually takes: stop
+drawing the part.** The ceiling only binds while the part is on screen, so a turn
+that has to go past it fades the far cheek or ear out — `rgba` to alpha 0 — or
+swaps the attachment away, and another part takes over. `A39` measures that: a
+deform key whose slot draws **no pixels at that key's own time** is passed over by
+name rather than refused, with the reason on the stats line and beside the key's
+own figures in the `DEFORM` block
+([#401](https://github.com/firejune/rigc/issues/401)). Two things it is not — the
+bar is alpha **exactly 0**, so a part faded halfway is still refused with the
+alpha in the message; and it is per key and per time, so the same slot folding at
+full alpha anywhere else is refused as before. ⛔ It is also not
+`invariants.deformMayFold`: that field turns the check off for the slot at every
+angle, including the ones where the part is fully visible.
+
+🚨 **Fade out *up to* the angle you cannot take, never *at* it — and the gate now
+keeps that rule rather than asking you to.** The runtime interpolates between
+keys, so an alpha-0 key landing exactly on the folding key leaves the frames just
+before it drawn and nearly folded (§9.2 measures it: 8 reversed triangles at
+alpha 0.20). `A39` scans the spans between consecutive keys as well and refuses
+one by name, at a time solved for in closed form and then posed and measured
+([#403](https://github.com/firejune/rigc/issues/403), AUTHORING §4.11.3). ⇒ The
+practical shape is unchanged and now checkable: **key the fade to 0 at or before
+the last angle that gates green, and let the fold happen after it.**
+
 📘 **The identity above, used forwards on a `pitch`.**
 [`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod)
 (repository material) picks its ceiling first and solves the *rows* out of it —
@@ -1018,6 +1203,77 @@ not a fold**: its winding survives. The angle A39 first fires at agrees with
 §4.2's `tan θ = Δx/Δz` to **0.0001°**, so the formula above is now checkable by
 running the gate instead of by rendering seven variants.
 
+🆕 **And one thing it stopped doing, on 2026-09-05
+([#401](https://github.com/firejune/rigc/issues/401)).** Build (b) is refused
+because the head is *drawn* while it folds. Fade that slot to alpha exactly 0 over
+the same keys — §4.2's fourth way out, and what a face past its ceiling actually
+does — and the same build is green, with the key still measured and the reason
+printed rather than passed over in silence:
+
+```
+  DEFORM  turn  default/head/head  key 1  t=0.500000  transform yaw  radius=170 degrees=40
+          skipped    A39 reads no winding off this key: the slot's alpha is exactly 0 at this
+                     time (slot 0.0000 x attachment 1.0000), so this key draws no pixels — a
+                     triangle that draws no pixels cannot draw them backwards
+          winding    24 of 32 kept, 0 collapsed  <- a fold, and nothing gates it: this key draws no pixels
+```
+
+`A39`'s message says the mesh "draws its texture backwards there", and that
+sentence is false when the slot draws nothing — the assertion was not too strict,
+it was measuring something other than what it said. The bar is **alpha exactly
+0**; at 0.5 build (b) is refused as before, with the alpha in the message. The
+same fold at full alpha in another animation is still refused, because the
+measurement is of one key at one time.
+
+🚨 **And the limit of that, measured rather than assumed: the gate read KEYS, and
+the geometry between two keys is interpolated.** Put the alpha-0 key exactly on
+the 40° key and 8 triangles are already reversed at `t=0.4`, where the slot is
+still drawing at **alpha 0.20**:
+
+| t | slot alpha | reversed triangles |
+| --- | ---: | ---: |
+| 0.30 | 0.40 | 0 |
+| 0.40 | **0.20** | **8** |
+| 0.45 | 0.10 | 8 |
+| 0.49 | 0.02 | 8 |
+| 0.50 | 0.00 | 8 |
+
+📌 The table and the refusal below are on the **turn probe** — this head's own
+five columns and 32 triangles on a one-second timeline, which is why the times
+are not build (b)'s. It is `selftest.ts`'s fixture, so the rows are reproduced by
+every run rather than transcribed once.
+
+🆕 **Closed on 2026-09-05
+([#403](https://github.com/firejune/rigc/issues/403)), and the shape of the fix
+is the reason it is here rather than in a paragraph of advice.** Every interval
+between two consecutive deform keys is scanned. A deform interpolated between two
+keys travels a **straight line through offset space**, so a triangle's signed
+area is a *quadratic in the interpolation fraction* — the fold is a root of it,
+solved for rather than searched, with no sample spacing anybody would have to
+defend. What that arithmetic names is then posed and measured by the same code
+that measures a key, **alpha read at that same instant**, so the fade a correct
+rig relies on is not refused and the frames it does not cover are:
+
+```
+FAIL  A39_DEFORM_KEEPS_TRIANGLE_WINDING: animation "turn" deform head/head BETWEEN key 0
+      (t=0s) and key 1 (t=0.5s), at t=0.444089s — 88.8% of the way from one to the other:
+      8 of 32 triangle(s) reverse winding … NO KEY LANDS THERE … at alpha 0.1118
+```
+
+⇒ The rule this section gave — *fade out over the run up to the angle you cannot
+take, so that every key past the ceiling is one that draws nothing* — is
+unchanged. What changed is that it is now a **measurement**: land the alpha-0 key
+on the fold and the build is refused, with the frame it is refused for.
+
+⚠️ **What that scan still cannot see**, stated because the limit moved rather
+than vanished: the closed form holds the BONES still across the span. On an
+unweighted attachment that is exact — one matrix multiplies every vertex and its
+determinant cancels out of the sign comparison — but on a weighted mesh whose
+bones move across the span it is an approximation, and a prediction no
+measurement reproduced is reported (`deformSpansUnconfirmed`) rather than
+refused. A fold caused by the bones alone is not this rule's subject at all, and
+`check` against a trusted render (§9.3) is what sees it.
+
 ⚠️ **One thing it deliberately does not do.** It is an **archetype** rule, so a
 `--profile spine` build reads `PROF` — the premise "a fold has no legitimate
 counter-example" turned out to be false when it was measured, an official

package/docs/MOTION.md

@@ -104,6 +104,11 @@ about.
 | **frame rate** | *"at 12 fps"* | ⛔ **do not adopt one.** Spine's times are seconds and frames exist only for convenience (AUTHORING §10.3), so a rate belongs to `render --fps` and to nothing in either spec file |
 | **pose-frame scale** | almost never stated | search the default window once, read the `search` block back, and narrow it if the answer sits at a window edge — §2.2 |
 
+📖 **A request in an animator's words — *"heavier"*, *"follow through"*, *"keep
+the volume"* — maps to a construct in §3.1.1's table.** Two of its rows are
+corrections rather than translations, so read it before assuming a word means
+here what it means elsewhere.
+
 ⚠️ **Read the intent adjectives before you read the pictures, and write down what
 you think they mean, in movement terms, before any measurement.** *"Snap"* means the
 extreme arrives early and the value settles late; *"heavy"* means the parts separate
@@ -270,6 +275,53 @@ it paraphrases.
 *unless the intent says otherwise*, exactly as AUTHORING §10 puts it, and the
 adjectives in §1 are what overrides them.
 
+### 3.1.1 The animator's words, in this vocabulary
+
+A request arrives in an animator's words — *"make it feel heavier"*, *"keep the
+volume when it lands"*, *"the cape should follow through"* — and this table is
+the map from those to the construct that carries them. §1's intent-adjective
+paragraph does this for three words; this is its full form.
+
+⚠️ **Two rows are corrections rather than translations**, and they are the
+reason the table earns its place: Spine's `Ease in`/`Ease out` mean the
+**opposite** of the web's, and a *moving hold* is not §3.3's *hold*. Both are
+words an agent already thinks it knows.
+
+Marks are §3.1's: 📗 stated on the linked page, 🧩 this guide's reading. Per
+cell, because most rows are a sourced word mapped to an unsourced construct.
+
+| The animator's word | What it means | rigc's construct |
+| --- | --- | --- |
+| **weight** — *"make it feel heavier"* | 📗 how an object answers a push: a light one reacts sooner than a heavy one ([twelve principles]) | 🧩 not one field. A longer `duration`, a slower attack on the leading `ease`, and **larger** offsets down §3.7's table — heavy is *parts separating in time*, which is what §1 already says the adjective means |
+| **timing** | 📗 how many frames an action takes, which is its speed ([twelve principles]) | 📗 `duration` and the key times, **in seconds** — frames exist for convenience only ([Keys]) · §3.3 |
+| **spacing** | 🧩 how far the value moves between one sampled frame and the next. Timing is *when the keys are*; spacing is *what happens between them* | 🧩 the `ease` on the key, not the key times. It has no field of its own — §2.1 sends you to the contact sheet because spacing is only visible across frames · §3.4 |
+| **slow in / slow out** | 📗 a body needs time to accelerate and to stop, so more drawings fall near each end ([twelve principles]) | 📗 a named entry in `easings` · §3.4. 🚨 **Spine's preset names invert the web's**: its *Ease out* changes more slowly near **the key**, its *Ease in* more slowly near **the next key** ([Graph]). An agent carrying the CSS meaning picks the opposite shape |
+| **arcs** | 📗 natural movement follows a curved path; straight lines read as mechanical ([twelve principles]) | 🧩 the **channel**, not a setting: `rotate` gives the arc free, `translate` draws the straight line. The question is never *arc or line*, it is *which channel carries this move* · §3.5 |
+| **anticipation** — *"wind up first"* | 📗 a small preparation that makes the action read ([twelve principles]) | 🧩 §3.6's interior key, the other way. 🚨 It goes **after** `t: 0` at L1/L2 — `t: 0` is a given condition, not a pose to move |
+| **follow-through** | 📗 loosely attached parts keep going after the body stops, then are pulled back ([twelve principles]) | 🧩 the trailing part's extreme lands later than its driver's **and overshoots once** — §3.7's last rows are that pull-back · §3.8 |
+| **overlapping action** — *"don't let it move as one piece"* | 📗 parts of a body move on different timings from one another ([twelve principles]) | 📗 in the editor it is literally *moving keys in time*, which is what the offset button is for ([Keys]). 🧩 here: a later extreme per bone, or `groups` + `stagger` where members share a value · §3.7 |
+| **drag** — *"it should lag"* | 📗 parts take a few frames to catch up when a body starts moving ([twelve principles]) | 🧩 the same offset applied at the **start** rather than at the stop. ⚠️ Convert the source's frames to a **fraction** of the duration — §3.7's offsets are fractions, so a 0.15 s snap and a 2 s idle share one table · §3.7 |
+| **the wave principle** | 📗 Esoteric's own framing: the thing to understand for tails, hair, cloth and flags — anything that follows through (video 4) | 🧩 the offset **compounding down a chain**, so the lag travels: `groups` + `stagger` where the members are a chain. ⚠️ **`wave` already names something else here** — a deform transform kind (AUTHORING §4.11.1) that ripples an attachment's vertices, not a chain's timing |
+| **squash and stretch** | 📗 what gives a drawing weight and flexibility ([twelve principles]); Spine notes the shear tool is used in small amounts for organic squash and stretch ([Tools]) | 🧩 two spellings. **Cheap:** a `scale` key whose two axes differ. **Full:** a `deform` timeline, which is what `gallery/squash` uses. §7 is rigid-first — land the movement, then deform · §4 |
+| **keeping the volume** | 📗 in *realistic* animation a squashed object keeps its volume: stretch it one way and it must narrow the other ([twelve principles]) | 🧩 `x·y ≈ 1` on a `scale` key, which `explain` now prints beside it, and the `area` figure a `deform` key already carried. **A reading, never a rule** — a shadow, a zoom and a cartoon squash all change area on purpose. ⚠️ Say *scale product* in a message: `volume` already means an event's audio and 4.3's `ScaleYMode.Volume` |
+| **overshoot and settle** | 📗 exaggeration — a motion that imitates reality exactly reads as dull ([twelve principles]) | 🧩 §3.8's interior key past the final value, then back. 🚨 The last key still carries the given end pose exactly |
+| **a moving hold** — *"it should never be fully still"* | 📗 a character that is barely moving still breathes; two nearly-identical poses keep it from going lifeless ([twelve principles]) | 🧩 **not** §3.3's *hold*, which is two EQUAL keys meaning *nothing moves here*. A moving hold is the opposite: §3.3's 1.5–3 s idle band with a small excursion — §0's A=B case |
+| **secondary action** | 📗 a supporting movement that emphasises the main one rather than competing with it ([twelve principles]) | 🧩 a whole extra timeline, and the **first thing to leave out of a first candidate**: a ballot spreading on both primary timing and a secondary action has asked two questions · §3.10 |
+| **pose to pose** vs **straight ahead** | 📗 the two ways animation is made — extremes first and fill in, or forward frame by frame ([twelve principles]) | 🧩 a keyframed skeleton can only do the first. Nothing in the format means *"and then draw the next frame"* — §3.2 |
+
+[twelve principles]: https://en.wikipedia.org/wiki/Twelve_basic_principles_of_animation
+[Keys]: http://esotericsoftware.com/spine-keys
+[Graph]: http://esotericsoftware.com/spine-graph
+[Tools]: http://esotericsoftware.com/spine-tools
+
+⚠️ **The eight *Animating with Spine* videos are the obvious source for this
+table and none of it comes from them.** Their captions could not be retrieved —
+the manifest is served and the body is not — so nothing here is presented as
+something said in one. Two rows cite a video's published *description*, which is
+Esoteric's own prose and marked as such; everything else is the twelve
+principles and Spine's written documentation. If the narration becomes readable,
+this table is where it belongs.
+
 ### 3.2 📗 Pose to pose is the normal form, and it is one of two
 
 Animation is publicly catalogued as being made either **straight ahead** — drawn

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Rig compiler for Spine — declarative rig specs in, Spine 4.3 skeleton data out, verified by a spine-core round-trip. Built so AI agents can author rigs and check their own work; the output imports into the Spine editor.",
   "type": "module",
   "bin": {
@@ -39,6 +39,7 @@
     "tools/contact.ts",
     "tools/png_probe.mjs",
     "tools/measure_contact_depth.ts",
+    "tools/editor_roundtrip.ts",
     "docs/AUTHORING.md",
     "docs/SPEC_COVERAGE.md",
     "docs/PROMPTING.md",

package/skills/motion/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: motion
-description: Author a Spine animation with rigc from key poses — an idle, a loop, a move from one picture to another — with timing, easing, anticipation, follow-through, and candidate variants a person can choose between. Use when the request is a movement on an existing or planned rig, such as "animate this rig", "make it breathe" or "go from pose A to pose B", including reading the poses out of reference frames. Not for Live2D, separating an image into parts, or motion capture and real-time tracking.
+description: Author a Spine animation with rigc from key poses — an idle, a loop, a move from one picture to another — with timing and spacing, ease in and out, anticipation, arcs, overlap, follow-through, squash and stretch, and candidate variants a person can choose between. Use when the request is a movement on an existing or planned rig, in the animator's words too: "animate this rig", "make it breathe", "go from pose A to pose B", "make it feel heavier", "the cape should follow through". Not for Live2D, separating an image into parts, or real-time tracking.
 license: MIT
 compatibility: Requires Bun 1.2 or later and the npm package spine-rigc.
 ---