spine-rigc 2.48.0 → 2.50.0

package/README.md

@@ -619,13 +619,13 @@ and `bun run fetch-examples`. The reasoning behind them is in
 [the benchmark dossier](https://github.com/rig-c/core/blob/main/docs/BENCHMARK.md).
 
 `build` and `validate` both default to `--profile spine` — the 35 validity rules, which
-ask *is this valid Spine 4.3 that any runtime plays correctly?* `--profile spine-html`
+ask *is this valid Spine 4.3 that any runtime plays correctly?* `--profile rig-play`
 adds all 51: the other 16 are one renderer's policy and one canvas budget's, and they
 fire on perfectly correct editor-produced Spine data, which is why they are opt-in.
 ⇒ **That reason is about foreign data and does not carry to a rig you are authoring
-yourself: author under `--profile spine-html` and read the extra 16 as findings, and
+yourself: author under `--profile rig-play` and read the extra 16 as findings, and
 gate the release under `--profile spine`.** A `deform` key that folds a mesh inside
-out is written out under the default and refused by name under `spine-html`, which
+out is written out under the default and refused by name under `rig-play`, which
 is the shape of what that split buys you. A report always names
 the profile it ran and lists what that profile left out.
 

package/docs/AUTHORING.md

@@ -239,7 +239,7 @@ What the flags mean:
 | `--manifest` | a cut manifest. Only for a rig with **measured art** behind it; a foreign skeleton has none |
 | `--cut` | `build`, `explain` and `validate`: look up a named cut in `--cuts <cuts.json>`, **instead of** `--rig`/`--motion`/`--out` — the two spellings are one build stated two ways and are refused together. A `cuts.json` is `{ "<name>": { "rig": …, "motion": …, "out": …, "manifest"?: … } }`, every path in it relative to the table's own file, so the table lives with the project that owns the art |
 | `--cuts` | the `cuts.json` `--cut` names. Required beside it — `--cut` alone is refused, with no guess at where the table lives |
-| `--profile` | `spine` = the 35 validity rules (**the default**) · `spine-html` = all 51, opt-in |
+| `--profile` | `spine` = the 35 validity rules (**the default**) · `rig-play` = all 51, opt-in. `spine-html`, the profile's former name, is read as `rig-play` until the next minor release and prints a deprecation line on stderr naming `rig-play` |
 | `--report` | `build` and `repack`: also write the gate's report as a JSON document (`build-report/1`) to this file — every gate's `PASS`, `SKIP` and `FAIL` rows, its summary figures and stats line, which supplier judged it, and every `pack:` line's figures. Written when the command writes `--out` and when a gate is red, before the exit; a file already at the path is removed first, so a compile error or a refused repack leaves none. Never inside `--out`, refused by name. The printed lines are byte-identical with it and without it — **§5.3** |
 | `--candidate` | `check`, `bench`, `render`, `inspect`, `preview`, `chainfit` and `vote` only: a **compiled** artifact — the directory `build --out` wrote, or a `skeleton.json` path. A directory holding no `skeleton.json`, or a path with nothing at it, is refused `nothing at <path>`, exit 2, nothing written, by every command that takes a build — `validate <dir>` and a directory given to `diff` included (`RC27`). `--atlas <path>` names the atlas when it does not sit beside the skeleton. On `render` and `check` a rigc build whose `skeleton.model.json` is `rigc-compiled/3` or `/2` needs no atlas at all: with no `--atlas` and no atlas beside it, it is drawn from the document's `pages`, the same frames, geometry and figures as with it, and the `atlas` line says `— not there`. An atlas that is there is still read, and held to `pages`: one that differs (edited after the build) is drawn through spine-core, and the `poser` line names the first difference. A build drawn through an atlas that is not there — a `rigc-compiled/1` document, or a build the core refuses — is refused `nothing at <the atlas>: … is drawn through its atlas (<why>)`, exit 2, nothing written; a Spine export without its atlas is refused `nothing at <the atlas>` as it always was. A directory whose files are not one build — a `skeleton.json` or a `skeleton.atlas` from another build beside this one's `skeleton.model.json` — is drawn through spine-core where the runtime can load the pair, the `poser` line naming the two digests or the atlas's first difference; where it cannot, it is refused `<skeleton> does not load against <the atlas>: spine-core draws this pair (<the poser line's why>) and could not resolve it — "<the runtime's own words>". <dir> is not one build: …`, exit 2, nothing written (`RC18`) — another build's skeleton beside this build's atlas typically ends `"Region not found in atlas: <region> (attachment: <name>)"`. Rebuild, or put the build's own three files back beside each other. A Spine export beside an atlas it was not exported with is refused in the same words, ending `The skeleton and the atlas are not one pair`. An atlas copied from another build's directory usually stops earlier, at its pages — their paths are relative to the directory it was written in — and is refused naming the first one: `nothing at <the page>: <the atlas> names it as a page, and spine-core draws this pair through that atlas (<why>). … <dir> is not one build: …`, exit 2, nothing written (`RC18`); an export whose atlas names a page that is not there is refused the same way, ending `and the page has to be there`. A build moved or copied whole away from the directory it was built in stops at the same place, on either poser, and is refused naming the page and the file that names it: `nothing at <the page>: <the skeleton.model.json> names it as a page, and the core draws this build from it. A page path is relative to the build's directory, so a build moved or copied away from the directory it was built in names pages that are not here — build it again where it is, or build it with --copy-images, which writes its pages beside it` (under `--poser spine`, `<the atlas> names it as a page, and spine-core draws this pair through that atlas (--poser spine)` with the same ending), exit 2, nothing written (`RC21`); only where the core refused the files does a page refusal say the directory is not one build. `bench --bones` and `rigc bonedist` — on its `--candidate` and on its `--reference` — refuse a pair the runtime cannot load in the words above with `spine-core poses this pair (bonedist's candidate: …)` or `(bonedist's reference: …)`, exit 2, nothing written (`RC20`); they read no page image, so a build whose pages are elsewhere is measured as it is in place. A `skeleton.json` that is not JSON is refused `rigc: cannot read <the file>: <the parser's words> (line N, column N)`, exit 2, by `render`, `check`, `bench` and `bonedist` as by every other command that reads one (`RC22`). With the atlas gone, `check` on a `rigc-compiled/3` build reads its pages' `scale:` lines off the document, so its texture note and `check.json`'s `textureFrom.candidateScales` are what they are with the atlas; on a `/2` build its texture note says whether the atlas declares a `scale:` line is not read (that document does not state one), and `candidateScales` is `null` (`RC13`). **`vote` and `preview` take it more than once**: `vote` 2–4 times, one per pane, labelled A, B, C, D in the order given; `preview` any number of times, one pane per candidate in the order given, each headed by its path and its gate line, and the same skeleton twice (a directory and its `skeleton.json` are one) is refused by name. `--atlas` goes with one candidate only. Everywhere else a repeat is a typo and is refused |
 | `--animation` | `render`, `preview` and `vote` only: which animation to show. The default is **every** one for `render`, the **first** for `preview` (each candidate's own first, with several), and for `vote` the first of candidate A. A name the skeleton does not have is refused, with the ones it does have listed — and for `vote` and a several-candidate `preview`, so is a name that only *some* candidates have, naming the one that lacks it |
@@ -306,7 +306,7 @@ reported `already linked`.
 
 Pick the profile deliberately, and know which one you got by saying nothing. The
 default is `spine`: "is this valid Spine 4.3 that any runtime plays correctly",
-which is the question a rig authored anywhere is asking. `--profile spine-html`
+which is the question a rig authored anywhere is asking. `--profile rig-play`
 adds one renderer's policy and one project's canvas budget on top, and those
 extra rules fire on perfectly correct Spine data (clipping attachments,
 unweighted meshes, packed atlases) — reach for it when you are shipping into
@@ -314,8 +314,8 @@ unweighted meshes, packed atlases) — reach for it when you are shipping into
 lists what that profile left out, on `PROF` lines.
 
 *Packed atlases* are in that list for what a page may hold, not for being packed:
-under `spine-html` a page is **one part per page OR a tiling page**, so `--pack
---profile spine-html` is an ordinary build — and it is the only one that puts the
+under `rig-play` a page is **one part per page OR a tiling page**, so `--pack
+--profile rig-play` is an ordinary build — and it is the only one that puts the
 renderer's own rulebook over shared-page sampling. What a *tiling* page has to
 satisfy under that profile is §5.2's `A49` row: no two regions on one page
 drawing over each other — refused where their rectangles overlap **and** their
@@ -600,7 +600,7 @@ what changes is that two rectangles may overlap where neither footprint is.
   against 155 and 44, all by 1, between their own `rect` packs under `pot` and
   `free`. No texel is read from a neighbour (that is three orders of magnitude
   louder, `PK06`).
-- **The gate reads footprints, not rectangles.** Under `--profile spine-html`
+- **The gate reads footprints, not rectangles.** Under `--profile rig-play`
   `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` refuses two regions on one page only
   where their rectangles overlap **and** what they draw overlaps — a mesh's
   hull (its UVs over the region's bounds; a linked mesh its source's), a region
@@ -928,7 +928,7 @@ report carries the rectangle to cut instead of leaving it to be derived:
 
 - `--atlas-in` cannot recover what a `scale:` quantised away (above), turned or not;
 - the **renderer** profile refuses a turned region outright
-  (`A06`, `--profile spine-html`), because that profile is about artifacts rigc
+  (`A06`, `--profile rig-play`), because that profile is about artifacts rigc
   itself emits and it never packs one turned. Reading a foreign pack and gating
   one under somebody else's renderer policy are different questions.
 
@@ -2057,7 +2057,7 @@ and the inheritance silently falls back to Normal — assertion `A02` refuses it
 | `bone` | required; must be a bone this rig declares | — |
 | `attachment` | the **setup pose** attachment name, or `null` for "show nothing" | must come from here or from `motion.setup` (R3) — **except** on a slot nothing fills, where it can only be `null` and may be left out |
 | `color` | `rrggbbaa` tint | opaque white |
-| `dark` | two-colour tint, `rrggbb`. The **setup** half; §4.4's `rgba2` and `rgb2` tracks key it over time and require it | — (🚫 `A12` under `spine-html`) |
+| `dark` | two-colour tint, `rrggbb`. The **setup** half; §4.4's `rgba2` and `rgb2` tracks key it over time and require it | — (🚫 `A12` under `rig-play`) |
 | `blend` | `normal` · `additive` · `multiply` · `screen`. Only the first letter's case is free: `Additive` reads as `additive`, while `ADDITIVE` or `mUlTiPlY` reads as **no mode** in the runtime with no error, so `build` refuses it by name (§5.1). Emitted as written | `normal` |
 
 ✅ **Every slot you declare is emitted, in this order.** A slot nothing fills — no
@@ -2119,7 +2119,7 @@ name no `image` — an empty `default`, or one carrying only a `boundingbox`, a
 with **no pages**, and rigc writes `skeleton.atlas` as an **empty file** (zero
 bytes). Four rules then report SKIP by name rather than a pass, because a page is
 their whole subject: `A07_ATLAS_TEXT_SHAPE`, `A06_ATLAS_PAGE_SIZE_MATCHES_PNG`,
-`A17_ATLAS_PAGE_FILES_EXIST` and — under `spine-html` —
+`A17_ATLAS_PAGE_FILES_EXIST` and — under `rig-play` —
 `A19_OVERLAY_PNGS_HAVE_ALPHA` and `A27_REGION_NAME_MATCHES_PAGE_FILENAME`.
 
 ⚠️ **This is not the case where an attachment WANTS a region.** A region or mesh
@@ -2458,8 +2458,8 @@ attachment rather than a second set of art.
 | `inverse` | default **false**. True makes everything **outside** the polygon visible instead of everything inside, and inverse clipping is always treated as convex (`ClippingAttachment.inverse`) |
 
 ⚠️ **A clipping attachment is refused by the renderer profile and by nothing
-else.** `A11_NO_CLIPPING_ATTACHMENTS` (§5.2) fires under `--profile spine-html`
-because that renderer skips clipping silently; it is one renderer's policy rather
+else.** `A11_NO_CLIPPING_ATTACHMENTS` (§5.2) fires under `--profile rig-play`
+because the renderer it was written for, spine-html 0.4.1, skipped clipping silently; it is one renderer's policy rather
 than anything about the data, and the default `spine` profile builds one.
 
 **Path** ([Spine: paths](http://esotericsoftware.com/spine-paths)) —
@@ -2562,7 +2562,7 @@ window off the attachment's own `image`; a `ring` and a `ribbon` are built from
 the numbers in this block and rigc compares neither to the PNG. The emitted
 `width`/`height` are this `size`, so a `size` that is not the art's own scales the
 drawing — measured: a 240x240 part declared `"size": [64, 64]` builds green under
-`--profile spine-html`. That is R1 rather than a gap: the compiler emits the
+`--profile rig-play`. That is R1 rather than a gap: the compiler emits the
 number the spec states and does not re-measure a plate to overrule it.
 
 ⭐ **Several grips split the ring by where the rig put them, on this route as on
@@ -3152,7 +3152,7 @@ one 96x64 plate of two islands under two two-link chains, `cell: 8`,
 The `influence` line is the falloff's report: the most bones any vertex binds
 (read it against `maxBones`), the mean, and how many vertices one bone owns
 outright. A named bone that **no** vertex binds is listed there by name — it is
-in no weight, so no other figure moves — and under `--profile spine-html`
+in no weight, so no other figure moves — and under `--profile rig-play`
 `A20_MESH_WEIGHTS_COHERENT` refuses it as a declared bone nothing binds. The
 `lattice` line says how many cells had art and how many were kept, and when
 islands were joined, how many and how many cells the join added. The coverage
@@ -4413,13 +4413,13 @@ attachment, rgba, rgb, alpha, rgba2, rgb2)`, §5.1's row.
   has one, so a file keying it without one parses cleanly and then throws in the
   player the first time the animation is applied. `A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN`
   (§5.2) holds the same pairing on a skeleton rigc did not write. 🚫 Both halves
-  of the two-colour tint are refused under `--profile spine-html`, whose renderer
+  of the two-colour tint are refused under `--profile rig-play`, whose DOM mode
   ignores them; the default `spine` profile that `build` runs reports `A12` as
   `PROF` and never applies it.
 - The six are every slot timeline the format has; anything else is refused
   here, and would be refused by the runtime's own reader too (`Invalid timeline
   type for a slot`). `A12_NO_DARK_COLOR` refuses `rgb2` — and `rgba2`, and the
-  slot field — in a file under the `spine-html` profile.
+  slot field — in a file under the `rig-play` profile.
   `sequence` is a timeline on an **attachment**, not on a slot — it is the
   family beside `deform`, §4.13.
 
@@ -4927,8 +4927,15 @@ that poses through its posers (`check`, `bonedist`, `inspect`, `--geometry`), ru
 the physics clock `2⁻³⁰` faster than the frames, so every such frame takes the steps
 exact arithmetic takes; the animation time is unchanged. A spring that has converged
 by the loop point therefore closes, which the loop-seam suite's `LS06` holds at all
-five rates. A player with a real clock is a different question and rigc does not
-answer it.
+five rates. A player that steps the core entry's live tracks at a fixed rate — a
+capture, an export, a test harness — is the render's case and takes the render's
+clock: `openTrack` and `openTracks` accept `clock`, what each step moves the physics
+clock by, and `physicsClockStep` (with `PHYSICS_CLOCK_LEAD`) is exported from
+`rig-c/core` to pass to it (issue #1396). It moves the physics alone — the track
+time, the animation time and the events stay on the steps, so the player keeps
+agreeing with `render` — and left out, a track steps the physics by the step itself,
+exactly as before. Which clock a player with a real clock uses is the player's
+question, and rigc does not answer it.
 
 `mix` is a player-side `AnimationStateData` config and is **not** emitted into
 skeleton JSON, so the parser is the only check it gets: it is
@@ -6478,7 +6485,7 @@ name or point the flag at the pack that has it.
 
 The report prints one line per assertion:
 
-**No run reproduces this:** assembled — one line of each verdict kind; the `PASS` and the `PROF` are verbatim from a `build` this page states, the `SKIP` is cut at the ellipsis and only `--profile spine-html` prints it, and the `FAIL` is invented, because a green build prints none
+**No run reproduces this:** assembled — one line of each verdict kind; the `PASS` and the `PROF` are verbatim from a `build` this page states, the `SKIP` is cut at the ellipsis and only `--profile rig-play` prints it, and the `FAIL` is invented, because a green build prints none
 ```
   PASS  A08_REGION_NAMES_MATCH_ATTACHMENTS
   SKIP  A21_MESH_RIM_PINNED: the skeleton has no weighted mesh attachment, …
@@ -6554,13 +6561,13 @@ Fix A00 and run it again.
 | <a id="A03_REGION_WIDTH_HEIGHT_FINITE"></a>`A03_REGION_WIDTH_HEIGHT_FINITE` | both | a region loaded `NaN` or a non-positive size — the attachment has no `image` and no `width`/`height`. **SKIP** when the skeleton carries no region attachment |
 | <a id="A04_MESH_TRIANGLES_AND_ENCODING"></a>`A04_MESH_TRIANGLES_AND_ENCODING` | both | authored mesh geometry: triangle count not a multiple of 3, an index out of range, or a `vertices` length that disagrees with `uvs` (the weighted/unweighted trap) **SKIP** when the skeleton carries no mesh attachment |
 | <a id="A05_CURVE_ARRAY_LENGTH"></a>`A05_CURVE_ARRAY_LENGTH` | both | a raw `curve` with the wrong number of values, a non-finite number in one, or a curve on a timeline that cannot take one. Four numbers **per value channel**. **SKIP** when no animation carries a timeline at all. Timelines with no `curve` on any key still PASS: every timeline name is checked against the channel table whether or not a curve sits on one Under `cli_core.ts build` the same clause runs over the text the emitter wrote and prints this line in the same words (`RC28`). |
-| <a id="A06_ATLAS_PAGE_SIZE_MATCHES_PNG"></a>`A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk — the message names the ratio it measured on **each** axis and the header that states the same art truthfully, and §0.2 has the whole of it: a runtime maps a region as a fraction of the DECLARED size and never reads the texture's own, so such a page draws, and what it breaks is every reader that addresses the page in texels. A uniform ratio is a `size:`/`scale:` pair away from honest and the message prints it; two ratios are not, because `scale:` carries one number, and the message says so rather than offering a header that would not work. **Or** a region's rectangle is not inside the page it names — rotation honoured, so a region at `rotate: 90` or `270` occupies `height x width` of the page and a region that fits only because it is turned is inside it. The message names the region, the rectangle it occupies, the page and the page's size. That clause is **validity** and runs under both profiles: a rectangle outside its page makes `u2 > 1` and samples whatever the wrap mode returns, and `--atlas-in` already refuses the same rectangle at compile time (§0.2). Under `spine-html` also: `pma` and rotation. Two regions on one page over the same texels was a clause here until issue #1099 and is `A49`'s now, read over what the two regions draw rather than over their rectangles. **Or** the page file is not a PNG at all, and then nothing about its size is measured: the message carries the page's path and the size the atlas declares, and names what the file is by its first bytes — one of WebP, JPEG, GIF, KTX, KTX2 by its signature, or no image format rigc recognises, the bytes in hex either way — or calls it **truncated** when it begins as a PNG and runs out before its `IEND`, or names the dimension when its `IHDR` states a width or height of **0**, which the format forbids (§0.2). **Or** the file reads as a PNG and its **image data cannot be decoded** — its compressed stream is inflated (not unfiltered) and the decoder refuses it, or it inflates short of the rows the header states — and the message names the file and carries the decoder's own words (`the decoder stops with "incorrect data check"`). That clause is validity too: nothing in rigc can read such a page back — and its failure is the **one** line that names such a page: `A19` SKIPs over it and points here rather than naming it again, the way `A17` alone names a missing file. **SKIP** when the atlas declares no page — and, rather than a PASS, when a page's file is **not on disk** and nothing else here failed: that page's size was not measured, so the reason names the pages not read (or says none was, when every file is missing) and points at `A17`, which fails naming each missing file — one missing file is named once, by the rule whose subject it is. With another `A06` failure standing, the missing page is `A17`'s alone |
+| <a id="A06_ATLAS_PAGE_SIZE_MATCHES_PNG"></a>`A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk — the message names the ratio it measured on **each** axis and the header that states the same art truthfully, and §0.2 has the whole of it: a runtime maps a region as a fraction of the DECLARED size and never reads the texture's own, so such a page draws, and what it breaks is every reader that addresses the page in texels. A uniform ratio is a `size:`/`scale:` pair away from honest and the message prints it; two ratios are not, because `scale:` carries one number, and the message says so rather than offering a header that would not work. **Or** a region's rectangle is not inside the page it names — rotation honoured, so a region at `rotate: 90` or `270` occupies `height x width` of the page and a region that fits only because it is turned is inside it. The message names the region, the rectangle it occupies, the page and the page's size. That clause is **validity** and runs under both profiles: a rectangle outside its page makes `u2 > 1` and samples whatever the wrap mode returns, and `--atlas-in` already refuses the same rectangle at compile time (§0.2). Under `rig-play` also: `pma` and rotation. Two regions on one page over the same texels was a clause here until issue #1099 and is `A49`'s now, read over what the two regions draw rather than over their rectangles. **Or** the page file is not a PNG at all, and then nothing about its size is measured: the message carries the page's path and the size the atlas declares, and names what the file is by its first bytes — one of WebP, JPEG, GIF, KTX, KTX2 by its signature, or no image format rigc recognises, the bytes in hex either way — or calls it **truncated** when it begins as a PNG and runs out before its `IEND`, or names the dimension when its `IHDR` states a width or height of **0**, which the format forbids (§0.2). **Or** the file reads as a PNG and its **image data cannot be decoded** — its compressed stream is inflated (not unfiltered) and the decoder refuses it, or it inflates short of the rows the header states — and the message names the file and carries the decoder's own words (`the decoder stops with "incorrect data check"`). That clause is validity too: nothing in rigc can read such a page back — and its failure is the **one** line that names such a page: `A19` SKIPs over it and points here rather than naming it again, the way `A17` alone names a missing file. **SKIP** when the atlas declares no page — and, rather than a PASS, when a page's file is **not on disk** and nothing else here failed: that page's size was not measured, so the reason names the pages not read (or says none was, when every file is missing) and points at `A17`, which fails naming each missing file — one missing file is named once, by the rule whose subject it is. With another `A06` failure standing, the missing page is `A17`'s alone |
 | <a id="A07_ATLAS_TEXT_SHAPE"></a>`A07_ATLAS_TEXT_SHAPE` | both | atlas text: a region name with stray whitespace, or a blank line splitting a page block. rigc writes the atlas, so this means a hand-edited file. Three sentences are about blank lines and name three different repairs: `line 1: the file begins with a blank line` (or `with N blank lines` for a run, one finding) is a blank before the first page name — delete it; `line N: the file ends with a blank line` (or `with N blank lines`, one finding) is a blank after the last page block's final line — delete it, since rigc ends the file on one newline; `line N: consecutive blank lines` is two blank lines side by side between the first page and the last — delete one. None of the three is `the last page block declares no region`, which means a page name and its fields with no region after them. rigc writes none of the three: under `--atlas-in` the pack's blank lines are put in rigc's shape on re-emission (§0.2), so any of them means a file rigc did not write, handed to `validate`. ⚠️ An atlas with **no page block at all** — no non-blank line — is not one of those: its subject is absent, so this reports **SKIP** naming the byte count it read, and so do the four rules below whose subject is a page ([#608](https://github.com/rig-c/core/issues/608)). A rig whose skins need no art writes exactly that file (§3.4), and before #608 this row refused it with two findings naming a page block that was not there. What an empty atlas does **not** excuse is an attachment that wants a region out of it — that is `A08` Under `cli_core.ts build` the same clause runs over the text the emitter wrote and prints this line in the same words (`RC28`). |
-| <a id="A08_REGION_NAMES_MATCH_ATTACHMENTS"></a>`A08_REGION_NAMES_MATCH_ATTACHMENTS` | both | three things, and the message says which: an attachment whose `path` names **no region** of this atlas; a `path` carrying **stray whitespace**, printed quoted so you can see it; an **atlas region name** carrying stray whitespace (`A07` names that same line with its line number). The first two are read off the raw file **before** the loader is asked, so the miss is named here with the skin, the slot, the placeholder and the attachment's own name — the four things `AtlasAttachmentLoader`'s own `Region not found in atlas: <path> (attachment: <name>)` does not carry. There is no `spine-html` clause here — a placeholder is free to differ from the region its `path` names **SKIP** when no attachment names a region *and* the atlas declares none — both of its subjects at once |
+| <a id="A08_REGION_NAMES_MATCH_ATTACHMENTS"></a>`A08_REGION_NAMES_MATCH_ATTACHMENTS` | both | three things, and the message says which: an attachment whose `path` names **no region** of this atlas; a `path` carrying **stray whitespace**, printed quoted so you can see it; an **atlas region name** carrying stray whitespace (`A07` names that same line with its line number). The first two are read off the raw file **before** the loader is asked, so the miss is named here with the skin, the slot, the placeholder and the attachment's own name — the four things `AtlasAttachmentLoader`'s own `Region not found in atlas: <path> (attachment: <name>)` does not carry. There is no `rig-play` clause here — a placeholder is free to differ from the region its `path` names **SKIP** when no attachment names a region *and* the atlas declares none — both of its subjects at once |
 | <a id="A09_ANIMATION_DURATION_MATCHES_SPEC"></a>`A09_ANIMATION_DURATION_MATCHES_SPEC` | both | the loaded duration ≠ the declared one, or the two sides disagree about which animations exist (R7). Asymmetric by design: a frame of slack for an animation that ends early, and none worth the name for a key *past* the declared end, which is the same rule §4.5 states at compile time — held here against a skeleton the compiler never saw. **SKIP** when neither side has an animation at all — a static rig has no duration |
 | <a id="A10_NO_NAN_AFTER_STEPPING"></a>`A10_NO_NAN_AFTER_STEPPING` | both | stepping the animation produced a pose that is not finite. It reads the **whole world transform** — all six terms `a`, `b`, `c`, `d`, `worldX`, `worldY` of every bone — then every vertex of every region and mesh the slots show, at the **setup pose** and at every stepped frame of every animation, through the same scan `render` refuses on, so the two cannot disagree. The detail names where (`the setup pose`, or `animation "x" frame i of 120 (t=…s)`), then the bone and the term (`bone "x" has a NaN`), or the slot, attachment and vertex (`vertex 3 has x Infinity`) when every bone is finite and a vertex is not — a `scaleX` chain whose product stays under the largest double does that. A bone at `rotation: 1e309` has a finite position and a `NaN` matrix, which is why the position alone is not read. Look for a number past the largest double, a degenerate curve or a zero scale. 🦴 **It also poses every bone `inherit` key at its own time**: the runtime resolves a mode by folding the case of its first letter and nothing else, and a spelling that misses is stored as **NaN** — the world position stays finite, `updateWorldTransform` matches no mode, and the bone keeps the rotation, scale and shear it had. The detail names the animation, the bone, the key's time and its spelling, beside the five. A bone whose *setup* spelling misses poses no mode at all, and is named the same way from the stepping loop. Neither is reachable from a rig spec — `build` refuses both spellings by name (§5.1) — so on a green build this clause is about files rigc did not write. Which mode a correct spelling poses is not judged here, because the lookup that resolved it is the one that would be checked. 🧍 **A skeleton with no animation is still read**: its setup pose is the whole of what it shows, so A10 reads it — the world transform and the vertices as above, and the bone's mode and the slot colours a stepped frame is read for, which on a static rig nothing else would reach — and names it `the setup pose` (`the setup pose: slot "x" colour is non-finite`). The stepping half had nothing, and a PASS row carries no detail, so the stats line says so: `nanStepping=skipped`, beside `animations=0`. `A09` does not follow — a declared duration is a fact about an animation and nothing else, so a static rig still gives it nothing. **SKIP** only when the skeleton carries **no bone and no animation**: there is then no pose to read and nothing to step |
 | <a id="A11_NO_CLIPPING_ATTACHMENTS"></a>`A11_NO_CLIPPING_ATTACHMENTS` | renderer | a clipping attachment; the target renderer skips them silently |
-| <a id="A12_NO_DARK_COLOR"></a>`A12_NO_DARK_COLOR` | renderer | a slot `dark` colour or an `rgba2`/`rgb2` timeline; parsed, then ignored |
+| <a id="A12_NO_DARK_COLOR"></a>`A12_NO_DARK_COLOR` | renderer | a slot `dark` colour or an `rgba2`/`rgb2` timeline; parsed, then ignored by rig-play's DOM mode. The rule is worded for that mode alone: rig-play's canvas mode carries `dark` on its frame, but no test of the player's holds that it draws it, so nothing here says it does |
 | <a id="A13_MESH_BUDGET"></a>`A13_MESH_BUDGET` | renderer | more mesh slots than the rig's `invariants.meshSlots`, or a mesh over its `invariants.meshTriangles`. Thin the mesh, or raise the budget in the rig spec. **SKIP** when the rig declares neither — which means *unmeasured*, not that the budget is inert: the same `meshSlots` is a **compile-time** refusal for rigc's own generators, before the gate (§3.7) **SKIP** also when the rig budgets **only** triangles and the skeleton carries no mesh. A declared slot budget still PASSes there, because zero mesh slots is a count measured against a ceiling |
 | <a id="A14_NO_FULL_FRAME_MESH"></a>`A14_NO_FULL_FRAME_MESH` | renderer | a mesh spans the whole stage — a full-frame canvas that can never dirty-skip. **SKIP** when the skeleton declares no stage (§3.1): there is no full frame to span, and *unmeasured* must not print the same green as *measured and clear* |
 | <a id="A15_IDLE_NO_MESH_BONE_KEYS"></a>`A15_IDLE_NO_MESH_BONE_KEYS` | renderer | the `idle` animation keys a bone that drives a mesh, directly or as a control bone. The rule assumes meshes are mostly static — the renderer skips redrawing a mesh nothing moved — so it has three states. **FAIL per bone** when the rig declares nothing: `idle keys bone "X", which drives a mesh — meshes never idle-skip`, and the **first** of those lines, once per run, names the case: `K bone(s) keyed by idle drive meshes; if this idle is meant to deform them (a painting rig), declare invariants.idleDrivesMeshes: { "why": … } in the rig spec — or, where the motion belongs to a pivot above the mesh, key that pivot one link up (FACE.md §3)`. It rides the first finding, so the count of FAIL lines is still the count of bones. **SKIP with the cost** when the rig declares `invariants.idleDrivesMeshes` (§3.7): `declared by the rig ("<why>"): idle keys N bone(s) that drive M mesh attachment(s) totalling V vertices — "a", "b" — and each of those meshes is recomputed on every frame it is shown`. **FAIL on a stale declaration** — declared, and the `idle` keys no mesh-driving bone, carries no bone timeline or does not exist: `the rig "X" declares invariants.idleDrivesMeshes ("…"), but "idle" keys no bone that drives a mesh, so the declaration switches off nothing — remove it`. Otherwise **SKIP** when there is no `idle` animation, or when the one there is carries no bone timeline — a rule whose subject does not exist is unmeasured and not satisfied |
@@ -6568,7 +6575,7 @@ Fix A00 and run it again.
 | <a id="A17_ATLAS_PAGE_FILES_EXIST"></a>`A17_ATLAS_PAGE_FILES_EXIST` | both | a page the atlas declares is not a file. Check `--images` and `--out`. This is the one rule that names a missing page file; `A06` and `A19` SKIP over the page they could not read and point here rather than naming it again. **SKIP** when the atlas declares no page — as it is for `A06`, `A19` and `A27`; see `A07` |
 | <a id="A18_DETERMINISTIC_EMIT"></a>`A18_DETERMINISTIC_EMIT` | both | a second compile of the same inputs differed — in `skeleton.json`, `skeleton.atlas` or the model document `skeleton.model.json`, the one named (the document's first differing line with it). That is a compiler bug, not a spec bug — report it Under `cli_core.ts build` the same clause runs over the text the emitter wrote and prints this line in the same words (`RC28`). |
 | <a id="A19_OVERLAY_PNGS_HAVE_ALPHA"></a>`A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part cannot draw a transparent pixel, so it would paint a solid rectangle over what is behind it. **The texels decide, on both routes**; the file header is only the fast negative. A file with no alpha channel (colour type 4 or 6) and no `tRNS` chunk has nowhere to keep a clear texel and is refused without being opened, by a sentence that names its colour type — so re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. A file whose header says it **could** be transparent is opened and read until its first texel below full alpha; one clear texel passes, and none is refused in the words the packed route uses for a region, naming the file and what it can hold — `is opaque in every one of its 200x80 texels` … `its file can hold transparency — colour type 6 (truecolour + alpha) carries an alpha channel — and no texel uses it`. Saving as RGBA is not the repair: the runtime draws the texels, not the declaration. On a loose page the file is the part, so the whole decoded image is the rectangle and no atlas coordinate is read. Only the base plate may be opaque, and which image that is is decided once for both routes: the plate the build names — on a cut manifest, the part whose window is the crop — and, only when it names none, an image at least the stage's size. The rig's statement comes first because the two can disagree: a stage stated small enough for an overlay to cover would otherwise exempt that overlay. A rig spec cannot name a base plate, so a stageless rig-spec build, and `validate <dir>` on a stageless skeleton, has nothing to decide it; an opaque part there is refused with *"nothing here decides which image that is: this skeleton declares no stage size to measure one against"* and the two ways to decide it — a `skeleton` stage the plate covers, or a cut manifest (for `validate`, the specs it was built from: `--rig`, `--motion` and the `--manifest`). On a rig-spec build the sentence goes on *"this skeleton declares no stage size to measure one against, and the build names no base plate"* and offers *"build from a cut manifest, whose base plate is the part whose window is the crop"*; a manifest build exempts the plate it names, with a stage or without one. Indexed-with-`tRNS` — the usual output of ImageMagick, "Export as PNG-8", GIMP's indexed mode, aseprite and pngquant — **passes**: it is transparent art. On a **shared** page the question is asked per REGION over the decoded page rather than per file, because a packed page's own file all but always declares transparency — its gutter is transparent — and the file-level question would then be answered by the packing rather than by the art. ⚠️ **That scan states its verdict over the texels it READ, and never over texels that are not on the page**: a rectangle partly on its page is judged over the part that is on it, and the message carries both counts — `opaque in every one of the 77 texels of its 12x8 rectangle at -1,-1 … the other 19 of the 96 it declares are not on the page and are not measured here`. A rectangle with **no** texel on the page is reported **not measured** by name — the region, its rectangle, the page image's size, and the pointer to `A06`, which is the rule that judges a region's rectangle — and no verdict about opacity is printed at all. ⚠️ **A page whose IMAGE is not the size the atlas declares for it is the same non-measurement for every region on it**, and the clause above does not cover that case: a page rescaled after packing leaves most rectangles partly on it, at coordinates that address a different part of the picture, so a scan would come back with a confident verdict over texels nobody had located — on a two-region pack at a uniform 0.5 an opaque part's failure **disappears**, the scan finding a transparent texel 32 texels away from it. The row names the page's two sizes and points at `A06`, which judges the page grid and prints the header that repairs it (§0.2). It stays a failure rather than becoming a SKIP because a SKIP is per ASSERTION: it would delete the verdicts on every other part of the same page, and an assertion cannot be skipped and failed at once without the report counting it twice. **SKIP** when the atlas declares no page — and, rather than a PASS, when a page carrying a part was not read and nothing else here failed: the reason names the pages not read and how many of the pages carrying a part were (or says none was), and for each page points at the one rule that names its file — `A17` when the file is **not on disk**, `A06` when it is on disk and **cannot be read as PNG** (not a PNG, truncated, an `IHDR` dimension of 0, or image data that does not decode; `A06` fails naming what the file is on every such page, under both profiles). Undecodable data is found where this rule decodes, so the header's fast negative above still refuses a part with no alpha channel and no `tRNS` without opening it — a verdict about the header, not about the pixels. So one unreadable file is one red line, never two: with another `A19` failure standing, the unread page is that rule's alone and this one says nothing about it. A page holding only the base plate moves nothing here, missing or unreadable: this rule had no part on it to read. |
-| <a id="A20_MESH_WEIGHTS_COHERENT"></a>`A20_MESH_WEIGHTS_COHERENT` | both ◑ | a weighted vertex with no bone, a negative weight, a bone index out of range, or weights that do not sum to 1. On a rig spec's `"boneIndexing": "raw"` mesh an index out of range or a run that does not decode is refused at compile first (§5.1, issue #917), so here it names a skeleton rigc did not compile. Under `spine-html` also: an unweighted mesh, a binding at weight 0, or **a bone the mesh declares that no vertex binds** — `mesh "x" declares bone "grip_b" and none of its 25 vertices binds it; the weights reference "box", "grip_a"`. Those three are one sentence about rigc's own generators: the bone set a generated mesh declares is the bone set its weights reference, so a `controls` or `chain` name that moves nothing is a defect where a foreign mesh's is not. Fix the rig spec's `controls`/`chain`, a `segments` generator's `bones` (its `influence` line names a bone no vertex binds), or the manifest's `control_bones`. **SKIP** when the skeleton carries no mesh attachment |
+| <a id="A20_MESH_WEIGHTS_COHERENT"></a>`A20_MESH_WEIGHTS_COHERENT` | both ◑ | a weighted vertex with no bone, a negative weight, a bone index out of range, or weights that do not sum to 1. On a rig spec's `"boneIndexing": "raw"` mesh an index out of range or a run that does not decode is refused at compile first (§5.1, issue #917), so here it names a skeleton rigc did not compile. Under `rig-play` also: an unweighted mesh, a binding at weight 0, or **a bone the mesh declares that no vertex binds** — `mesh "x" declares bone "grip_b" and none of its 25 vertices binds it; the weights reference "box", "grip_a"`. Those three are one sentence about rigc's own generators: the bone set a generated mesh declares is the bone set its weights reference, so a `controls` or `chain` name that moves nothing is a defect where a foreign mesh's is not. Fix the rig spec's `controls`/`chain`, a `segments` generator's `bones` (its `influence` line names a bone no vertex binds), or the manifest's `control_bones`. **SKIP** when the skeleton carries no mesh attachment |
 | <a id="A21_MESH_RIM_PINNED"></a>`A21_MESH_RIM_PINNED` | archetype | a generated ring's rim, a ribbon's entry row, or a contour's outline (which is all of it) is not pinned to its anchor bone at weight 1. **SKIPs** by name on authored or linked geometry and on a `segments` mesh, whose outline is weighted by distance like the rest of it — none of them claims a pinned rim |
 | <a id="A22_MESH_UVS_IN_UNIT_RANGE"></a>`A22_MESH_UVS_IN_UNIT_RANGE` | both | a mesh UV outside its region, or a UV array that disagrees with the vertex count. **SKIP** when the skeleton carries no mesh attachment |
 | <a id="A23_PHYSICS_CONSTRAINT_EFFECTIVE"></a>`A23_PHYSICS_CONSTRAINT_EFFECTIVE` | both | a physics constraint that drives no component, rests at `mix: 0` with **no timeline in any animation keying that `mix` above 0**, has `mass: 0`, has `strength` at or below 0 — `0` says `nothing pulls it back`, below 0 says the offset `is pushed away and grows with every step`, both read off the row's `outside` arms, which the key's refusal quotes too — or has `damping` outside `[0, 1]`, which says `` physics "C" has damping 1.5; must be inside [0, 1] — the per-step decay is `damping ** (60 * step)`, and the runtime runs this value finitely, so refusing it is rigc's call rather than the runtime's: above 1 every velocity grows on every step and the offset diverges ``, the bound read off the row the key's refusal reads; `1` and `0` are inside, since both are finite at every rate — **at rest, and on every physics timeline key**. The timeline arm reads each key through the runtime's own `PhysicsConstraint*Timeline.set`, so a keyed `mass` is judged as the `massInverse` it becomes, and the detail names the animation, the constraint, the key time, the value and the bound. Two differences between the two arms, and the runtime is the reason for both: a **key** of `mix: 0` is accepted, because `update` opens with `if (mix === 0) return;` and muting a constraint for a stretch is what a mix timeline is for — the editor's own `sack-pro` example keys it there on 24 of its 36 mix keys — and a **key** of `strength: 0` is accepted, because it releases the constraint for the span with `damping` and `inertia` still applied and the next key pulls the offset back, measured through spine-core at no NaN, a coast to a limit and a return in 54 steps. As a **setup** value `strength: 0` is still refused by the arm above, and `mix: 0` is refused only when nothing keys it above 0. The `mix` branch above is why `mix` is the one setup value a key can answer for: at rest the constraint is **inert** rather than broken, so a rig that rests muted and is keyed above 0 is refused by nothing, while a rig resting at `mass: 0` is `massInverse` Infinity before anything plays and no key reaches back into that. The detail of the refusal says both halves and how many animations were searched: `` physics "C" has mix 0 and none of the 3 animations keys its mix above 0; the runtime runs this value finitely, so refusing it is rigc's call rather than the runtime's: at 0 `update` returns before it does anything (`PhysicsConstraint.js:109-111`), so the constraint is muted — rest it above 0, or key its mix above 0 in an animation ``. ⚠️ Every reason A23 prints for a setup value is that value's row `basis` arm (§4.4's table) — an arithmetic arm names its expression (`physics "C" has massInverse Infinity; mass must be > 0 — at 0 …`), a behavioural one says it is rigc's call and what the value does. A setup `mix` **below** 0 is told the jiggle is applied inverted, not that it is muted: such a constraint is measured moving its bone by exactly the opposite of a positive mix. The search counts the unnamed global timeline for every constraint whose own `mixGlobal` is set, reads each key through the runtime's accessor, counts every sample of a Bezier between two keys as a value the timeline poses — so two keys of 0 joined by a curve lifted above 0 are a rescue, measured to move the bone — and takes an animation a slider applies like any other. It is the one reading `A36` and `A37` use as well. `inertia`, `wind`, `gravity` and the top of `mix` are bounded nowhere, at rest or keyed. `ingest` does not carry a constraint that drives no component into the spec it writes: it omits it with its timelines and reports `PHYSICS_DRIVES_NOTHING` ([INGEST §2.0](INGEST.md)), so this sentence is met on a file, never on a decompiled rebuild. 🦴 **A lever drive on a bone with no lever** (issue #1195): a constraint driving `rotate`, `shearX` or `scaleX` on a bone whose `length` is 0 (or states none) is refused, at rest, with one sentence per reading. `rotate` and `shearX` chase the bone's tip, so with no tip the solver aims the bone at a **world** direction — measured through rigc's poser on a chain held still for 3 s, a length-0 bone turns 53.204° from a 90° rest and holds there, where length 0.01 moves 0.0000: `` physics "C" drives rotate on bone "B" whose length is 0 — with no tip the solver aims the bone at world angle 0 and holds it there; give "B" a length or drive x/y instead ``. The rest angle is not read: a bone resting at world 0° does not move, but only until a key or a parent turns it. `scaleX` divides the motion along the bone by its length and adds nothing at 0, so the drive does nothing: `` physics "C" drives scaleX on bone "B" whose length is 0, which the solver divides the motion by, so it drives nothing; give "B" a length ``. Fix in the **rig spec**: give the bone its `length` (§3.2), measured off the art it carries, or, for the first sentence, drive the constraint in `x`/`y` in the **motion spec** instead. `x` and `y` read the bone's origin and never its tip, so a constraint driving only those on a length-0 bone is not refused; the editor's own example exports carry them there. The Spine editor's export drops `rotate`, `scaleX` and `shearX` from a physics constraint on a zero-length bone and keeps them on any bone with a length — measured on 4.3.23 and 4.3.26, issue #1196 — so what this clause refuses is also what the editor would silently lose. **SKIP** when the skeleton declares no physics constraint — the same sentence `A36` and `A37` print for their own constraint types |
@@ -6731,7 +6738,7 @@ Two more limits that are not errors but will shape what you can attempt:
 1. `build --profile <the one you meant>` exits 0 and the report has **no FAIL**.
    Saying nothing means `spine`, so "the one you meant" is a decision either way —
    the report's first line names the profile that judged it.
-   📎 The two profiles judge attachment **naming** identically: `spine-html` adds
+   📎 The two profiles judge attachment **naming** identically: `rig-play` adds
    the renderer and archetype rules and has no opinion about how an attachment is
    spelled, so a rig whose named skins share a placeholder (§3.4.9) is green
    under either.
@@ -6752,7 +6759,7 @@ Two more limits that are not errors but will shape what you can attempt:
 3. Read the `PROF` lines. They are where "was this rig held to that rule at all"
    gets answered for everything the profile left out — the renderer policy *and*
    the archetype rules. A green under `spine` has been held to neither; a green
-   under `spine-html` has been held to both.
+   under `rig-play` has been held to both.
 4. Run `explain` and read the slots table: every slot you declared **is** there
    (§3.3 — `A26_SLOT_DRAW_ORDER` holds that, and a slot nothing fills reads
    `setup=null attachments=[]`), so what this step is for is the two things the

package/docs/FACE.md

@@ -539,7 +539,7 @@ which `rigc explain` prints as a parent column (§9.2).
 ⭐ **The same reasoning puts the head's pivot one link above the mesh.** A head
 rotates about the top of the neck, not about the middle of its own face, so the
 roll belongs on a `headroll` bone above `head`. There is a rule that enforces it
-under `--profile spine-html`: `A15_IDLE_NO_MESH_BONE_KEYS` refuses an `idle` that
+under `--profile rig-play`: `A15_IDLE_NO_MESH_BONE_KEYS` refuses an `idle` that
 keys a bone driving a mesh — its own slot bone or its control bone — because that
 renderer must never idle-skip a mesh. Keying the pivot one link up satisfies it,
 and **the rig that satisfies the assertion is the better rig anyway.**
@@ -852,7 +852,7 @@ in the experiment came close to that ratio.
 
 ⚠️ **A `clipping` attachment would lift the iris's travel ceiling and you cannot
 have one.** Spine has them (AUTHORING §3.4) but `A11_NO_CLIPPING_ATTACHMENTS`
-refuses one under `--profile spine-html`, so a rig carrying one builds on only one
+refuses one under `--profile rig-play`, so a rig carrying one builds on only one
 of the two profiles. The ceiling is then geometric: in the worked example the
 iris's ink ring has radius 28.5 against a socket opening 36 half-wide, so
 `36 − 28.5 = 7.5` units is as far as it can travel before it crosses its own lash.
@@ -1473,7 +1473,7 @@ bun install                                     # once
 
 bun cli.ts build --rig gallery/portrait/rig.json \
                  --motion gallery/portrait/motion.json \
-                 --out gallery/portrait/build --profile spine-html
+                 --out gallery/portrait/build --profile rig-play
 bun cli.ts render --candidate gallery/portrait/build --fps 25 --max 640 \
                  --out gallery/portrait/render
 ```
@@ -1481,8 +1481,8 @@ bun cli.ts render --candidate gallery/portrait/build --fps 25 --max 640 \
 ```
   MESH  head         authored 25 vertices / 32 triangles  (budget 32)  bones=[head]  attachments=[head]  covers 100.00% of the art, reaching 95.90px past it
   MESH  hair_bang    authored 15 vertices / 16 triangles  (budget 32)  bones=[bang]  attachments=[hair_bang]  covers 100.00% of the art, reaching 55.22px past it
-  ..    validate (spine-core round trip + machine assertions, profile spine-html)
-  ..    profile spine-html — every assertion applies
+  ..    validate (spine-core round trip + machine assertions, profile rig-play)
+  ..    profile rig-play — every assertion applies
 ```
 
 Green — the profile line above says so in the tool's own words.
@@ -1515,7 +1515,7 @@ for (const k of d.keys) if (k.transform) {
 await Bun.write("/tmp/swapped.motion.json", JSON.stringify(m, null, 2));
 '
 bun cli.ts build --rig gallery/portrait/rig.json --motion /tmp/swapped.motion.json \
-                 --out /tmp/swapped --profile spine-html
+                 --out /tmp/swapped --profile rig-play
 
 # (b) FOLD IT: evaluate the same closed form at 40°, past the 31.37° of §4.2,
 #     so the two far columns swap order and the mesh turns inside out. Since
@@ -1527,23 +1527,23 @@ for (const k of d.keys) if (k.transform) k.transform.degrees = 40;
 await Bun.write("/tmp/folded.motion.json", JSON.stringify(m, null, 2));
 '
 bun cli.ts build --rig gallery/portrait/rig.json --motion /tmp/folded.motion.json \
-                 --out /tmp/folded --profile spine-html
+                 --out /tmp/folded --profile rig-play
 ```
 
 **What comes back from both:**
 
 | | good | (a) one band inverted | (b) mesh folded |
 | --- | --- | --- | --- |
-| `--profile spine-html`, **without `A39`** | green | **green, and the same counts** | **green, and the same counts** |
+| `--profile rig-play`, **without `A39`** | green | **green, and the same counts** | **green, and the same counts** |
 | `A35_DEFORM_KEYS_FIT_THE_ATTACHMENT` | PASS | **PASS** | **PASS** |
 | the `MESH` coverage line | 100.00%, 95.90px past | **byte-identical** | **byte-identical** |
 | `A39_DEFORM_KEEPS_TRIANGLE_WINDING` | PASS | PASS | **FAIL, both keys, 8 of 32 triangles** |
-| `--profile spine-html`, **with `A39`** | green | green | **refused, and nothing written** |
+| `--profile rig-play`, **with `A39`** | green | green | **refused, and nothing written** |
 | the `DEFORM` block, `head` key 1 `area` | x0.637174 … x1.319122 | **x0.765250 … x1.362834** | **x−0.288121 … x1.820211** |
 | … and its `winding` | 32 of 32 kept | 32 of 32 kept | **24 of 32 kept** |
 
 🚨 **All three were green, and the coverage line is the same string in all three,
-because it reports the SETUP pose.** The `--profile spine-html` row with `A39` is
+because it reports the SETUP pose.** The `--profile rig-play` row with `A39` is
 the only verdict that separates them, and the two rows above it measure only the
 setup geometry: `A35` is silent about build (b). `A35` checks that a deform run *fits* its
 attachment — an honest and useful check, and orthogonal to whether the numbers in
@@ -1609,7 +1609,7 @@ bun cli.ts explain --rig gallery/portrait/rig.json \
 legitimate counter-example is the fold, which is `A39`'s.
 
 **`A39_DEFORM_KEEPS_TRIANGLE_WINDING` closes the half of that gap the fold
-lives in** — `--profile spine-html`. Build (b) above is refused
+lives in** — `--profile rig-play`. Build (b) above is refused
 by name, on both its keys, with the triangles listed:
 
 ```
@@ -1711,7 +1711,7 @@ bun cli.ts check --candidate /tmp/folded            --frames gallery/portrait/re
 ```
 
 ⚠️ **The third of those needs a build §9.2's own command will not write.** Build (b)
-under `--profile spine-html` is refused and nothing
+under `--profile rig-play` is refused and nothing
 lands in `/tmp/folded` — which is the row above it in §9.2's table, working. Take
 that candidate from the **default** profile, where `A39` reads `PROF` and the
 artifact is written — a profile selects which assertions apply and not what is
@@ -1840,7 +1840,7 @@ it come off:
 
 `spine` is the default, so that is the `build` above with no `--profile` on it —
 the report names what the profile leaves out rather than this page counting it.
-§9.2 runs the same rig under `--profile spine-html` and quotes what comes back
+§9.2 runs the same rig under `--profile rig-play` and quotes what comes back
 there; `A13_MESH_BUDGET` and `A15_IDLE_NO_MESH_BONE_KEYS` are among the rules
 the default profile excludes.
 

package/docs/INGEST.md

@@ -1000,12 +1000,12 @@ other one is this project's own renderer and archetype policy.
 | **archetype policy** (8) | `A21_MESH_RIM_PINNED`, `A24_AXIS_SPACE_STROKE`, `A25_DETACHED_BONE_PARENTAGE`, `A26_SLOT_DRAW_ORDER`, `A28_RIBBON_ROWS_SHARE_WEIGHTS`, `A29_STROKE_WITHIN_CONTACT_DEPTH`, `A30_STROKE_WITHIN_CAP_CONTAINMENT`, `A39_DEFORM_KEEPS_TRIANGLE_WINDING` |
 
 Two further rules — **`A06`** and **`A20`** — are *mixed*: their validity clauses run
-in both profiles and their policy clauses only under `spine-html`. `A06`'s
+in both profiles and their policy clauses only under `rig-play`. `A06`'s
 size-vs-PNG check is validity; rotation and premultiplied alpha are policy (two
 regions over the same texels was a policy clause of `A06` until it became `A49`). `A20`'s weight coherence is validity; requiring a mesh to be
 weighted at all is policy.
 
-⚠️ **`--profile spine-html` on foreign data produces a wall of failures that mean
+⚠️ **`--profile rig-play` on foreign data produces a wall of failures that mean
 nothing about the file.** Same `spineboy-pro.json`, same atlas, one flag changed — the
 run ends `rigc: 13 assertion(s) failed`, and this is the tally with one real message
 per rule — `A06` takes a page that is one part covering it exactly *or a tiling of
@@ -1019,7 +1019,7 @@ regions*, so a packed atlas passes both profiles and the wall is policy only:
 
 Every one of those is a correct statement about a correct file: a bone *does* key a
 mesh, a mesh *is* unweighted, a clipping attachment *is* present.
-⇒ **Do not run `spine-html` against
+⇒ **Do not run `rig-play` against
 somebody's export unless they asked whether it satisfies this project's renderer
 policy**, which is a different question from whether their file is valid.
 
@@ -1264,7 +1264,7 @@ something is invisible to every measure in that report. Pair it with a `check` a
 frames rendered from the original.
 
 ⚠️ **Do not rename toward what a rule seems to want.** `A27`'s
-region-name-matches-page-filename is `spine-html` policy (§3.3): under the default
+region-name-matches-page-filename is `rig-play` policy (§3.3): under the default
 profile it does not fire, and renaming somebody's attachments to satisfy a policy they
 never opted into is a change with no benefit to them.
 

package/docs/RIGGING.md

@@ -572,7 +572,7 @@ The same rig keys `headroll` and never `head`: *"a head rotates about the top of
 neck, not about the middle of its own face."* A renderer policy assertion
 (`A15_IDLE_NO_MESH_BONE_KEYS`, AUTHORING §5) forced that answer independently — two
 arguments, one bone. ⚠️ **It is a renderer rule, so like §10.3's `A25` it only fires
-under `--profile spine-html`**; under `--profile spine` it reports `PROF` and the
+under `--profile rig-play`**; under `--profile spine` it reports `PROF` and the
 structural argument is the only one you get. [FACE.md](FACE.md) §3 is the same bone
 from the mesh's side.
 
@@ -1201,7 +1201,7 @@ Declare the pair in `invariants.detached` (AUTHORING §3.7) and it fires:
 
 ```bash
 rigc build --rig detached.rig.json --motion stack.motion.json --images parts \
-           --out det --profile spine-html
+           --out det --profile rig-play
 ```
 
 ```
@@ -1414,7 +1414,7 @@ rigc build --rig stack.rig.json --motion stack.motion.json --images parts --out
 #  ..    pages=4 regions=4 bones=6 slots=5 animations=4 version=4.3.13 …  profile=spine
 ```
 
-✅ It is green under **both** profiles, so `--profile spine-html` is available for
+✅ It is green under **both** profiles, so `--profile rig-play` is available for
 §10.3 without any unrelated failure in the report.
 
 ### The three variants the sections build

package/package.json

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

package/skills/rigc-face/SKILL.md

@@ -37,7 +37,7 @@ names the reversed triangles with their signed areas. `invariants.deformMayFold`
 in the rig spec is the one declared exemption, so reach for it when the slot
 folds on purpose and never to quiet a refusal you have not read. It is an
 **archetype** rule: a `--profile spine` build prints `PROF` for it and says
-nothing about the fold, so author under `--profile spine-html`.
+nothing about the fold, so author under `--profile rig-play`.
 
 What `A39` still cannot say is whether the projection was the right one —
 nothing measures whether 12° was the angle the shot wanted. FACE §9.2 is that

package/src/assertions/bodies/a06.ts

@@ -1,7 +1,7 @@
 /**
  * A06, the body (issue #1025, step 4c of #380): every page the atlas names is
  * the size its PNG is, every region lies inside its page, and — under
- * `spine-html` — no page claims premultiplied alpha and no region is turned.
+ * `rig-play` — no page claims premultiplied alpha and no region is turned.
  * The clause that refused two regions on one page overlapping is
  * `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` since issue #1099 (`./a49.ts`).
  *

package/src/assertions/bodies/a12.ts

@@ -1,6 +1,9 @@
 /**
  * A12, the body (issue #1025, cut 4c-4 of #380): no dark colour and no
- * two-colour timeline — both parsed, then silently ignored by spine-html.
+ * two-colour timeline — both parsed, then ignored by rig-play's DOM mode.
+ * Only the DOM mode is named (issue #1277): rig-play's canvas mode carries
+ * `dark` on the frame, but no test of the player's draws it, so nothing here
+ * says it is drawn there.
  *
  * Moved out of `src/validate.ts` unchanged but for what it reads: the slots
  * are a fact (`../facts/skeleton_roster.ts`) and the slot timelines are A45's
@@ -16,14 +19,14 @@ import type { SlotTimelines } from '../facts/slot_colour.ts';
 export function a12NoDarkColor({ fail }: Verdicts, { slots }: SkeletonRosterFacts, slotTimelines: readonly SlotTimelines[]): void {
   for (const slot of slots) {
     if (slot.dark) {
-      fail('A12_NO_DARK_COLOR', `slot "${slot.name}" declares a dark colour; the renderer ignores it`);
+      fail('A12_NO_DARK_COLOR', `slot "${slot.name}" declares a dark colour; rig-play's DOM mode ignores it`);
     }
   }
   for (const { animation, slot, timelines } of slotTimelines) {
     for (const [name, keys] of Object.entries(timelines)) {
       if (!Array.isArray(keys)) continue;
       if (name === 'rgba2' || name === 'rgb2') {
-        fail('A12_NO_DARK_COLOR', `${animation}.slots.${slot}.${name}: two-colour timeline "${name}" is silently ignored by the renderer`);
+        fail('A12_NO_DARK_COLOR', `${animation}.slots.${slot}.${name}: two-colour timeline "${name}" is ignored by rig-play's DOM mode`);
       }
     }
   }

package/src/assertions/bodies/a19.ts

@@ -145,7 +145,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
     // ⭐ Who names it is read off the two bodies, not chosen. Both ask
     // `readPngHeader` (`pngProblem`, the one reader of a page's identity) the
     // same question about the same file, A06 runs under both profiles and this
-    // rule under `spine-html` alone, and A06 FAILs on every page for which it
+    // rule under `rig-play` alone, and A06 FAILs on every page for which it
     // answers with a problem — so on every input that reaches this branch, A06
     // has already named the file and the report is red. A FAIL here would be
     // the second naming and a PASS a certificate over alpha nobody read, so
@@ -246,7 +246,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
               `${region.y} is not where "${region.name}"'s texels are on this file and this rule states ` +
               'nothing about whether it can draw a transparent pixel. The page grid is ' +
               "A06_ATLAS_PAGE_SIZE_MATCHES_PNG's to judge, and it names the ratio and how to declare the page " +
-              'honestly. This is renderer policy, and it belongs to --profile spine-html: the default ' +
+              'honestly. This is renderer policy, and it belongs to --profile rig-play: the default ' +
               '--profile spine does not run this check.',
           );
         }
@@ -280,7 +280,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
               `${plate.width}x${plate.height}, so it states nothing about whether "${region.name}" can draw a ` +
               "transparent pixel. A region's rectangle is A06_ATLAS_PAGE_SIZE_MATCHES_PNG's to judge, and one " +
               'that runs off its page is refused there by name. This is renderer policy, and it belongs to ' +
-              '--profile spine-html: the default --profile spine does not run this check.',
+              '--profile rig-play: the default --profile spine does not run this check.',
           );
           continue;
         }
@@ -298,7 +298,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
           'A19_OVERLAY_PNGS_HAVE_ALPHA',
           `part "${region.name}" is opaque in ${over}, so it would paint a solid rectangle over whatever is ` +
             `drawn behind it. Re-export the part with transparency and pack again. ${exemption} This is ` +
-            'renderer policy, and it belongs to --profile spine-html: the default --profile spine does not run ' +
+            'renderer policy, and it belongs to --profile rig-play: the default --profile spine does not run ' +
             'this check.',
         );
       }
@@ -316,7 +316,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
           `(${colourTypeName(info.colourType)}) with no tRNS chunk, so it would paint a solid rectangle over ` +
           'whatever is drawn behind it. Re-export it with transparency — as RGBA, or as an indexed or greyscale ' +
           `PNG that keeps its tRNS chunk. ${exemption} This is renderer policy, and it belongs to --profile ` +
-          'spine-html: the default --profile spine does not run this check.',
+          'rig-play: the default --profile spine does not run this check.',
       );
       continue;
     }
@@ -352,7 +352,7 @@ export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atla
       `part image "${page.name}" is opaque in every one of its ${plate.width}x${plate.height} texels, so it ` +
         `would paint a solid rectangle over whatever is drawn behind it: its file can hold transparency — ${holds} ` +
         '— and no texel uses it. Re-export the part with the transparency it is meant to have. ' +
-        `${exemption} This is renderer policy, and it belongs to --profile spine-html: the default --profile ` +
+        `${exemption} This is renderer policy, and it belongs to --profile rig-play: the default --profile ` +
         'spine does not run this check.',
     );
   }

package/src/assertions/bodies/a20.ts

@@ -1,7 +1,7 @@
 /**
  * A20, the body (issue #1025, step 4c of #380): a weighted mesh's weights
  * cohere — every vertex bound, every weight finite and non-negative, every
- * vertex's weights summing to 1 — and, under `spine-html`, a generated mesh is
+ * vertex's weights summing to 1 — and, under `rig-play`, a generated mesh is
  * weighted, binds only bones that move it and binds every bone it declares.
  *
  * Moved out of `src/validate.ts` clause by clause, every clause about the
@@ -72,7 +72,7 @@ export function a20MeshWeightsCoherent({ fail, skip }: Verdicts, { meshes, bones
         // In a rigc-GENERATED ring or ribbon it is still a defect: the
         // generator bound a bone that does nothing, which is a bug in the
         // generator and dead work in the runtime's inner loop. So it stays a
-        // failure under spine-html and is not one under spine.
+        // failure under rig-play and is not one under spine.
         else if (policy && generated && weight === 0) {
           fail(
             'A20_MESH_WEIGHTS_COHERENT',

package/src/assertions/emitted/index.ts

@@ -22,7 +22,7 @@
  *
  * Links nothing from the runtime.
  */
-import { ASSERTION_KIND, type AssertionProfile } from '../kinds.ts';
+import { ASSERTION_KIND, resolveProfile, type AssertionProfile } from '../kinds.ts';
 import { verdictHarness, type VerdictLists } from '../harness.ts';
 import { MOVED_ASSERTIONS } from '../model/index.ts';
 import type { Verdicts } from '../harness.ts';
@@ -125,7 +125,9 @@ export function roundTripOnlyCodes(): string[] {
 }
 
 /** The restated rules over one build's emitted texts, in `validate()`'s report shape. */
-export function validateEmittedText(input: EmittedTextInput): VerdictLists & { profile: AssertionProfile } {
+export function validateEmittedText(given: EmittedTextInput): VerdictLists & { profile: AssertionProfile } {
+  // A former profile name reads as its profile (issue #1277), for the rules and the report alike.
+  const input: EmittedTextInput = { ...given, profile: resolveProfile(given.profile, 'the emitted text') };
   const known = new Set(EMITTED_TEXT_RULES.map((r) => r.code));
   const unrun = roundTripOnlyCodes().filter((code) => !known.has(code));
   if (unrun.length > 0) {

package/src/assertions/harness.ts

@@ -18,7 +18,7 @@
  * This module links nothing from the runtime, directly or through what it
  * imports — the condition for the model side to use it, held by the selftest.
  */
-import { kindRunsUnder, type AssertionKind, type AssertionProfile } from './kinds.ts';
+import { kindRunsUnder, resolveProfile, type AssertionKind, type AssertionProfile } from './kinds.ts';
 
 /** One failure: the assertion's code and the sentence naming the object, the value found and the value required. */
 export interface Failure {
@@ -75,6 +75,10 @@ export interface VerdictHarness extends VerdictLists {
  * the table lacks — `validate` for the gate, so its message is the one it was.
  */
 export function verdictHarness(profile: AssertionProfile, kinds: Readonly<Record<string, AssertionKind>>, who: string): VerdictHarness {
+  // A former name resolves to its profile and anything outside the pair is
+  // refused by name — `resolveProfile` says why. The entries resolve before
+  // they get here, so this is the floor for a caller of the harness itself.
+  profile = resolveProfile(profile, who);
   const failures: Failure[] = [];
   const passed: string[] = [];
   const skipped: VerdictLists['skipped'] = [];

package/src/assertions/kinds.ts

@@ -12,7 +12,32 @@
  */
 
 /** The two rulebooks — `ValidateProfile` in `src/validate.ts`, where the choice between them is argued. */
-export type AssertionProfile = 'spine' | 'spine-html';
+export type AssertionProfile = 'spine' | 'rig-play';
+
+/**
+ * A profile's former name, which the CLI's `--profile` still reads for one
+ * minor and resolves at parse time, printing the deprecation line that names
+ * the profile it reads as (issue #1277). Nothing past the flag parser sees an
+ * alias: the rule set is keyed on the profile it resolves to, so the alias and
+ * its target cannot come to run different rules.
+ */
+export const PROFILE_ALIASES: Readonly<Record<string, AssertionProfile>> = { 'spine-html': 'rig-play' };
+
+/**
+ * The profile a gate entry runs under: a profile as given, a former name as the
+ * profile it became — silently, because the CLI prints the deprecation line and
+ * a library caller of `validate()` through a courtesy key passed the former
+ * name on the release before this one and must get the same rules — and
+ * anything else refused by name. `kindRunsUnder` reads every name but
+ * `rig-play` as validity-only, so an unresolved name would run a weaker gate in
+ * silence, under a name nobody chose (issue #1277).
+ */
+export function resolveProfile(profile: string, who: string): AssertionProfile {
+  if (profile === 'spine' || profile === 'rig-play') return profile;
+  const target = Object.hasOwn(PROFILE_ALIASES, profile) ? PROFILE_ALIASES[profile] : undefined;
+  if (target !== undefined) return target;
+  throw new Error(`${who}: profile ${JSON.stringify(profile)} is not a profile; the profiles are "spine" and "rig-play"`);
+}
 
 /** The three kinds a rule can be; the table's own comment says what each means. */
 export type AssertionKind = 'validity' | 'renderer' | 'archetype';
@@ -100,7 +125,7 @@ export const ASSERTION_KIND: Readonly<Record<string, AssertionKind>> = {
   A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS: 'validity',
 };
 
-/** Whether `profile` runs a rule of `kind`: `spine` runs validity alone, `spine-html` every kind. */
+/** Whether `profile` runs a rule of `kind`: `spine` runs validity alone, `rig-play` every kind. */
 export function kindRunsUnder(kind: AssertionKind, profile: AssertionProfile): boolean {
-  return kind === 'validity' || profile === 'spine-html';
+  return kind === 'validity' || profile === 'rig-play';
 }

package/src/assertions/model/index.ts

@@ -37,7 +37,7 @@
  * Links nothing from the runtime, directly or through what it imports — held
  * by the selftest's `VF` controls.
  */
-import { ASSERTION_KIND, type AssertionProfile } from '../kinds.ts';
+import { ASSERTION_KIND, resolveProfile, type AssertionProfile } from '../kinds.ts';
 import { verdictHarness, type VerdictHarness, type Verdicts, type VerdictLists } from '../harness.ts';
 import { SKIP_NO_ATLAS, SKIP_NO_MODEL } from '../reasons.ts';
 import { a03RegionWidthHeightFinite } from '../bodies/a03.ts';
@@ -294,7 +294,7 @@ export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.meshes(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
   { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.meshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.meshes(read), supply.animatedBones(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
-  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'rig-play', supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
   { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
@@ -313,7 +313,7 @@ export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', run: (v, read, _input, supply) => a44LinkedMeshStatesNoGeometryOfItsOwn(v, supply.links(read)), unread: SKIP_NO_MODEL },
   { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
   { code: 'A17_ATLAS_PAGE_FILES_EXIST', run: (v, read, input, supply) => a17AtlasPageFilesExist(v, supply.atlasPages(read), input), unread: SKIP_NO_ATLAS },
-  { code: 'A06_ATLAS_PAGE_SIZE_MATCHES_PNG', run: (v, read, input, supply) => a06AtlasPageSizeMatchesPng(v, supply.atlasRegions(read, input), input, input.profile === 'spine-html'), unread: SKIP_NO_ATLAS },
+  { code: 'A06_ATLAS_PAGE_SIZE_MATCHES_PNG', run: (v, read, input, supply) => a06AtlasPageSizeMatchesPng(v, supply.atlasRegions(read, input), input, input.profile === 'rig-play'), unread: SKIP_NO_ATLAS },
   { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), { atlasDir: input.atlasDir, rig: supply.rigInfo(read, input) }), unread: SKIP_NO_ATLAS },
   { code: 'A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP', run: (v, read, input, supply) => a49PackedFootprintsDoNotOverlap(v, supply.atlasRegions(read, input), supply.regionJoins(read), supply.meshes(read)), unread: SKIP_NO_ATLAS },
   { code: 'A50_STAGE_BOX_IS_THE_STAGE', run: (v, read, _input, supply) => a50StageBoxIsTheStage(v, supply.stageBox(read)), unread: SKIP_NO_MODEL },
@@ -389,7 +389,9 @@ function rigFigures(stats: Record<string, number | string>, read: ReadDocument |
  * prints. `plant` replaces a family's supplier; only the selftest's plants
  * pass one.
  */
-export function validateModel(input: ModelValidateInput, plant: Partial<ModelSupply> = {}): ModelReport {
+export function validateModel(given: ModelValidateInput, plant: Partial<ModelSupply> = {}): ModelReport {
+  // A former profile name reads as its profile (issue #1277), for the policy switches and the report alike.
+  const input: ModelValidateInput = { ...given, profile: resolveProfile(given.profile, 'the model side') };
   const supply: ModelSupply = { ...MODEL_SUPPLY, ...plant };
   const h = verdictHarness(input.profile, { ...ASSERTION_KIND, ...MODEL_PARSE_KIND }, 'the model side');
   const { read, held } = parse(h, input.modelText);

package/src/assertions/report.ts

@@ -10,7 +10,18 @@ import type { AssertionProfile } from './kinds.ts';
 import type { VerdictLists } from './harness.ts';
 import { failLine } from '../guide.ts';
 
-export const VALIDATE_PROFILES: readonly AssertionProfile[] = ['spine', 'spine-html'];
+export const VALIDATE_PROFILES: readonly AssertionProfile[] = ['spine', 'rig-play'];
+
+/**
+ * The line `--profile <alias>` prints on stderr before the command runs: the
+ * old name, the profile it reads as, and the flag to pass instead (issue
+ * #1277). Stderr so a report on stdout reads the same whichever name the
+ * caller typed; the report itself names the profile that judged it, which is
+ * the target and never the alias.
+ */
+export function profileAliasLine(alias: string, target: AssertionProfile): string {
+  return `rigc: --profile ${alias} is deprecated and reads as --profile ${target}, the same rules; it is accepted until the next minor release — pass --profile ${target}`;
+}
 
 /**
  * What the CLI uses when `--profile` is absent — and ONLY the CLI. This is not
@@ -21,7 +32,7 @@ export const VALIDATE_PROFILES: readonly AssertionProfile[] = ['spine', 'spine-h
  * into the Spine editor", which is exactly the question `spine` asks, and a
  * stranger's first build was being judged instead against one renderer's policy
  * and one project's canvas budget — 14 rules they have no stake in, with the
- * escape hatch documented only in prose. Defaults beat prose. `spine-html` is
+ * escape hatch documented only in prose. Defaults beat prose. `rig-play` is
  * still one flag away, and every report names the profile that judged it.
  */
 export const CLI_DEFAULT_PROFILE: AssertionProfile = 'spine';

package/src/atlas.ts

@@ -553,7 +553,7 @@ export interface EmitPage {
  * against the unturned pack. But on neither rig did a turn shrink the page: both
  * were already on the smallest power-of-two page their area allows, and a turn
  * that buys no area only moves bytes. Shipping it would also need two clauses
- * changed that say rigc never turns a region — `A06`'s under `spine-html`
+ * changed that say rigc never turns a region — `A06`'s under `rig-play`
  * ([`src/validate.ts`](validate.ts)) and `artUvsOf`
  * ([`src/render.ts`](render.ts)), which returns no art UVs for a turned region
  * attachment, so `check`'s texture substitution would report it unmatched.

package/src/cli/shared.ts

@@ -26,10 +26,11 @@ import {
   CLI_DEFAULT_PROFILE,
   type GateHere,
   type PackPageFigures,
+  profileAliasLine,
   VALIDATE_PROFILES,
 } from '../assertions/report.ts';
 import type { VerdictLists } from '../assertions/harness.ts';
-import type { AssertionProfile } from '../assertions/kinds.ts';
+import { PROFILE_ALIASES, type AssertionProfile } from '../assertions/kinds.ts';
 import { MAX_CANDIDATES, MIN_CANDIDATES } from '../ballot.ts';
 import { BONEDIST_SPEC, IDENTITY_CORRESPONDENCE } from '../correspondence.ts';
 import { ANCHOR_MAX_RESIDUAL, ANCHOR_MAX_UNEXPLAINED, DEFAULT_HINGE_MAX, DEFAULT_HINGE_MIN, DEFAULT_MIN_LEVER_PX, DEFAULT_MIN_VISIBLE, DEFAULT_PASSES } from '../chainfit.ts';
@@ -988,7 +989,7 @@ const FLAG_MEANINGS: Record<string, string> = {
   cuts: 'the cuts.json --cut names',
   profile:
     'which rulebook to check against (default: spine) — spine = valid Spine 4.3 that any runtime plays ' +
-    "correctly; spine-html = also this project's renderer/archetype policy",
+    "correctly; rig-play = also this project's renderer/archetype policy",
   atlas: "the candidate's atlas, when it is not beside the skeleton",
   reference: 'the reference skeleton to pose beside the candidate — a directory or a skeleton.json path',
   'reference-atlas': "the reference's atlas, when it is not beside the reference skeleton",
@@ -1179,7 +1180,7 @@ const FLAG_VALUES: Record<string, string> = {
   manifest: '<path>',
   cut: '<name>',
   cuts: '<path>',
-  profile: 'spine|spine-html',
+  profile: 'spine|rig-play',
   atlas: '<path>',
   'atlas-in': '<file.atlas>',
   'page-size': '<px>',
@@ -1324,7 +1325,7 @@ export const COMMANDS: CommandDoc[] = [
       for: 'the gate round-trips every build through it before anything is written',
       core: {
         usage: [
-          'rigc build --rig <path> --motion <path> --out <dir> [--manifest <path>] [--images <dir>] [--profile spine|spine-html] [--copy-images] [--report <file>]   (the same files the round-tripped build writes; gated without spine-core — see build --help)',
+          'rigc build --rig <path> --motion <path> --out <dir> [--manifest <path>] [--images <dir>] [--profile spine|rig-play] [--copy-images] [--report <file>]   (the same files the round-tripped build writes; gated without spine-core — see build --help)',
           `rigc build … --pack [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon]   (parts onto shared pages, written into --out)`,
           'rigc build … --atlas-in <skeleton.atlas>                    (resolve the parts against a pack somebody already made)',
           'rigc build --cut <name> --cuts <cuts.json>',
@@ -1348,7 +1349,7 @@ export const COMMANDS: CommandDoc[] = [
     },
     spineFormat: true,
     usage: [
-      'rigc build --rig <path> --motion <path> --out <dir> [--manifest <path>] [--images <dir>] [--profile spine|spine-html] [--copy-images] [--report <file>]',
+      'rigc build --rig <path> --motion <path> --out <dir> [--manifest <path>] [--images <dir>] [--profile spine|rig-play] [--copy-images] [--report <file>]',
       `rigc build … --pack [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon]   (parts onto shared pages, written into --out)`,
       'rigc build … --atlas-in <skeleton.atlas>                    (resolve the parts against a pack somebody already made)',
       'rigc build --cut <name> --cuts <cuts.json>',
@@ -1378,8 +1379,8 @@ export const COMMANDS: CommandDoc[] = [
       for: 'the rebuild it writes is gated by build\'s gate, which round-trips it through spine-core',
       core: {
         usage: [
-          `rigc repack <dir | skeleton.json> --out <dir> [--atlas <path>] [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon] [--profile spine|spine-html] [--stage x,y,w,h] [--stage-box <slot>] [--accept-skeleton-differences] [--report <file>]   (gated without spine-core — see repack --help)`,
-          `rigc repack <dir | skeleton.json> --out <dir> --keep-pages [--atlas <path>] [--profile spine|spine-html] [--stage x,y,w,h] [--stage-box <slot>] [--report <file>]   (skeleton.model.json alone, pages kept)`,
+          `rigc repack <dir | skeleton.json> --out <dir> [--atlas <path>] [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon] [--profile spine|rig-play] [--stage x,y,w,h] [--stage-box <slot>] [--accept-skeleton-differences] [--report <file>]   (gated without spine-core — see repack --help)`,
+          `rigc repack <dir | skeleton.json> --out <dir> --keep-pages [--atlas <path>] [--profile spine|rig-play] [--stage x,y,w,h] [--stage-box <slot>] [--report <file>]   (skeleton.model.json alone, pages kept)`,
         ],
         notes: [
           'a packed build repacked from its own output — skeleton.json, skeleton.atlas and the',
@@ -1401,8 +1402,8 @@ export const COMMANDS: CommandDoc[] = [
     },
     spineFormat: true,
     usage: [
-      `rigc repack <dir | skeleton.json> --out <dir> [--atlas <path>] [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon] [--profile spine|spine-html] [--stage x,y,w,h] [--stage-box <slot>] [--accept-skeleton-differences] [--report <file>]`,
-          `rigc repack <dir | skeleton.json> --out <dir> --keep-pages [--atlas <path>] [--profile spine|spine-html] [--stage x,y,w,h] [--stage-box <slot>] [--report <file>]   (skeleton.model.json alone, pages kept)`,
+      `rigc repack <dir | skeleton.json> --out <dir> [--atlas <path>] [--page-size ${DEFAULT_PAGE_SIZE}] [--padding ${DEFAULT_PADDING}] [--page-edges pot|free] [--pack-shape rect|polygon] [--profile spine|rig-play] [--stage x,y,w,h] [--stage-box <slot>] [--accept-skeleton-differences] [--report <file>]`,
+          `rigc repack <dir | skeleton.json> --out <dir> --keep-pages [--atlas <path>] [--profile spine|rig-play] [--stage x,y,w,h] [--stage-box <slot>] [--report <file>]   (skeleton.model.json alone, pages kept)`,
     ],
     flags: ['out', 'atlas', 'page-size', 'padding', 'page-edges', 'pack-shape', 'profile', 'stage', 'stage-box', 'accept-skeleton-differences', 'keep-pages', 'report'],
     overrides: {
@@ -1469,7 +1470,7 @@ export const COMMANDS: CommandDoc[] = [
     runtime: { for: 'the gate it re-runs is the round trip through it', rerunsTheGate: true },
     spineFormat: true,
     usage: [
-      'rigc validate <dir | skeleton.json> [--atlas <path>] [--profile spine|spine-html]',
+      'rigc validate <dir | skeleton.json> [--atlas <path>] [--profile spine|rig-play]',
       'rigc validate --cut <name> --cuts <cuts.json>   (also re-derives declared durations)',
     ],
     flags: ['atlas', 'profile', 'cut', 'cuts', 'rig', 'motion', 'out', 'manifest', 'images'],
@@ -1815,17 +1816,17 @@ export function commandHelp(name: string, docs: readonly CommandDoc[] = COMMANDS
  * `--profile` paragraph states each profile's rule count, which only the
  * validator knows (`CliEntry.profileRules`).
  */
-const USAGE_PARAGRAPHS: ReadonlyArray<{ about: readonly string[] | { flag: string }; lines: (rules: (profile: 'spine' | 'spine-html') => number) => string[] }> = [
+const USAGE_PARAGRAPHS: ReadonlyArray<{ about: readonly string[] | { flag: string }; lines: (rules: (profile: 'spine' | 'rig-play') => number) => string[] }> = [
   {
     about: ['build', 'validate', 'bench'],
     lines: (rules) => [
-      'build, validate and bench take --profile spine|spine-html:',
+      'build, validate and bench take --profile spine|rig-play:',
       '  spine       is this valid Spine 4.3 that any runtime plays correctly?',
       `              THE DEFAULT — ${rules('spine')} rules, and the question the output answers when`,
       '              you import it into the Spine editor.',
-      '  spine-html  the above, plus this project\'s renderer and archetype policy:',
-      `              all ${rules('spine-html')} rules, opt-in. Those extra ` +
-        `${rules('spine-html') - rules('spine')} fire on real, correct,`,
+      '  rig-play    the above, plus this project\'s renderer and archetype policy:',
+      `              all ${rules('rig-play')} rules, opt-in. Those extra ` +
+        `${rules('rig-play') - rules('spine')} fire on real, correct,`,
       '              editor-produced Spine data, so they are somebody\'s policy rather',
       '              than anybody\'s validity.',
       '',
@@ -1955,7 +1956,7 @@ const USAGE_PARAGRAPHS: ReadonlyArray<{ about: readonly string[] | { flag: strin
  * lines, then every paragraph about only those commands (`USAGE_PARAGRAPHS`).
  * `checkout` is the file a source checkout runs this entry as.
  */
-export function usageText(docs: readonly CommandDoc[], checkout: string, rules: ((profile: 'spine' | 'spine-html') => number) | undefined): string {
+export function usageText(docs: readonly CommandDoc[], checkout: string, rules: ((profile: 'spine' | 'rig-play') => number) | undefined): string {
   const names = new Set(docs.map((doc) => doc.name));
   const takes = (flag: string): boolean => docs.some((doc) => doc.flags.includes(flag));
   const lines = [
@@ -2002,6 +2003,13 @@ export function usageText(docs: readonly CommandDoc[], checkout: string, rules:
 export function readProfile(flags: Record<string, string>): AssertionProfile {
   const raw = flags.profile;
   if (raw === undefined) return CLI_DEFAULT_PROFILE;
+  // A former name resolves here and nowhere else (issue #1277): past this line
+  // the alias does not exist, so it cannot select a rule set of its own.
+  const aliased = Object.hasOwn(PROFILE_ALIASES, raw) ? PROFILE_ALIASES[raw] : undefined;
+  if (aliased !== undefined) {
+    console.error(profileAliasLine(raw, aliased));
+    return aliased;
+  }
   const found = VALIDATE_PROFILES.find((p) => p === raw);
   if (!found) throw new UsageError(`--profile ${JSON.stringify(raw)}; known profiles: ${VALIDATE_PROFILES.join(', ')}`);
   return found;
@@ -2633,7 +2641,7 @@ export interface CliEntry {
   /** Every command this entry runs, by name — exactly its set, or the run refuses to start. */
   runs: Readonly<Record<string, CommandRun>>;
   /** Each profile's rule count, for the `--profile` paragraph; the validator's, so only an entry that links it states it. */
-  profileRules?: (profile: 'spine' | 'spine-html') => number;
+  profileRules?: (profile: 'spine' | 'rig-play') => number;
   /** The refusals of bodies only this entry registers (`CliRefusal`). */
   refusals?: readonly CliRefusal[];
 }

package/src/cli/spine_commands.ts

@@ -818,4 +818,4 @@ export const SPINE_COMMAND_REFUSALS: readonly CliRefusal[] = [
 ];
 
 /** Each profile's rule count — the validator's, which the usage's `--profile` paragraph states. */
-export const PROFILE_RULES = (profile: 'spine' | 'spine-html'): number => assertionCountForProfile(profile);
+export const PROFILE_RULES = (profile: 'spine' | 'rig-play'): number => assertionCountForProfile(profile);

package/src/compile.ts

@@ -1420,7 +1420,7 @@ const SLIDER_TRACKS: Record<string, ValueTrackShape> = {
  * refused by `A12_NO_DARK_COLOR`, and that is not a contradiction — A12 is filed
  * `renderer` in `ASSERTION_KIND`, so it states what ONE renderer ignores rather
  * than what is wrong. The `spine` profile `build` runs reports it `PROF` and
- * never applies it; `--profile spine-html` is where it fires. Emitting a
+ * never applies it; `--profile rig-play` is where it fires. Emitting a
  * construct one consumer drops is exactly what a profile is for.
  */
 export const SLOT_TRACKS: Record<string, 'attachment' | SlotColourShape> = {

package/src/core/entry.ts

@@ -17,13 +17,14 @@
  *
  * ⚠️ A symbol is listed here only because a dependant was seen using it,
  * or asked for it in writing before it could be (`openTrack`, issue #1276;
- * `openTracks`, issue #1336).
+ * `openTracks`, issue #1336; `physicsClockStep` and `PHYSICS_CLOCK_LEAD`,
+ * the clock a live track's `clock` option takes, issue #1396).
  * The list is `scripts/install_smoke.ts`'s `OBSERVED_SYMBOLS` rows for
  * `./core`, and a symbol added here and not there is not promised.
  */
 export { readModel, underSkin, underNoSkin, CoreInputError, CORE_DOCUMENT_SPEC, CORE_DOCUMENT_SPECS, CORE_BLEND_MODES, activeBones } from './index.ts';
 export type { CompiledDocument, CoreSlotRow, CoreBlendMode } from './index.ts';
-export { poseRawSetup, poseRawAnimation, poseRawAnimationEach, loopedTime, setupBounds } from './raw.ts';
+export { poseRawSetup, poseRawAnimation, poseRawAnimationEach, loopedTime, setupBounds, physicsClockStep, PHYSICS_CLOCK_LEAD } from './raw.ts';
 export type { RawPose, RawBone, RawDrawn, RawClip, RawClipped, RawEvent, RawReset } from './raw.ts';
 export { poseWalkSetup, poseLoopingWalk } from './walk.ts';
 export { openTrack } from './track.ts';

package/src/core/raw.ts

@@ -257,7 +257,7 @@ export interface WalkMode {
   keep: boolean;
   /** A plant only (the core suite's `CO26`): the animation time a looping step applies at, from its track time, the duration and the track time before it — `loopedTime` unless given. */
   time?: (trackTime: number, duration: number, before: number) => number;
-  /** What the physics clock moves by, from the step and how far the animation time moved — the step itself unless given: a plant (`CO26`), or the render's offline clock passed to `poseRawAnimationEach` (issue #1380). */
+  /** What the physics clock moves by, from the step and how far the animation time moved — the step itself unless given: a plant (`CO26`), the render's offline clock passed to `poseRawAnimationEach` (issue #1380), or a live track's `clock` option (`./track.ts`, issue #1396). */
   clock?: (dt: number, moved: number) => number;
   /** A plant only (`CO26`): `false` fires no `reset` key across the wrap — the reading the walk was measured against and rejected. */
   wrapResets?: boolean;
@@ -561,6 +561,20 @@ export function physicsClockStep(step: number): number {
   return step + step * PHYSICS_CLOCK_LEAD;
 }
 
+/**
+ * A live track's `clock` option (issue #1396, `./track.ts` and `./tracks.ts`):
+ * the caller's function, called with each step, its answer checked before the
+ * skeleton's clock moves by it — a finite time at or above 0, or the step
+ * refused by name, as a step itself is. `who` names the track in the refusal.
+ */
+export function checkedClock(clock: (dt: number) => number, who: string): (dt: number) => number {
+  return (dt) => {
+    const moved = clock(dt);
+    if (typeof moved !== 'number' || !Number.isFinite(moved) || moved < 0) throw new CoreInputError(`${who} clock moved the physics by ${String(moved)} for a step of ${dt}, not a finite time at or above 0`);
+    return moved;
+  };
+}
+
 /**
  * The animation time a looping track applies its animation at (`./walk.ts`,
  * *The time*): the track time wrapped by the duration, and 0 over a duration

package/src/core/track.ts

@@ -26,7 +26,8 @@
  *
  * - **Held** (`loop: false`): the raw entry's walk — the track time the
  *   running sum of the steps, the animation time held at the duration, the
- *   physics clock moved by the step, events over `(previous animation time,
+ *   physics clock moved by the step (or by `clock`, *The physics clock*
+ *   below), events over `(previous animation time,
  *   animation time]` (`./raw.ts`, *One step*). `CO46` holds it to
  *   `poseRawAnimation` pose for pose, every field, bit for bit.
  * - **Looped** (`loop: true`): A10's looping walk's time, clock and `reset`
@@ -135,6 +136,44 @@
  *   children, the meshes they carry and the physics do not.
  * - **Pose 0 not adjusted** under `reset: 'animation'`.
  *
+ * ## The physics clock (issue #1396)
+ *
+ * `clock` is what each step moves the skeleton's physics clock by — the time
+ * a physics constraint integrates — with `poseRawAnimationEach`'s meaning.
+ * Absent, it is the step itself, and every pose is the one the track posed
+ * before the option existed (`CO46`–`CO50`, unchanged). `physicsClockStep` is
+ * the render's clock (issue #1380), for a player stepping at a fixed rate.
+ * The track time, the animation time, the wrap, the events and `trackTime`
+ * stay on the running sum of the steps: the clock moves the physics and
+ * nothing else.
+ *
+ * - **Why the track takes it.** Stepped at a fixed rate whose frame lasts a
+ *   whole number of physics steps, a spring shows the render's defect. On the
+ *   public trailer's `show`, read with play#103's detector, the frame clock
+ *   adds outlier poses 5, 11–13, 44–45 and 187–189 at a fixed 1/20 and 8,
+ *   15–17, 31–33 and 505–507 at 1/60, and `clock: physicsClockStep` removes
+ *   every one (the PR of issue #1396 carries the table). A player scaling its
+ *   own `dt` instead moves the animation time too: a key at 0.5 s fires on
+ *   the tenth step of 1/20 where the render and the runtime fire it on the
+ *   eleventh, and the player stops agreeing with `rigc render`.
+ * - **The reset.** Pose 0 under `reset: 'animation'` is a step of 0 and moves
+ *   the clock by `clock(0)`, as the render's walk does — 0 for
+ *   `physicsClockStep`; under `setup` nothing is stepped. A physics `reset`
+ *   key restarts a constraint's time from the clock as it stands, so it is
+ *   read on the same clock as every other step.
+ * - **The seek** stays the caller's — open, then step to the time — and its
+ *   steps go through the same clock, so a seek's physics is the physics of
+ *   the steps it took.
+ * - **A clock that returns no time** — not finite, or below 0 — refuses the
+ *   step by name after the track time has moved, so the track stays refused.
+ *
+ * `CO53` holds the mechanism on LS05's spring probe (every constraint update
+ * takes the steps exact arithmetic takes; the frame clock is red), `CO54` the
+ * poses (equal to the render's walk, to `poseRawAnimationEach` on the same
+ * clock, between the two live entries, and to spine-core with its
+ * `AnimationState` updated by the step and its `Skeleton` by the clock), and
+ * `CO55` that the times and the events are those of the walk without it.
+ *
  * ## The oracle chain
  *
  * Nothing here is held to spine-core directly but the events: the live track
@@ -153,15 +192,17 @@
  * history, so a seek is "open, then step to the time".
  */
 import { CoreInputError, type CompiledDocument } from './index.ts';
-import { openRawTrack, stepRawTrack, type RawPose, type RawReset, type TrackState, type WalkMode } from './raw.ts';
+import { checkedClock, openRawTrack, stepRawTrack, type RawPose, type RawReset, type TrackState, type WalkMode } from './raw.ts';
 import type { LocalAdjust, TimelinePlant } from './animation.ts';
 export type { AdjustableLocals, BoneLocals, LocalAdjust } from './animation.ts';
 
-/** How a live track is opened: whether it loops, and where its physics is reset (`RawReset`) — both the caller's, neither with a default — and the caller's adjustment of every pose's bone locals (the header's *The adjustment*). */
+/** How a live track is opened: whether it loops, and where its physics is reset (`RawReset`) — both the caller's, neither with a default — the caller's adjustment of every pose's bone locals (the header's *The adjustment*), and what each step moves the physics clock by (the header's *The physics clock*). */
 export interface TrackOptions {
   loop: boolean;
   reset: RawReset;
   adjust?: LocalAdjust;
+  /** What each step of `dt` moves the skeleton's physics clock by — `physicsClockStep` is the render's; absent, the step itself. The track time, the animation time and the events stay on the running sum of the steps. */
+  clock?: (dt: number) => number;
 }
 
 /** A live track (`openTrack`): pose 0, then one pose per `step`. */
@@ -191,7 +232,10 @@ export function openTrack(doc: CompiledDocument, animation: string, options: Tra
   if (typeof options !== 'object' || options === null || typeof options.loop !== 'boolean') throw new CoreInputError(`the live track's options.loop is ${JSON.stringify((options as Partial<TrackOptions> | null)?.loop)}, not true or false`);
   if (options.reset !== 'animation' && options.reset !== 'setup') throw new CoreInputError(`the live track's options.reset is ${JSON.stringify(options.reset)}, not "animation" or "setup"`);
   if (options.adjust !== undefined && typeof options.adjust !== 'function') throw new CoreInputError(`the live track's options.adjust is ${typeof options.adjust}, not a function`);
-  const { track, first } = openRawTrack(doc, animation, plant, options.reset, options.loop ? LOOPED : HELD, options.adjust);
+  if (options.clock !== undefined && typeof options.clock !== 'function') throw new CoreInputError(`the live track's options.clock is ${typeof options.clock}, not a function`);
+  const mode = options.loop ? LOOPED : HELD;
+  const clock = options.clock === undefined ? undefined : checkedClock(options.clock, 'the live track\'s');
+  const { track, first } = openRawTrack(doc, animation, plant, options.reset, clock === undefined ? mode : { ...mode, clock: (dt) => clock(dt) }, options.adjust);
   return new Track(track, first);
 }
 

package/src/core/tracks.ts

@@ -73,7 +73,12 @@
  *   out fires none** — not "until the mix passes half way": `eventThreshold`
  *   defaults to 0 and an entry's events are applied only while `mix <
  *   eventThreshold`, which no mix is. `complete` is not carried (issue #1276).
- * - **Physics** steps on top of the mixed locals, as on one track.
+ * - **Physics** steps on top of the mixed locals, as on one track — and on
+ *   the same clock: `TracksOptions.clock`, what each step moves the physics
+ *   clock by, has the single track's meaning (`./track.ts`, *The physics
+ *   clock*, issue #1396). The entries' track times, the mixes, the queue and
+ *   the events stay on the steps; `start()` under `reset: 'animation'` moves
+ *   the clock by `clock(0)`.
  *
  * `CO51` holds all of it to spine-core 4.3.13 at tolerance 0 — every bone's
  * world transform, every drawn attachment's world vertices, every slot's
@@ -159,13 +164,15 @@ import { activeBones, CoreInputError, rawNumber, readColour, shownAttachment, ty
 import { channelAt, keyIndexAt, SLOT_COLOUR_TIMELINES, slotRowsFrom, steppedLocalsWorld, type BoneTimelineKind, type CoreKey, type LocalAdjust, type SlotBase, type SlotColourKind, type TimelinePlant } from './animation.ts';
 import { deformAt, setupArray, type CoreAttachmentTimeline } from './deform.ts';
 import { eventsFired, type CoreEventKey, type CoreEventRow } from './events.ts';
-import { openRawTracksPath, type RawPose, type RawReset, type RawTracksPath } from './raw.ts';
+import { checkedClock, openRawTracksPath, type RawPose, type RawReset, type RawTracksPath } from './raw.ts';
 import { slotTimelinesApply } from './skins.ts';
 
-/** How the live tracks are opened: where the physics is reset (`RawReset`, the caller's, no default) and the caller's adjustment of every pose's bone locals. */
+/** How the live tracks are opened: where the physics is reset (`RawReset`, the caller's, no default), the caller's adjustment of every pose's bone locals, and what each step moves the physics clock by (the header's *The physics clock*). */
 export interface TracksOptions {
   reset: RawReset;
   adjust?: LocalAdjust;
+  /** What each step of `dt` moves the skeleton's physics clock by — `physicsClockStep` is the render's; absent, the step itself. Every entry's track time, the mixes, the queue and the events stay on the steps. */
+  clock?: (dt: number) => number;
 }
 
 /**
@@ -1299,7 +1306,9 @@ function delayOf(v: number, call: string): number {
 export function openTracks(doc: CompiledDocument, options: TracksOptions, plant: TracksPlant = {}): LiveTracks {
   if (typeof options !== 'object' || options === null || (options.reset !== 'animation' && options.reset !== 'setup')) throw new CoreInputError(`the live tracks' options.reset is ${JSON.stringify((options as Partial<TracksOptions> | null)?.reset)}, not "animation" or "setup"`);
   if (options.adjust !== undefined && typeof options.adjust !== 'function') throw new CoreInputError(`the live tracks' options.adjust is ${typeof options.adjust}, not a function`);
-  return new Tracks(doc, options.reset, options.adjust, plant, openRawTracksPath(doc, plant));
+  if (options.clock !== undefined && typeof options.clock !== 'function') throw new CoreInputError(`the live tracks' options.clock is ${typeof options.clock}, not a function`);
+  const clock = options.clock === undefined ? undefined : checkedClock(options.clock, 'the live tracks\'');
+  return new Tracks(doc, options.reset, options.adjust, clock, plant, openRawTracksPath(doc, plant));
 }
 
 class Tracks implements LiveTracks {
@@ -1313,6 +1322,7 @@ class Tracks implements LiveTracks {
     private readonly doc: CompiledDocument,
     private readonly reset: RawReset,
     private readonly adjust: LocalAdjust | undefined,
+    private readonly clock: ((dt: number) => number) | undefined,
     private readonly plant: TracksPlant,
     private readonly path: RawTracksPath,
   ) {
@@ -1426,7 +1436,7 @@ class Tracks implements LiveTracks {
     const { doc, path } = this;
     const ctx = path.ctx;
     const before = ctx.time;
-    ctx.time += dt;
+    ctx.time += this.clock === undefined ? dt : this.clock(dt);
     const pose = new Pose(doc, this.plant);
     const animationTime = this.mixer.apply(pose);
     const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));

package/src/rig.ts

@@ -426,7 +426,7 @@ export interface RigSlot {
   attachment?: string | null;
   /** `rrggbbaa`. Default opaque white. */
   color?: string;
-  /** Two-colour tint, `rrggbb`. 🚫 `A12_NO_DARK_COLOR` under `spine-html`. */
+  /** Two-colour tint, `rrggbb`. 🚫 `A12_NO_DARK_COLOR` under `rig-play`. */
   dark?: string;
   /** Default `normal`. Only the first letter's case is free (`RigSlotBlend`). */
   blend?: RigSlotBlend;

package/src/validate.ts

@@ -77,7 +77,7 @@ import {
   walkTimelines,
 } from './timelines.ts';
 import type { RigInfo } from './types.ts';
-import { ASSERTION_KIND, kindRunsUnder, type AssertionProfile } from './assertions/kinds.ts';
+import { ASSERTION_KIND, kindRunsUnder, resolveProfile, type AssertionProfile } from './assertions/kinds.ts';
 import { verdictHarness, type Failure } from './assertions/harness.ts';
 import { isObj, type Json } from './assertions/values.ts';
 import type { SkinEntryFacts } from './assertions/facts/skin_entries.ts';
@@ -168,14 +168,14 @@ export type { Failure } from './assertions/harness.ts';
  * ⭐ The distinction this draws is the difference between "wrong" and "not how we
  * do it here", and conflating the two is how a validator stops being usable on
  * anybody else's data. Fifteen of the 40 assertions are policy — seven for one
- * renderer (`spine-html`) and one project's canvas budget, eight for rigc's own
+ * renderer (`rig-play`) and one project's canvas budget, eight for rigc's own
  * formations — and every one of them fires
  * on real, correct, editor-produced Spine data — the official example projects
  * carry clipping attachments, unweighted meshes, 116-triangle meshes and packed
  * atlases, all of which are perfectly valid and none of which spine-html likes.
  *
  * - `spine`      — is this valid Spine 4.3 that any runtime will play correctly?
- * - `spine-html` — the above, plus this project's renderer and archetype policy.
+ * - `rig-play`   — the above, plus this project's renderer and archetype policy.
  *
  * ⚠️ `validate()` has NO default profile — `ValidateInput.profile` is required,
  * and that is deliberate. A silent default here can only be wrong in one of two
@@ -207,7 +207,7 @@ export const ASSERTION_NAMES: readonly string[] = Object.keys(ASSERTION_KIND);
 
 /** How many assertions this profile applies, by the kinds it carries. */
 export function assertionCountForProfile(profile: ValidateProfile): number {
-  if (profile === 'spine-html') return ASSERTION_NAMES.length;
+  if (profile === 'rig-play') return ASSERTION_NAMES.length;
   return ASSERTION_NAMES.filter((name) => ASSERTION_KIND[name] === 'validity').length;
 }
 
@@ -2012,9 +2012,10 @@ function once<T>(supply: () => T): () => T {
 }
 
 export function validate(input: ValidateInput): ValidateReport {
-  const profile = input.profile;
+  // A former name reads as its profile (issue #1277): the policy switch below and the report both use the resolved one.
+  const profile = resolveProfile(input.profile, 'validate');
   /** True when this profile's rulebook includes the policy layer. */
-  const policy = profile === 'spine-html';
+  const policy = profile === 'rig-play';
   // The harness — `check`, `fail`, `skip` and the lists they fill — is
   // `./assertions/harness.ts`'s since issue #1025, and the rule is the one it
   // always was: the model side runs the bodies that moved there in the same
@@ -2566,7 +2567,7 @@ export function validate(input: ValidateInput): ValidateReport {
   });
 
   // --- A12: no dark / two-colour tint --------------------------------------
-  // Parsed, then silently ignored by spine-html.
+  // Parsed, then ignored by rig-play's DOM mode.
   check('A12_NO_DARK_COLOR', () => a12NoDarkColor(verdicts, rawSkeletonRoster(raw), rawSlotTimelines(raw)));
 
   // --- A05: curve arrays are 4 numbers per value channel --------------------
@@ -3309,7 +3310,7 @@ export function validate(input: ValidateInput): ValidateReport {
   // first build — and told them, untruthfully, that the file held no transparency
   // at all. That audit is also why the CLI's default is now `spine`, which does
   // not run this rule at all (#221): a stranger reaches this refusal only by
-  // asking for `spine-html`. It still has to be both TRUE and actionable when it
+  // asking for `rig-play`. It still has to be both TRUE and actionable when it
   // fires, and it now has to name the profile it belongs to as well as the one
   // that does not ask — the reader opted in, and the message is where they find
   // out what they opted into.