@rig-c/core 2.70.0 → 2.71.0

package/docs/AUTHORING.md

@@ -273,7 +273,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 36 validity rules (**the default**) · `rig-play` = all 50, 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` |
+| `--profile` | `spine` = the 36 validity rules (**the default**) · `rig-play` = all 50, opt-in. `spine-html`, the profile's former name, is read as `rig-play` until the next major release and prints `rigc: --profile spine-html is deprecated and reads as --profile rig-play, the same rules; it is accepted until the next major release — pass --profile rig-play` on stderr |
 | `--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 |
@@ -5219,7 +5219,7 @@ is that a **depth** is the decision while a **residual** is not.
 
 | `kind` | Reads | `translatex` / `translatey` | `scalex` / `scaley` | Worked case |
 | --- | --- | --- | --- | --- |
-| `yaw` | each member's setup `x` | `d = (x−about)·(cos t − 1) − (depth − carried)·sin t` — FACE §3 | `cos(α − t)/cos α`, `α = atan2(x−about, depth)` — FACE §5 | `gallery/portrait` |
+| `yaw` | each member's setup `x` | `d = (x−about)·(cos t − 1) − (depth − carried)·sin t` (or `−(depth − carried)·sin t` with `"narrowing": false`) — FACE §3 | `cos(α − t)/cos α`, `α = atan2(x−about, depth)` — FACE §5 | `gallery/portrait` |
 | `pitch` | each member's setup `y` | the same expression with `y` for `x` — a nod | the same | `gallery/nod` |
 
 ⭐ **The `property` says which half of the turn a key is.** A turn does two
@@ -5248,6 +5248,15 @@ is an **auditing** decision before it is a rigging one: a residual is 1–6 unit
 where a total is 30–40, and nobody can eyeball a wrong sign in the second.
 `about` (default 0) is where the axis crosses the driving coordinate, in the
 members' shared parent's space.
+`narrowing` (default `true`) says whether the displacement includes the
+foreshortening of the member's setup position `(x−about)·(cos t − 1)` (or `y`).
+With `"narrowing": false`, the displacement evaluates `d = −(depth − carried)·sin t`
+alone — for a rig whose plate proportions are held at their front-view width
+across the turn rather than narrowed toward the axis (§4.11.1). It belongs on the
+displacement projection (`translatex` / `translatey`) only; stating `narrowing` on
+a `scalex` or `scaley` track is refused by name (`CE_TRACK_NARROWING_PROJECTION`),
+because a foreshortening track *is* the narrowing — to turn without narrowing a
+plate's scale, omit that track.
 
 Six things the construct is bounded by, and each one is a refusal:
 
@@ -6194,7 +6203,7 @@ example needed it:
 
 | `kind` | Parameters | What it evaluates | Worked case |
 | --- | --- | --- | --- |
-| `yaw` | `radius` **or** `depth`, `degrees`, `about` | `dx = (x−about)·(cos t − 1) − z·sin t`, with `z = √(radius² − (x−about)²)` from a cylinder or `z` read per vertex off a depth map — the 2.5D turn (FACE §1) | `gallery/portrait` |
+| `yaw` | `radius` **or** `depth`, `degrees`, `about`, `narrowing` | `dx = (x−about)·(cos t − 1) − z·sin t` (or `dx = −z·sin t` with `"narrowing": false`), with `z = √(radius² − (x−about)²)` from a cylinder or `z` read per vertex off a depth map — the 2.5D turn (FACE §1) | `gallery/portrait` |
 | `pitch` | the same | the same expression with `y` for `x` — a nod rather than a turn | `gallery/nod` |
 | `affine` | `scale`, `about` | `dx = (sx−1)·(x−ax)`, `dy = (sy−1)·(y−ay)` — a scale about a fixed point | `gallery/squash` |
 | `wave` | `amplitude`, `wavelength`, `phase`, `along`, `axis` | `d = amplitude · sin(2π·along/wavelength + phase)` | `gallery/nod` |
@@ -6204,8 +6213,28 @@ example needed it:
 displaces; they cannot be the same coordinate, because reading and displacing one
 axis is a stretch and `affine` states that. `power: 1` is an affine shear and
 `power: 2` is a cantilever — flat at `from`, so a part held at one end bends
-instead of tilting. `about` defaults to 0 (or `[0, 0]`), `phase` to 0 and `power`
-to 2; nothing else has a default.
+instead of tilting. `about` defaults to 0 (or `[0, 0]`), `narrowing` to `true`,
+`phase` to 0 and `power` to 2; nothing else has a default.
+
+**`"narrowing": false` drops the setup-position foreshortening `(u−about)·(cos t − 1)` and keeps the depth shift `−z·sin t` alone.**
+A rigid 3D cylinder narrows across the screen as `cos t`, pulling every vertex
+inward by `(x−about)·(cos t − 1)` on top of its depth shift `−z·sin t`. On a
+cut-out rig whose facial plates are drawn to keep their front-view proportions
+across a turn — features translating by `−(depth − carried)·sin t` without
+foreshortening their setup `x` or `y` — that inward pull squashes the outer cheek
+while the features riding over it do not narrow to match. Setting `"narrowing": false`
+on `yaw` or `pitch` (both here and on `derive` in §4.5.1) states that choice
+in the model rather than forcing the author back to a raw `vertices` array.
+With the `cos t` term absent, a triangle's deformed twice-signed area is
+`2A(t) = 2A₀ − 2A_axis·sin t` instead of `2A₀·cos t − 2A_axis·sin t`, so it
+crosses zero at `sin t = A₀ / A_axis` (`asin(|A₀ / A_axis|)` when `|A₀ / A_axis| < 1`,
+and never on `(0, 90°)` when `|A₀ / A_axis| ≥ 1`) rather than `tan t = A₀ / A_axis`
+(`atan(|A₀ / A_axis|)`). When a deform key on a depth-mapped mesh declares
+`"narrowing": false`, `build` and `explain` recompute that axis's turn ceiling
+(§3.4.5) with `asin`, so the reported ceiling stays the exact angle `A39` fires at;
+mixing `"narrowing": false` and the default (`true`) on the same attachment and axis
+is refused (`CE_COMPILE_DEFORM_TURN_NARROWING_MIXED`), because one attachment and axis
+cannot have both the `asin` and `atan` ceilings at once.
 
 Six things this construct is bounded by, and each one is a refusal rather than a
 convention:
@@ -7456,6 +7485,7 @@ retain the minimal inputs and report that code rather than inventing author data
 | <a id="CE_COMPILE_DEFORM_FROM_VERTEX_INVALID"></a>`CE_COMPILE_DEFORM_FROM_VERTEX_INVALID` | “&lt;value&gt; (t=&lt;value&gt;): fromVertex is &lt;value&gt;; it is a vertex index, so a whole number ≥ 0” | State fromVertex as a whole vertex index at least zero. |
 | <a id="CE_COMPILE_DEFORM_FROM_VERTEX_OUTSIDE_ATTACHMENT"></a>`CE_COMPILE_DEFORM_FROM_VERTEX_OUTSIDE_ATTACHMENT` | “&lt;value&gt; (t=&lt;value&gt;): fromVertex &lt;value&gt; plus &lt;value&gt; vertex offset(s) runs to vertex &lt;value&gt;&lt;value&gt;, and the attachment has &lt;value&gt;” | Keep fromVertex plus the covered vertex count within the attachment. |
 | <a id="CE_COMPILE_DEFORM_WEIGHTED_FROM_VERTEX_AMBIGUOUS"></a>`CE_COMPILE_DEFORM_WEIGHTED_FROM_VERTEX_AMBIGUOUS` | “&lt;value&gt; (t=&lt;value&gt;): "fromVertex" counts VERTICES, and this attachment is weighted — its deform array holds one x, y pair per bone INFLUENCE, and vertex &lt;value&gt; has &lt;value&gt; of them. One offset per vertex is not a thing that array can hold: the world offset of a multi-bone vertex is the weighted sum of a per-bone offset in each bone's own bind space, so rigc will not guess one for you. Either key the control bone instead, or write the bind-space pairs yourself and start the run with "offset" (vertex &lt;value&gt; starts at deform index &lt;value&gt;).” | Key the control bone or author each bone influence's bind-space pair using offset. |
+| <a id="CE_COMPILE_DEFORM_TURN_NARROWING_MIXED"></a>`CE_COMPILE_DEFORM_TURN_NARROWING_MIXED` | “deform &lt;turnTriple&gt; keys "&lt;turnAxis&gt;" with narrowing=false in animation "&lt;turnFalseAnim&gt;" and with narrowing=true in animation "&lt;turnTrueAnim&gt;". An attachment's turn ceiling on one axis is either asin(\|A₀ / A_axis\|) (without narrowing) or atan(\|A₀ / A_axis\|) (with narrowing) — mixing both on one attachment and axis would report one ceiling where two apply. Use one "narrowing" setting across every "&lt;turnAxis&gt;" key on &lt;turnTriple&gt;.”<br>Also: “&lt;turnDeformSkin&gt;/&lt;turnTrack.slot&gt;/&lt;turnTrack.attachment&gt;”<br>Here the values named in the message include: “default”. | Use one `"narrowing"` setting (`true` or `false`) across every deform turn key on the same attachment and axis. |
 | <a id="CE_COMPILE_TRACK_TARGETS_MULTIPLE"></a>`CE_COMPILE_TRACK_TARGETS_MULTIPLE` | “animation "&lt;value&gt;": a track names more than one target (&lt;value&gt;); the list is &lt;value&gt; and a track names exactly one”<br>Also: “, ”<br>Here the values named in the message include: “/”, “bone”, “slot”, “group”. | Name exactly one target field on a track. |
 | <a id="CE_COMPILE_CONSTRAINT_TRACK_PROPERTY_UNKNOWN"></a>`CE_COMPILE_CONSTRAINT_TRACK_PROPERTY_UNKNOWN` | “animation "&lt;value&gt;": &lt;value&gt; has no timeline "&lt;value&gt;" (it has: &lt;value&gt;)”<br>Also: “, ”<br>“path constraint”<br>“physics constraint”<br>“{group "&lt;value&gt;" / &lt;value&gt; "&lt;value&gt;"}”<br>Here the values named in the message include: “slider”. | Use a timeline property supported by this constraint family. |
 | <a id="CE_COMPILE_ANIMATION_GROUP_UNKNOWN"></a>`CE_COMPILE_ANIMATION_GROUP_UNKNOWN` | “animation "&lt;value&gt;": unknown group "&lt;value&gt;"” | Declare the motion group or correct its name. |
@@ -7623,8 +7653,8 @@ retain the minimal inputs and report that code rather than inventing author data
 | <a id="CE_DEFORM_WAVELENGTH_ZERO"></a>`CE_DEFORM_WAVELENGTH_ZERO` | “&lt;where&gt;: transform wave has wavelength 0; one period cannot be zero long” | State a non-zero wavelength. |
 | <a id="CE_DEFORM_BEND_POWER_WHOLE"></a>`CE_DEFORM_BEND_POWER_WHOLE` | “&lt;where&gt;: transform bend has power &lt;power&gt;; it is a whole number ≥ 1 (1 is an affine shear, 2 a cantilever that is flat at "from"). A fractional power is not evaluated because it has no value on the side of "from" the part does not reach.” | Use a whole bend power of at least 1. |
 | <a id="CE_DEFORM_BEND_ENDS_EQUAL"></a>`CE_DEFORM_BEND_ENDS_EQUAL` | “&lt;where&gt;: transform bend has from &lt;from&gt; and to &lt;to&gt;; they are the two ends of the bend, so they differ” | Give bend from and to different values. |
-| <a id="CE_DEFORM_TRANSFORM_QUANTISED_IDENTITY"></a>`CE_DEFORM_TRANSFORM_QUANTISED_IDENTITY` | “&lt;where&gt;: transform &lt;kind&gt; states &lt;stated&gt;, and every one of this attachment's &lt;count&gt; vertices evaluates to an offset of 0 — the largest value the closed form reached at any of them is &lt;band.toExponential(3)&gt;, which quantises to 0 on the 1e-6 grid a model is evaluated on. So the key states a deformation and emits the identity, and nothing downstream can tell it apart from a key that meant the setup pose. &lt;sampledTo&gt;. A key that MEANS the identity states it in its own parameters (&lt;identitySpelling&gt;) or carries no run at all.”<br>“A scale about a fixed point moves nothing that SITS on it, so every vertex this attachment has lies at about=[&lt;about[0]&gt;, &lt;about[1]&gt;] on the axis the scale changes — the geometry has collapsed onto the point the key holds still”<br>“amount 0”<br>“amount=&lt;amount&gt; from=&lt;from&gt; to=&lt;to&gt; power=&lt;power&gt; along=&lt;an&gt; axis=&lt;axis === 0 ? 'x' : 'y'&gt;”<br>“amplitude 0”<br>“amplitude=&lt;amplitude&gt; wavelength=&lt;wavelength&gt; phase=&lt;phase&gt; along=&lt;an&gt; axis=&lt;axis === 0 ? 'x' : 'y'&gt;”<br>“degrees 0”<br>“scale [1, 1]”<br>“scale=[&lt;scale[0]&gt;, &lt;scale[1]&gt;]&lt;a.about === undefined ? '' : ` about=[${about[0]}, ${about[1]}]`&gt;”<br>“{Every vertex sits at &lt;an&gt;=&lt;distinct[0]&gt;, so one value of the sinusoid covers the whole attachment and this phase is where that one value crosses zero. A wave needs the coordinate it reads to VARY across the geometry; a part that displaces as a whole is a bone, not a deform / The closest two distinct &lt;an&gt; coordinates in this attachment are &lt;round(gap)&gt; apart, and a sinusoid has to be sampled to exist: a wavelength of at least 4x that (&lt;round(4 * gap)&gt;) to read as a wave at all and 8x (&lt;round(8 * gap)&gt;) to read as a curve, where this key states &lt;round(wavelength / gap)&gt;x. At 2x every sample lands on the same pair of phases, and at the zero crossings that pair is (0, 0). `gallery/nod`'s README carries that rule and the measured table behind it}”<br>“{Every vertex sits at &lt;an&gt;=&lt;from&gt;, which is "from" — the end the bend is anchored at, where the displacement is 0 by construction. The span the key names does not cross the part it is keyed on / The furthest any vertex reaches into the span is u=&lt;round(reach)&gt; of 1, and u^&lt;power&gt; of that is &lt;(reach ** power).toExponential(3)&gt; — so the part occupies only the flat end of the curve. Move "to" to where the geometry actually ends, or lower the power}”<br>“{The turn is &lt;degrees&gt;°, and a projection of it can only vanish where every vertex shares one &lt;kind === 'yaw' ? 'x' : 'y'&gt; AND one depth — check the depth map's sampled range in the mesh report, which is 0 wide when the sheet is flat where this part sits / The turn is &lt;degrees&gt;°, and a projection of it can only vanish where every vertex shares one &lt;kind === 'yaw' ? 'x' : 'y'&gt; — check that this attachment's setup geometry is the shape the radius says it is}”<br>“{depth=true degrees=&lt;degrees&gt;&lt;t.about === undefined ? '' : ` about=${about}`&gt; / radius=&lt;radius&gt; degrees=&lt;degrees&gt;&lt;t.about === undefined ? '' : ` about=${about}`&gt;}”<br>Also: “axis=[&lt;value&gt;, &lt;value&gt;] from=&lt;value&gt; to=&lt;value&gt; shape=&lt;value&gt;”<br>“mask=&lt;value&gt;”<br>“&lt;value&gt; envelope(&lt;value&gt;)”<br>Here the values named in the message include: “linear”, “smooth”. | Use parameters with a measured non-zero result, explicitly state identity parameters, or omit the run. |
-| <a id="CE_DEFORM_ENVELOPE_ZERO_WEIGHT"></a>`CE_DEFORM_ENVELOPE_ZERO_WEIGHT` | “&lt;where&gt;: transform &lt;kind&gt; states &lt;stated&gt; and moves &lt;plain.filter((d, i) =&gt; i % 2 === 0 &amp;&amp; (d !== 0 \|\| plain[i + 1] !== 0)).length&gt; of &lt;count&gt; vertices, and envelope &lt;weighed.stated&gt; weighs every one of them 0 — so the key states a deformation and emits the identity. &lt;weighed.reach&gt;”<br>“The mask "&lt;mask&gt;" weighs &lt;carried&gt; of &lt;count&gt; vertices above 0.”<br>“axis=[&lt;axis[0]&gt;, &lt;axis[1]&gt;] from=&lt;from&gt; to=&lt;to&gt; shape=&lt;shape&gt;”<br>“mask=&lt;mask&gt;”<br>“{The attachment has no vertices. / Along [&lt;axis[0]&gt;, &lt;axis[1]&gt;] this attachment's vertices sit at &lt;round(lo)&gt; to &lt;round(hi)&gt;, and the ramp rises from &lt;from&gt; (weight 0) to &lt;to&gt; (weight 1) — move "from" and "to" onto the part.}”<br>Also: “amplitude=&lt;value&gt; wavelength=&lt;value&gt; phase=&lt;value&gt; along=&lt;value&gt; axis=&lt;value&gt;”<br>“{depth=true degrees=&lt;value&gt;&lt;value&gt; / radius=&lt;value&gt; degrees=&lt;value&gt;&lt;value&gt;}”<br>“{ /  about=[&lt;value&gt;, &lt;value&gt;]}”<br>“amount=&lt;value&gt; from=&lt;value&gt; to=&lt;value&gt; power=&lt;value&gt; along=&lt;value&gt; axis=&lt;value&gt;”<br>“&lt;value&gt; envelope(&lt;value&gt;)”<br>“scale=[&lt;value&gt;, &lt;value&gt;]&lt;value&gt;”<br>Here the values named in the message include: “linear”, “smooth”. | Place the envelope ramp or mask where it weights moved vertices above 0, or remove the ineffective key. |
+| <a id="CE_DEFORM_TRANSFORM_QUANTISED_IDENTITY"></a>`CE_DEFORM_TRANSFORM_QUANTISED_IDENTITY` | “&lt;where&gt;: transform &lt;kind&gt; states &lt;stated&gt;, and every one of this attachment's &lt;count&gt; vertices evaluates to an offset of 0 — the largest value the closed form reached at any of them is &lt;band.toExponential(3)&gt;, which quantises to 0 on the 1e-6 grid a model is evaluated on. So the key states a deformation and emits the identity, and nothing downstream can tell it apart from a key that meant the setup pose. &lt;sampledTo&gt;. A key that MEANS the identity states it in its own parameters (&lt;identitySpelling&gt;) or carries no run at all.”<br>“A scale about a fixed point moves nothing that SITS on it, so every vertex this attachment has lies at about=[&lt;about[0]&gt;, &lt;about[1]&gt;] on the axis the scale changes — the geometry has collapsed onto the point the key holds still”<br>“amount 0”<br>“amount=&lt;amount&gt; from=&lt;from&gt; to=&lt;to&gt; power=&lt;power&gt; along=&lt;an&gt; axis=&lt;axis === 0 ? 'x' : 'y'&gt;”<br>“amplitude 0”<br>“amplitude=&lt;amplitude&gt; wavelength=&lt;wavelength&gt; phase=&lt;phase&gt; along=&lt;an&gt; axis=&lt;axis === 0 ? 'x' : 'y'&gt;”<br>“degrees 0”<br>“scale [1, 1]”<br>“scale=[&lt;scale[0]&gt;, &lt;scale[1]&gt;]&lt;a.about === undefined ? '' : ` about=[${about[0]}, ${about[1]}]`&gt;”<br>“{Every vertex sits at &lt;an&gt;=&lt;distinct[0]&gt;, so one value of the sinusoid covers the whole attachment and this phase is where that one value crosses zero. A wave needs the coordinate it reads to VARY across the geometry; a part that displaces as a whole is a bone, not a deform / The closest two distinct &lt;an&gt; coordinates in this attachment are &lt;round(gap)&gt; apart, and a sinusoid has to be sampled to exist: a wavelength of at least 4x that (&lt;round(4 * gap)&gt;) to read as a wave at all and 8x (&lt;round(8 * gap)&gt;) to read as a curve, where this key states &lt;round(wavelength / gap)&gt;x. At 2x every sample lands on the same pair of phases, and at the zero crossings that pair is (0, 0). `gallery/nod`'s README carries that rule and the measured table behind it}”<br>“{Every vertex sits at &lt;an&gt;=&lt;from&gt;, which is "from" — the end the bend is anchored at, where the displacement is 0 by construction. The span the key names does not cross the part it is keyed on / The furthest any vertex reaches into the span is u=&lt;round(reach)&gt; of 1, and u^&lt;power&gt; of that is &lt;(reach ** power).toExponential(3)&gt; — so the part occupies only the flat end of the curve. Move "to" to where the geometry actually ends, or lower the power}”<br>“{The turn is &lt;degrees&gt;°, and a projection of it can only vanish where every vertex shares one &lt;kind === 'yaw' ? 'x' : 'y'&gt; AND one depth — check the depth map's sampled range in the mesh report, which is 0 wide when the sheet is flat where this part sits / The turn is &lt;degrees&gt;°, and a projection of it can only vanish where every vertex shares one &lt;kind === 'yaw' ? 'x' : 'y'&gt; — check that this attachment's setup geometry is the shape the radius says it is}”<br>“{depth=true degrees=&lt;degrees&gt;&lt;t.about === undefined ? '' : ` about=${about}`&gt;&lt;narrowingNote&gt; / radius=&lt;radius&gt; degrees=&lt;degrees&gt;&lt;t.about === undefined ? '' : ` about=${about}`&gt;&lt;narrowingNote&gt;}”<br>“{ /  narrowing=false}”<br>Also: “axis=[&lt;value&gt;, &lt;value&gt;] from=&lt;value&gt; to=&lt;value&gt; shape=&lt;value&gt;”<br>“mask=&lt;value&gt;”<br>“&lt;value&gt; envelope(&lt;value&gt;)”<br>Here the values named in the message include: “linear”, “smooth”. | Use parameters with a measured non-zero result, explicitly state identity parameters, or omit the run. |
+| <a id="CE_DEFORM_ENVELOPE_ZERO_WEIGHT"></a>`CE_DEFORM_ENVELOPE_ZERO_WEIGHT` | “&lt;where&gt;: transform &lt;kind&gt; states &lt;stated&gt; and moves &lt;plain.filter((d, i) =&gt; i % 2 === 0 &amp;&amp; (d !== 0 \|\| plain[i + 1] !== 0)).length&gt; of &lt;count&gt; vertices, and envelope &lt;weighed.stated&gt; weighs every one of them 0 — so the key states a deformation and emits the identity. &lt;weighed.reach&gt;”<br>“The mask "&lt;mask&gt;" weighs &lt;carried&gt; of &lt;count&gt; vertices above 0.”<br>“axis=[&lt;axis[0]&gt;, &lt;axis[1]&gt;] from=&lt;from&gt; to=&lt;to&gt; shape=&lt;shape&gt;”<br>“mask=&lt;mask&gt;”<br>“{The attachment has no vertices. / Along [&lt;axis[0]&gt;, &lt;axis[1]&gt;] this attachment's vertices sit at &lt;round(lo)&gt; to &lt;round(hi)&gt;, and the ramp rises from &lt;from&gt; (weight 0) to &lt;to&gt; (weight 1) — move "from" and "to" onto the part.}”<br>Also: “amplitude=&lt;value&gt; wavelength=&lt;value&gt; phase=&lt;value&gt; along=&lt;value&gt; axis=&lt;value&gt;”<br>“{depth=true degrees=&lt;value&gt;&lt;value&gt;&lt;value&gt; / radius=&lt;value&gt; degrees=&lt;value&gt;&lt;value&gt;&lt;value&gt;}”<br>“{ /  narrowing=false}”<br>“{ /  about=[&lt;value&gt;, &lt;value&gt;]}”<br>“amount=&lt;value&gt; from=&lt;value&gt; to=&lt;value&gt; power=&lt;value&gt; along=&lt;value&gt; axis=&lt;value&gt;”<br>“&lt;value&gt; envelope(&lt;value&gt;)”<br>“scale=[&lt;value&gt;, &lt;value&gt;]&lt;value&gt;”<br>Here the values named in the message include: “linear”, “smooth”. | Place the envelope ramp or mask where it weights moved vertices above 0, or remove the ineffective key. |
 | <a id="CE_DEFORM_ENVELOPE_NO_EFFECT"></a>`CE_DEFORM_ENVELOPE_NO_EFFECT` | “&lt;where&gt;: transform &lt;kind&gt; states envelope &lt;weighed.stated&gt;, and it changes no emitted number: every vertex the model moves takes weight 1 (&lt;weighed.full&gt; of &lt;count&gt; vertices at 1, &lt;weighed.zero&gt; at 0), so the run is the un-enveloped one and the envelope is a field a reader would credit for an output it did not shape. &lt;weighed.reach&gt;”<br>“The mask "&lt;mask&gt;" weighs &lt;carried&gt; of &lt;count&gt; vertices above 0.”<br>“axis=[&lt;axis[0]&gt;, &lt;axis[1]&gt;] from=&lt;from&gt; to=&lt;to&gt; shape=&lt;shape&gt;”<br>“mask=&lt;mask&gt;”<br>“{The attachment has no vertices. / Along [&lt;axis[0]&gt;, &lt;axis[1]&gt;] this attachment's vertices sit at &lt;round(lo)&gt; to &lt;round(hi)&gt;, and the ramp rises from &lt;from&gt; (weight 0) to &lt;to&gt; (weight 1) — move "from" and "to" onto the part.}”<br>Here the values named in the message include: “linear”, “smooth”. | Remove the ineffective envelope, or place its transition over vertices the model moves. |
 | <a id="CE_DEFORM_ENVELOPE_OBJECT"></a>`CE_DEFORM_ENVELOPE_OBJECT` | “&lt;where&gt;: transform field "envelope" is &lt;JSON.stringify(envelope)&gt;; it is an object — a ramp `{ "axis", "from", "to", "shape" }` or a mask `{ "mask" }`” | Write envelope as a ramp object or a mask object. |
 | <a id="CE_DEFORM_ENVELOPE_MASK_RAMP_CONFLICT"></a>`CE_DEFORM_ENVELOPE_MASK_RAMP_CONFLICT` | “&lt;where&gt;: transform field "envelope" states "mask" &lt;JSON.stringify(e.mask)&gt; beside the ramp's &lt;rampStated.map((f) =&gt; `"${f}"`).join(', ')&gt;. They are two answers to one question — what weight each vertex takes — and a key carrying both leaves a reader unable to say which one the output came from. Drop one.”<br>Here the values named in the message include: “axis”, “shape”. | Choose envelope.mask or the ramp fields and remove the other form. |
@@ -7649,6 +7679,7 @@ retain the minimal inputs and report that code rather than inventing author data
 | <a id="CE_TRACK_DERIVE_OBJECT"></a>`CE_TRACK_DERIVE_OBJECT` | “&lt;where&gt;: "derive" is &lt;JSON.stringify(derive)&gt;; it is an object with a "kind"” | Write derive as an object with a kind. |
 | <a id="CE_TRACK_DERIVE_KIND"></a>`CE_TRACK_DERIVE_KIND` | “&lt;where&gt;: "derive" has kind &lt;JSON.stringify(kind)&gt;; this spec evaluates &lt;TRACK_DERIVE_KINDS.join(', ')&gt;. A model that is none of those is still authorable as a per-member "v" map, or as one track per member.”<br>Here the values named in the message include: “yaw”, “pitch”. | Use a supported derive kind, a per-member v map, or one authored track per member. |
 | <a id="CE_TRACK_CARRIED_PROJECTION"></a>`CE_TRACK_CARRIED_PROJECTION` | “&lt;where&gt;: derive &lt;kind&gt; states carried=&lt;JSON.stringify(turn.carried)&gt; on a "&lt;property&gt;" track, and the foreshortening reads no depth difference — it is cos(α − t)/cos α, where α is the member's own angle off the axis. "carried" belongs on the "&lt;projections.shift&gt;" track, whose shared shift is the thing it names.” | Put carried on the displacement projection rather than the foreshortening track. |
+| <a id="CE_TRACK_NARROWING_PROJECTION"></a>`CE_TRACK_NARROWING_PROJECTION` | “&lt;where&gt;: derive &lt;kind&gt; states narrowing=&lt;JSON.stringify(turn.narrowing)&gt; on a "&lt;property&gt;" track, and a "&lt;property&gt;" track IS the foreshortening — its whole output is cos(α − t)/cos α. "narrowing" belongs on the "&lt;projections.shift&gt;" track, where it drops (&lt;projections.coordinate&gt;−about)·(cos t − 1) from the displacement; to turn without narrowing the plate's scale, omit the "&lt;property&gt;" track.” | Put narrowing on the displacement projection rather than the foreshortening track, or omit the foreshortening track. |
 | <a id="CE_TRACK_FORESHORTEN_DEPTH"></a>`CE_TRACK_FORESHORTEN_DEPTH` | “&lt;where&gt;: derive &lt;kind&gt; projects onto "&lt;property&gt;" and member "&lt;member.name&gt;" states depth &lt;depth&gt;. Foreshortening is cos(α − t)/cos α with α = atan2(coordinate, depth), which needs the part to be IN FRONT of the axis; at or behind it there is no front surface to narrow. A part behind the axis still takes the "&lt;projections.shift&gt;" projection, where a negative depth is exactly what swings it the other way.” | State positive depth for the foreshortening projection; negative depth belongs to displacement. |
 | <a id="CE_TRACK_FORESHORTEN_EDGE_ON"></a>`CE_TRACK_FORESHORTEN_EDGE_ON` | “&lt;where&gt;: derive &lt;kind&gt; turns member "&lt;member.name&gt;" (&lt;projections.coordinate&gt;=&lt;u&gt;, depth=&lt;depth&gt;) past its own edge: α = &lt;round(alpha)&gt; rad and the turn is &lt;round(rad)&gt; rad, so cos(α − t) is &lt;round(Math.cos(alpha - rad))&gt; and the scale would be &lt;round(scale)&gt;. A scale at or below 0 mirrors the drawing rather than narrowing it. The part has turned edge-on — the turn is past what this construction carries, and FACE §8 is the page that picks a construction from the angle.” | Keep the turn within this construction's positive scale range or choose the construction described in FACE §8. |
 | <a id="CE_TRACK_PROPERTY_PROJECTION"></a>`CE_TRACK_PROPERTY_PROJECTION` | “&lt;where&gt;: derive &lt;kind&gt; has no projection onto "&lt;property&gt;". It projects onto "&lt;p.shift&gt;" (the displacement, FACE §3) and "&lt;p.foreshorten&gt;" (the narrowing, FACE §5), and onto nothing else — a turn about one axis moves nothing along it, so a paired "translate"/"scale" would need a second channel this model does not state. State the axis, or write the values as a per-member "v" map.” | Use the derive kind's printed displacement or foreshortening property, or a per-member v map. |
@@ -7718,7 +7749,7 @@ retain the minimal inputs and report that code rather than inventing author data
 
 | Code | Fixed message text and alternatives | What to change |
 | --- | --- | --- |
-| <a id="CE_KEYS_UNKNOWN_FIELD"></a>`CE_KEYS_UNKNOWN_FIELD` | “&lt;where&gt;: &lt;what&gt; has &lt;strays.length === 1 ? 'a key' : `${strays.length} keys`&gt; this compiler does not read: &lt;named.join(', ')&gt;. Nothing reads such a key, so it would be dropped from the emitted skeleton in silence — fix the spelling or remove it. {This shape has no fields at all. / Known here: &lt;[...known].sort().join(', ')&gt;.}”<br>“{"&lt;key&gt;" / "&lt;key&gt;" (did you mean &lt;near.map((n) =&gt; `"${n}"`).join(', ')&gt;?)}”<br>Also: “skin "&lt;value&gt;" slot "&lt;value&gt;" attachment "&lt;value&gt;"”<br>“&lt;value&gt; generator.bones[&lt;value&gt;]”<br>“{constraint "&lt;value&gt;" / constraints[&lt;value&gt;]}”<br>“&lt;value&gt;.transform.envelope”<br>“&lt;value&gt; weights[&lt;value&gt;][&lt;value&gt;]”<br>“invariants.deformMayFold[&lt;value&gt;]”<br>“animations."&lt;value&gt;"”<br>“&lt;value&gt;.offsets[&lt;value&gt;]”<br>“{stop "&lt;value&gt;" / stops[&lt;value&gt;]}”<br>“&lt;value&gt; properties."&lt;value&gt;".to."&lt;value&gt;"”<br>“this rig spec”<br>“&lt;value&gt;.derive”<br>“setup."&lt;value&gt;"”<br>“physics."&lt;value&gt;"”<br>“&lt;value&gt;'s "lower"”<br>“&lt;value&gt; "sequence"”<br>“&lt;value&gt; generator.bias”<br>“&lt;value&gt; generator.depth”<br>“&lt;value&gt;.events[&lt;value&gt;]”<br>“&lt;value&gt;.tracks[&lt;value&gt;]”<br>“invariants.axes[&lt;value&gt;]”<br>“&lt;value&gt; generator.falloff”<br>“&lt;value&gt;.drawOrder[&lt;value&gt;]”<br>“&lt;value&gt; generator.influence”<br>“invariants.detached[&lt;value&gt;]”<br>“{slot "&lt;value&gt;" / slots[&lt;value&gt;]}”<br>“invariants.consumerDrivenMix[&lt;value&gt;]”<br>“event "&lt;value&gt;"”<br>“&lt;value&gt;'s "from"”<br>“this motion spec”<br>“{absent / &lt;value&gt;}”<br>“{region / &lt;value&gt;}”<br>“&lt;value&gt;.keys[&lt;value&gt;]”<br>“&lt;value&gt; generator.soft”<br>“{linkedmesh / &lt;value&gt;}”<br>“&lt;value&gt;.deform[&lt;value&gt;]”<br>“&lt;value&gt;.sequence[&lt;value&gt;]”<br>“&lt;value&gt; generator (&lt;value&gt;)”<br>“{bone "&lt;value&gt;" / bones[&lt;value&gt;]}”<br>Here the values named in the message include: “uvs”, “mixX”, “blend”, “scaleX”, “groups”, “radius”, “images”, “axisBone”, “maxBones”, “massBone”, “softness”, “timelines”, “archetype”, “rotateMode”, “windGlobal”, “localTarget”, “spacingMode”, “positionMode”, “inertiaGlobal”, “dampingGlobal”, “gravityGlobal”, “strengthGlobal”, “skeleton.stageBox”, “invariants.idleDrivesMeshes”, “ik”, “lag”, “why”, “cut”, “fps”, “icon”, “dark”, “cols”, “kind”, “hull”, “cell”, “path”, “loop”, “mask”, “ease”, “ramp”, “note”, “mode”, “size”, “rows”, “mixY”, “alpha”, “pairs”, “inner”, “curve”, “limit”, “edges”, “float”, “start”, “audio”, “along”, “clamp”, “width”, “skins”, “links”, “chain”, “phase”, “about”, “power”, “count”, “color”, “gamma”, “index”, “delay”, “shearY”, “source”, “convex”, “target”, “amount”, “volume”, “shearX”, “slider”, “string”, “center”, “parent”, “closed”, “zScale”, “inward”, “margin”, “across”, “height”, “digits”, “scaleY”, “anchor”, “degrees”, “inverse”, “stretch”, “easings”, “against”, “default”, “inherit”, “lengths”, “carried”, “balance”, “stagger”, “outward”, “through”, “vertices”, “axis_deg”, “contrast”, “compress”, “notUnder”, “property”, “duration”, “controls”, “additive”, “rotation”, “triangles”, “mixScaleY”, “mixScaleX”, “mixShearY”, “tolerance”, “mixRotate”, “meshSlots”, “minWeight”, “mixGlobal”, “amplitude”, “massGlobal”, “meshCenter”, “fromVertex”, “slotWindow”, “wavelength”, “"skeleton"”, “attachments”, “vertexCount”, “maxVertices”, “localSource”, “"invariants"”, “bendPositive”, “boneIndexing”, “constantSpeed”, “meshTriangles”, “referenceScale”. | Fix each printed stray key's spelling using the suggested or known names, or remove it. |
+| <a id="CE_KEYS_UNKNOWN_FIELD"></a>`CE_KEYS_UNKNOWN_FIELD` | “&lt;where&gt;: &lt;what&gt; has &lt;strays.length === 1 ? 'a key' : `${strays.length} keys`&gt; this compiler does not read: &lt;named.join(', ')&gt;. Nothing reads such a key, so it would be dropped from the emitted skeleton in silence — fix the spelling or remove it. {This shape has no fields at all. / Known here: &lt;[...known].sort().join(', ')&gt;.}”<br>“{"&lt;key&gt;" / "&lt;key&gt;" (did you mean &lt;near.map((n) =&gt; `"${n}"`).join(', ')&gt;?)}”<br>Also: “skin "&lt;value&gt;" slot "&lt;value&gt;" attachment "&lt;value&gt;"”<br>“&lt;value&gt; generator.bones[&lt;value&gt;]”<br>“{constraint "&lt;value&gt;" / constraints[&lt;value&gt;]}”<br>“&lt;value&gt;.transform.envelope”<br>“&lt;value&gt; weights[&lt;value&gt;][&lt;value&gt;]”<br>“invariants.deformMayFold[&lt;value&gt;]”<br>“animations."&lt;value&gt;"”<br>“&lt;value&gt;.offsets[&lt;value&gt;]”<br>“{stop "&lt;value&gt;" / stops[&lt;value&gt;]}”<br>“&lt;value&gt; properties."&lt;value&gt;".to."&lt;value&gt;"”<br>“this rig spec”<br>“&lt;value&gt;.derive”<br>“setup."&lt;value&gt;"”<br>“physics."&lt;value&gt;"”<br>“&lt;value&gt;'s "lower"”<br>“&lt;value&gt; "sequence"”<br>“&lt;value&gt; generator.bias”<br>“&lt;value&gt; generator.depth”<br>“&lt;value&gt;.events[&lt;value&gt;]”<br>“&lt;value&gt;.tracks[&lt;value&gt;]”<br>“invariants.axes[&lt;value&gt;]”<br>“&lt;value&gt; generator.falloff”<br>“&lt;value&gt;.drawOrder[&lt;value&gt;]”<br>“&lt;value&gt; generator.influence”<br>“invariants.detached[&lt;value&gt;]”<br>“{slot "&lt;value&gt;" / slots[&lt;value&gt;]}”<br>“invariants.consumerDrivenMix[&lt;value&gt;]”<br>“event "&lt;value&gt;"”<br>“&lt;value&gt;'s "from"”<br>“this motion spec”<br>“{absent / &lt;value&gt;}”<br>“{region / &lt;value&gt;}”<br>“&lt;value&gt;.keys[&lt;value&gt;]”<br>“&lt;value&gt; generator.soft”<br>“{linkedmesh / &lt;value&gt;}”<br>“&lt;value&gt;.deform[&lt;value&gt;]”<br>“&lt;value&gt;.sequence[&lt;value&gt;]”<br>“&lt;value&gt; generator (&lt;value&gt;)”<br>“{bone "&lt;value&gt;" / bones[&lt;value&gt;]}”<br>Here the values named in the message include: “uvs”, “mixX”, “blend”, “scaleX”, “groups”, “radius”, “images”, “axisBone”, “maxBones”, “massBone”, “softness”, “timelines”, “archetype”, “rotateMode”, “windGlobal”, “localTarget”, “spacingMode”, “positionMode”, “inertiaGlobal”, “dampingGlobal”, “gravityGlobal”, “strengthGlobal”, “skeleton.stageBox”, “invariants.idleDrivesMeshes”, “ik”, “lag”, “why”, “cut”, “fps”, “icon”, “dark”, “cols”, “kind”, “hull”, “cell”, “path”, “loop”, “mask”, “ease”, “ramp”, “note”, “mode”, “size”, “rows”, “mixY”, “alpha”, “pairs”, “inner”, “curve”, “limit”, “edges”, “float”, “start”, “audio”, “along”, “clamp”, “width”, “skins”, “links”, “chain”, “phase”, “about”, “power”, “count”, “color”, “gamma”, “index”, “delay”, “shearY”, “source”, “convex”, “target”, “amount”, “volume”, “shearX”, “slider”, “string”, “center”, “parent”, “closed”, “zScale”, “inward”, “margin”, “across”, “height”, “digits”, “scaleY”, “anchor”, “degrees”, “inverse”, “stretch”, “easings”, “against”, “default”, “inherit”, “lengths”, “carried”, “balance”, “stagger”, “outward”, “through”, “vertices”, “axis_deg”, “contrast”, “compress”, “notUnder”, “property”, “duration”, “controls”, “additive”, “rotation”, “triangles”, “mixScaleY”, “mixScaleX”, “mixShearY”, “tolerance”, “mixRotate”, “meshSlots”, “minWeight”, “mixGlobal”, “amplitude”, “massGlobal”, “meshCenter”, “fromVertex”, “slotWindow”, “wavelength”, “"skeleton"”, “attachments”, “vertexCount”, “maxVertices”, “localSource”, “"invariants"”, “bendPositive”, “boneIndexing”, “constantSpeed”, “meshTriangles”, “referenceScale”, “narrowing”. | Fix each printed stray key's spelling using the suggested or known names, or remove it. |
 | <a id="CE_KEYS_NUMBER_FLOAT32_FINITE"></a>`CE_KEYS_NUMBER_FLOAT32_FINITE` | “&lt;where&gt;: &lt;place(path)&gt; is &lt;String(node)&gt;; a number in this file is finite at float32 precision, at most ±&lt;String(FLOAT32_MAX)&gt;, because the skeleton is written as float32 — past that it would be emitted as Infinity, which JSON writes as null, a value the file never stated.&lt;why&gt;”<br>“{ / { This one is finite as a double and has no float32 but Infinity. /  JSON has no spelling for Infinity: a literal past ±1.7976931348623157e308, such as 1e309, parses to it.}}” | State a finite number whose float32 rounding stays finite; inspect the printed path and magnitude. |
 | <a id="CE_KEYS_FIELD_VALUE_TYPE"></a>`CE_KEYS_FIELD_VALUE_TYPE` | “&lt;where&gt;: &lt;visit.name([key, ...wrong.tail])&gt; is &lt;typeFound(wrong.value)&gt;; &lt;wrong.required&gt; is required”<br>“a boolean (true or false)”<br>“a number”<br>“a number or null”<br>“a string”<br>“a string or null”<br>“an array of arrays of numbers”<br>“an array of numbers”<br>“an array of numbers, or null”<br>“an array of strings”<br>“an object whose every value is a string or null”<br>“an object whose every value is an array of numbers”<br>“an object whose every value is an array of strings” | Replace the named field or element with the required JSON type printed in the message. |
 | <a id="CE_KEYS_ENUM_VALUE"></a>`CE_KEYS_ENUM_VALUE` | “&lt;where&gt;: &lt;visit.name([key])&gt; is &lt;JSON.stringify(value) ?? String(value)&gt;; one of &lt;rule.set.map((name) =&gt; JSON.stringify(name)).join(', ')&gt; — &lt;rule.readAs&gt;”<br>“anything else was read as a ribbon by the mesh checks and as a ring by the control-bone reader and the geometry builder, so the refusal it got named a fault the part did not have”<br>“anything else was read as no rotation source, and the bone was emitted without the setup rotation it asked for”<br>“anything else was read as the default "name" in silence: a weighted "vertices" run was refused as unflagged, and every other attachment built byte for byte as if the key were absent” | Choose one of the printed names for the named field; the readAs explanation describes why another spelling changes its meaning. |
@@ -9060,6 +9091,23 @@ Draw order does not enter: a cell is covered or bare whichever piece is in front
 An owner says which piece drew a ghost cell; it does not say which piece is over
 or under the other, or whether that exposure should fail a consumer's policy.
 
+**Outside the overlap hull is outside the gap reading.** Both `gap` and its
+`gapOpen` partition are judged only inside the carried setup-overlap hull. Art
+that reaches beyond a joint disc, such as a drape over an elbow, can break
+outside that hull without a gap being reported. A gap of 0 is never a statement
+that the seam is closed outside the hull; inspect `ghost` and the actual frames
+too. Ghost independently names one-sided exposure of the carried setup overlap,
+not every visible break in the silhouette.
+
+In the public [draped-sleeve fixture](https://github.com/rig-c/parts/blob/0628d7bc311a2b548edf7a11e8407546357d4b4d/fixtures/hybrid_limb.ts),
+measured on core `f273358` at both −30° and +30°, the hard cut reads `gap = 0`,
+`gapOpen = 0`, `ghost = 8` cells; the hybrid's two interfaces read 0 in all three
+classes. The [cell overlay](https://github.com/rig-c/core/blob/570a2954747780a2169fa6036eebe53f3ea66f2a/bench/studies/2026-10-25-seam-reach/evidence/cut-endpoint-cell-overlay.png)
+shows the notch and flap excluded outside the hull, while ghost names different
+cells on the joint rim. The [measurement receipt](https://github.com/rig-c/core/blob/570a2954747780a2169fa6036eebe53f3ea66f2a/bench/studies/2026-10-25-seam-reach/evidence/receipt.json)
+pins the inputs, commands and frame digest; these are seam cells, not display
+pixels. See [#1575](https://github.com/rig-c/core/issues/1575) for the reading.
+
 **Its reach, stated.** A piece folded right back over its partner carries the band
 across the region it vacated, so a hull that wide reads the vacated cells its
 partner's view still finds drawn. And no size is too small to print: on
@@ -12442,3 +12490,90 @@ calls, with the independent linked mesh selected, agree exactly. The API's
 nonselected output is the stored source geometry through the unchanged setup
 matrices; it does not borrow a different selection's deform. The control
 checks both results and the source of the difference, without an epsilon.
+
+## 15. Posing in place for a player — the runtime poser (stage 0)
+
+rigc poses a model document twice over, on purpose (issue #1591). The **oracle**
+(`src/core/`) is the reference: each pose is a pure function of the document,
+the skin and the time, returned as a fresh, name-keyed, detached record, and it
+is the poser `tools/core_gate.ts` holds to spine-core 4.3.13 at tolerance 0. The
+**runtime poser** (`src/runtime/`) is for a player drawing many skeletons a
+frame: it resolves every name to an index once at load and overwrites typed
+arrays in place, so a steady-state frame allocates nothing. It computes every
+value with the oracle's own formulas in the oracle's order of operations, and it
+is held equal to the oracle at tolerance 0 rather than trusted; the oracle is not
+changed for it. It is imported from `rig-c/runtime`, an **experimental** entry
+(RELEASING.md, *The import surface*): not promised until it stabilises, so a
+minor may reshape it and a dependant pins an exact version.
+
+```ts
+import { readModel, underNoSkin } from 'rig-c/core';
+import { compileRuntime, RuntimePose, RuntimeRefusal } from 'rig-c/runtime'; // experimental
+
+const view = underNoSkin(readModel(modelText));
+const model = compileRuntime(view, { ignore: ['events'] }); // throws RuntimeRefusal, every missing construct named
+const pose = new RuntimePose(model);                         // every buffer allocated here, once
+pose.setAnimation('walk');                                   // a refused animation throws its RuntimeRefusal
+pose.step(1 / 60);                                           // or pose.apply(t) at an animation time
+pose.computeVertices();
+// pose.world: 6 numbers per bone (a, b, c, d, worldX, worldY — W_A … W_Y), y up
+// pose.light: 4 per slot; pose.shown: per slot an index into model.attachments, or −1
+// pose.vertices: model.attachments[i].count numbers at model.attachments[i].offset
+```
+
+Each `model.attachments[i]` also carries readonly `skin` and `placeholder`: the
+exact resolved table identity `(skin, model.slots[attachment.slot].name, placeholder)`.
+The display `name` may be shared by different placeholders; it is never a table
+key to guess the source from. These load-time strings do not change the pose path.
+
+| | what stage 0 poses |
+| --- | --- |
+| bones | local and world transforms, all five inherit modes, skin-required bones under the view's skin (an inactive bone is zeros, as the oracle poses it) |
+| timelines | `rotate`, `translate(x/y)`, `scale(x/y)`, `shear(x/y)`; a slot's `attachment`, `rgba`, `rgb` and `alpha`; ik and transform timelines; linear, stepped and Bézier keys, each read from a per-pose key cursor |
+| constraints | one- and two-bone ik; world-space, absolute transform constraints; the document's order, each followed by the bones below what it moved posed again |
+| vertices | regions, meshes, weighted meshes and linked meshes, written into the pose's buffer |
+| time | one animation at full weight from the setup pose, at a time (`apply`) or stepped as a looping track (`step`, the track time wrapped by the duration as `openTrack` wraps it) |
+
+**Everything else is refused at load, by name.** `RuntimeRefusal.missing` lists
+every construct met, each `{ feature, detail, animation }`, and the message
+reads `not posed by the runtime poser (stage 0), N construct(s) missing:
+<feature>: <detail>; …`. A model-level feature refuses the whole model; an
+animation-level one refuses that animation alone (`model.refused`;
+`model.animation(name)` and `setAnimation(name)` throw its refusal) and every
+other animation is posed. Fall back to the oracle (`openTrack`) for what is
+refused: nothing is posed approximately.
+
+| feature | refuses | what it is |
+| --- | --- | --- |
+| `skin` | the model | a skin other than `default` |
+| `path-constraint`, `physics-constraint`, `slider-constraint` | the model | a constraint of that kind |
+| `local-transform`, `additive-transform` | the model | a transform constraint with `localSource` or `localTarget`, or `additive` |
+| `inactive-constrained-bone` | the model | an applied ik or transform constraint naming a bone the view leaves inactive (what the oracle writes there depends on the pass before) |
+| `noscale-world-target` | the model | a world-space transform onto a `noScale` or `noScaleOrReflection` bone, whose local values would be read back in that mode |
+| `clipping`, `null-atlas-region` | the model when shown at setup, else the animation that keys it | a clipping attachment; a region whose atlas rectangle the model states as `null` |
+| `skin-conflict` | as above | a placeholder the skins fill differently |
+| `oracle-absent` | the model | a pose the oracle itself leaves out (`constraintsAbsentWhy`) |
+| `inherit-timeline`, `deform-timeline`, `sequence-timeline`, `draw-order-timeline`, `dark-colour-timeline` | the animation | a timeline of that kind (`dark-colour` is `rgba2` / `rgb2`) |
+| `events` | the animation, unless `ignore: ['events']` | event keys. Events move no pose, so a consumer that reads none may ask for them to be ignored and is handed a poser that fires none; without the request a dropped cue would be silent |
+
+A call it cannot answer throws `RuntimeInputError`, naming the call:
+`apply: no animation is set (setAnimation first)`, `animation "x" is not one of
+this document's [...]`, `apply: the time NaN is not finite`.
+
+**The gate.** `tools/core_gate.ts` runs a third dumper (`runtimeDump` in
+`tools/pose_oracle.ts`) over every row it builds, at the oracle's samples, and
+compares its document with the oracle's in full doubles at tolerance 0 twice:
+through `compare` and cell by cell (which reads the bones `compare`'s
+ill-conditioned rule leaves out). One `RUNTIME` line per row reads `IDENTICAL`
+(covered whole and equal), `SKIP` (refused at load, or animations or events left
+out — every one named), `DIFF` (the first value that differs) or `REFUSED`; then
+one `RUNTIME SKIP feature <name>` line per feature with the rows it refused, a
+`HOLE` line when no row is covered whole or nothing was compared, and `RUNTIME
+GREEN|RED`, counting rows covered whole, covered in part and refused at load, and
+the poses and values compared. A `DIFF` or `REFUSED` turns the run RED; a SKIP
+never counts as a pass. The page UVs are the atlas's and are compared by neither
+side here. The selftest's `runtime-poser` suite holds the gate to its plants (a
+1e-6° bone perturbation, a weighted binding bound to the wrong bone index, a
+refused feature smuggled through — each caught by name), a seeded population of
+every construct above, the looping step against `openTrack`, and a steady-state
+frame measured at 0 bytes with the collector off.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.70.0",
+  "version": "2.71.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": {
@@ -19,6 +19,7 @@
     "./errors": "./src/errors.ts",
     "./meshcompare": "./src/meshcompare.ts",
     "./core": "./src/core/entry.ts",
+    "./runtime": "./src/runtime/index.ts",
     "./cli": "./cli.ts",
     "./package.json": "./package.json",
     "./*.ts": "./*.ts",

package/src/assertions/report.ts

@@ -20,7 +20,7 @@ export const VALIDATE_PROFILES: readonly AssertionProfile[] = ['spine', 'rig-pla
  * 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}`;
+  return `rigc: --profile ${alias} is deprecated and reads as --profile ${target}, the same rules; it is accepted until the next major release — pass --profile ${target}`;
 }
 
 /**

package/src/compile.ts

@@ -3015,6 +3015,46 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // The same for a `soft` mask's per-vertex level, which a deform envelope's
   // `mask` reads (issue #1413). Never emitted either.
   const attachmentSoftMasks = new Map<string, DeformSoftMask>();
+  // `skin/slot/attachment` -> per-axis narrowing mode when a deform turn key on
+  // that attachment declares `narrowing: false` (issue #1584), so `sampleMeshDepth`
+  // evaluates `turnCeiling` with the `asin(|A₀ / A_axis|)` closed form that
+  // matches `A39` on the keyed turn.
+  const attachmentTurnNarrowing = new Map<string, { yaw?: boolean; pitch?: boolean }>();
+  const attachmentTurnNarrowingBy = new Map<string, { yaw?: { mode: boolean; anim: string }; pitch?: { mode: boolean; anim: string } }>();
+  withMotionSource(() => {
+    for (const [turnAnimName, turnAnim] of Object.entries(motion.animations ?? {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))) {
+      for (const turnTrack of turnAnim.deform ?? []) {
+        const turnDeformSkin = turnTrack.skin ?? DEFAULT_SKIN;
+        const turnTriple = `${turnDeformSkin}/${turnTrack.slot}/${turnTrack.attachment}`;
+        for (const turnKey of turnTrack.keys ?? []) {
+          const turnSpec = turnKey.transform as { kind?: unknown; narrowing?: unknown } | undefined;
+          if (turnSpec && (turnSpec.kind === 'yaw' || turnSpec.kind === 'pitch')) {
+            const turnAxis = turnSpec.kind;
+            const turnNarrowMode = turnSpec.narrowing !== false;
+            const turnPrev = attachmentTurnNarrowingBy.get(turnTriple)?.[turnAxis];
+            if (turnPrev !== undefined && turnPrev.mode !== turnNarrowMode) {
+              const turnFalseAnim = turnNarrowMode ? turnPrev.anim : turnAnimName;
+              const turnTrueAnim = turnNarrowMode ? turnAnimName : turnPrev.anim;
+              throw new CompileError(
+                `deform ${turnTriple} keys "${turnAxis}" with narrowing=false in animation "${turnFalseAnim}" and with narrowing=true in animation "${turnTrueAnim}". ` +
+                  'An attachment\'s turn ceiling on one axis is either asin(|A₀ / A_axis|) (without narrowing) or atan(|A₀ / A_axis|) (with narrowing) — ' +
+                  `mixing both on one attachment and axis would report one ceiling where two apply. Use one "narrowing" setting across every "${turnAxis}" key on ${turnTriple}.`,
+                'CE_COMPILE_DEFORM_TURN_NARROWING_MIXED',
+              );
+            }
+            const curBy = attachmentTurnNarrowingBy.get(turnTriple) ?? {};
+            if (curBy[turnAxis] === undefined) curBy[turnAxis] = { mode: turnNarrowMode, anim: turnAnimName };
+            attachmentTurnNarrowingBy.set(turnTriple, curBy);
+            if (!turnNarrowMode) {
+              const cur = attachmentTurnNarrowing.get(turnTriple) ?? {};
+              cur[turnAxis] = false;
+              attachmentTurnNarrowing.set(turnTriple, cur);
+            }
+          }
+        }
+      }
+    }
+  });
 
   for (const rigSlot of rig.slots) {
     const part = partBySlot.get(rigSlot.name);
@@ -3183,6 +3223,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           imagesDir,
           depths: attachmentDepths,
           softMasks: attachmentSoftMasks,
+          turnNarrowing: attachmentTurnNarrowing.get(`${skinName}/${rigSlot.name}/${placeholder}`),
           slotNames: new Set(rig.slots.map((s) => s.name)),
           atlasRegions: atlasIn === null ? null : atlasIn.byName,
           links: pendingLinks,
@@ -4333,6 +4374,12 @@ interface AttachmentContext {
    * emitted, for `depths`' reason.
    */
   softMasks: Map<string, DeformSoftMask>;
+  /**
+   * Per-axis `narrowing` mode when a deform turn key on this attachment states
+   * `"narrowing": false` (issue #1584), so `sampleMeshDepth` computes the turn
+   * ceiling with `asin(|A₀ / A_axis|)` on that axis.
+   */
+  turnNarrowing?: { yaw?: boolean; pitch?: boolean };
   /** Every slot the rig declares — a clipping attachment's `end` resolves here. */
   slotNames: Set<string>;
   /**
@@ -6324,6 +6371,7 @@ function sampleMeshDepth(
         points.map(([px, py]) => toBind(px, py)),
         z,
         triangles,
+        ctx.turnNarrowing === undefined ? undefined : { narrowing: ctx.turnNarrowing },
       ),
     },
   };

package/src/core/animation.ts

@@ -189,11 +189,12 @@ import {
   foldInheritMode,
   gridRound,
   readBlend,
-  readColour,
   shownAttachment,
   shownRow,
   slidersKeyingWhy,
   sourceOfDoc,
+  viewColours,
+  WHITE,
   type CompiledDocument,
   type CoreAnimation,
   type CoreBoneRow,
@@ -834,12 +835,15 @@ export function posedSlots(
   /** Filled with each slot's placeholder once the sample's own timelines have moved it, before the sliders — what the attachments are posed from (`attachmentStates`). */
   placeholders?: Map<string, string | null>,
 ): { rows: CoreSlotRow[]; conflicts: string[] } {
-  const colour = plant.colour ?? readColour;
+  // The view's stated colours, read once (`viewColours`); a planted reader of the light colour is called as it always was.
+  const stated = viewColours(doc);
+  const colour = plant.colour ?? stated;
   const byName = new Map(timelines.slots.map((s) => [s.name, s]));
   return slotRowsFrom(doc, plant, sliders, placeholders, (slot, live) => {
     let placeholder = slot.setup;
-    const light = slot.color === undefined ? [1, 1, 1, 1] : colour(slot.color);
-    const setupDark = slot.dark === undefined ? null : readColour(slot.dark);
+    const setupLight = slot.color === undefined ? WHITE : colour(slot.color);
+    const light = [setupLight[0], setupLight[1], setupLight[2], setupLight[3]];
+    const setupDark = slot.dark === undefined ? null : stated(slot.dark);
     const dark = setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]];
     for (const tl of live ? (byName.get(slot.name)?.timelines ?? []) : []) {
       if (tl.kind === 'attachment') {
@@ -848,7 +852,6 @@ export function posedSlots(
         continue;
       }
       const v = valuesAt(tl.keys, t, plant);
-      const setupLight = slot.color === undefined ? [1, 1, 1, 1] : colour(slot.color);
       const channels = SLOT_COLOUR_TIMELINES[tl.kind].channels;
       channels.forEach((name, i) => {
         const at = { r: 0, g: 1, b: 2, a: 3, r2: 4, g2: 5, b2: 6 }[name];
@@ -955,15 +958,22 @@ export function posedBoneRows(doc: CompiledDocument, timelines: CoreAnimationTim
 /** `posedBoneRows`, with the world transforms the rows were read off — what the sample's attachments are posed through. */
 export function posedBoneWorld(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant = {}, constraints?: CoreConstraintTimelines, sliders?: SliderApplication[], step?: PoseStep): { rows: CoreBoneRow[]; world: Map<string, CoreWorld> } {
   const posed = posedBoneStep(doc, timelines, t, plant, constraints, sliders, step);
-  return { rows: stepRows(posed), world: posed.world };
+  const stage = plant.stage;
+  if (stage !== undefined) stage.begin('readout');
+  const rows = stepRows(posed);
+  if (stage !== undefined) stage.end('readout');
+  return { rows, world: posed.world };
 }
 
 /**
  * `posedBoneWorld`'s world transforms without its rows (issue #1179, the
  * second part): the same pose by the same operations in the same order, since
  * `stepRows` only reads the world once it is posed. A walk reads `world` and
- * no row, so the scan's walk (`scanWalkIn` in `./raw.ts`, A10's) asks for
- * this; the raw entry's walk still forms the rows it does not read, unchanged.
+ * no row, so every walk asks for this — the scan's (`scanWalkIn` in
+ * `./raw.ts`, A10's), the raw entry's batch walks and the live track's step.
+ * The rows were the only thing the other variant adds, and their rounding
+ * (`rawNumber`, `keptNumber`) refuses nothing, so leaving them out moves no
+ * number and no refusal of a walk.
  */
 export function posedBoneWorldAlone(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant, constraints: CoreConstraintTimelines | undefined, sliders: SliderApplication[] | undefined, step: PoseStep | undefined): Map<string, CoreWorld> {
   return posedBoneStep(doc, timelines, t, plant, constraints, sliders, step).world;
@@ -997,20 +1007,34 @@ function stepRows(posed: PosedStep): CoreBoneRow[] {
 
 /** `posedBoneWorld` up to its rows, refusing a bone the evaluator gave no transform (`PosedStep`). */
 function posedBoneStep(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant, constraints: CoreConstraintTimelines | undefined, sliders: SliderApplication[] | undefined, step: PoseStep | undefined): PosedStep {
+  const stage = plant.stage;
+  if (stage !== undefined) stage.begin('timeline');
   const bones = posedBones(doc, timelines, t, plant);
+  if (stage !== undefined) stage.end('timeline');
   // One step of the stepped phase (issue #956, `./constraints_physics.ts`): the physics records posed by their timelines and stepped under the walk's context; the deformed curve a path walks as above.
-  if (constraints !== undefined && step !== undefined) return steppedLocals(doc, bones, plant, () => pathDeformed(doc, posedRecords(constraintRecords(doc), constraints, t), timelines, t, plant), constraints.physicsKeyed ?? [], t, sliders, step);
+  if (constraints !== undefined && step !== undefined) {
+    return steppedLocals(doc, bones, plant, () => pathDeformed(doc, posedRecords(constraintRecords(doc), constraints, t), timelines, t, plant), constraints.physicsKeyed ?? [], t, sliders, step);
+  }
   const active = activeBones(doc);
   // The caller's adjustment, after the timelines and before anything reads the locals (`LocalAdjust`).
-  if (step?.adjustment !== undefined) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
-  let world = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (step?.adjustment !== undefined) {
+    if (stage !== undefined) stage.begin('timeline');
+    adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
+    if (stage !== undefined) stage.end('timeline');
+  }
+  if (stage !== undefined) stage.begin('world');
+  const initialWorld = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (stage !== undefined) stage.end('world');
+  let world = initialWorld;
   if (constraints !== undefined) {
+    if (stage !== undefined) stage.begin('constraints');
     const setupRecords = constraintRecords(doc);
     // A path walks the curve the sample's deform timelines left on its slot (`./deform.ts`); a slider's deform of a walked path leaves the bones out (`pathAnimationsWhy`).
     const records = pathDeformed(doc, posedRecords(setupRecords, constraints, t), timelines, t, plant);
     // A path constraint may read a slot bone the runtime has not yet brought up to date in this pass, as the previous pass left it (`./constraints_path.ts`, *Which slot bone*); `poseAnimations` holds that pass to the setup pose's reading.
     const previous = setupRecords.some((r) => r.kind === 'path') ? applyConstraints(doc.bones, (plant.evaluate ?? worldTransforms)(doc.bones, active), active, plant.constraints ? plant.constraints(setupRecords) : setupRecords, null, undefined, undefined, undefined, solverRules(plant.solver)) : null;
-    world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(records) : records, previous, sliders, undefined, undefined, solverRules(plant.solver));
+    world = applyConstraints(bones, initialWorld, active, plant.constraints ? plant.constraints(records) : records, previous, sliders, undefined, undefined, solverRules(plant.solver));
+    if (stage !== undefined) stage.end('constraints');
   }
   for (const b of bones) if (world.get(b.name) === undefined) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
   return { bones, world, active, round: plant.round ?? gridRound };
@@ -1027,27 +1051,35 @@ function posedBoneStep(doc: CompiledDocument, timelines: CoreAnimationTimelines,
  * past the timelines for both.
  */
 function steppedLocals(doc: CompiledDocument, bones: ModelBone[], plant: TimelinePlant, records: () => CoreConstraintRecord[], physicsKeyed: NonNullable<CoreConstraintTimelines['physicsKeyed']>, t: number, sliders: SliderApplication[] | undefined, step: PoseStep): PosedStep {
+  const stage = plant.stage;
   const active = activeBones(doc);
   // The caller's adjustment, after the timelines and before anything reads the locals (`LocalAdjust`).
-  if (step.adjustment !== undefined) adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
-  let world = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (step.adjustment !== undefined) {
+    if (stage !== undefined) stage.begin('timeline');
+    adjustLocals(doc, bones, step.adjustment.callback, step.adjustment.context);
+    if (stage !== undefined) stage.end('timeline');
+  }
+  if (stage !== undefined) stage.begin('world');
+  const initialWorld = (plant.evaluate ?? worldTransforms)(bones, active);
+  if (stage !== undefined) {
+    stage.end('world');
+    stage.begin('constraints');
+  }
   const stepped = stepPhysicsRecords(records(), physicsKeyed, t, active, step.ctx, step.before);
-  world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(stepped) : stepped, null, sliders, step.ctx, undefined, solverRules(plant.solver));
+  const world = applyConstraints(bones, initialWorld, active, plant.constraints ? plant.constraints(stepped) : stepped, null, sliders, step.ctx, undefined, solverRules(plant.solver));
+  if (stage !== undefined) stage.end('constraints');
   for (const b of bones) if (world.get(b.name) === undefined) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
   return { bones, world, active, round: plant.round ?? gridRound };
 }
 
 /**
- * `steppedLocals`' world transforms, the oracle's rows formed beside them when
- * `rows` is set (as `posedBoneWorld` forms them and `posedBoneWorldAlone` does
- * not): the live tracks' entry to the stepped phase (`./tracks.ts`). The
- * document's constraint records as they stand — the live tracks mix no
- * constraint timeline — and no physics timeline keyed.
+ * `steppedLocals`' world transforms, without the oracle's rows (as
+ * `posedBoneWorldAlone` poses them): the live tracks' entry to the stepped
+ * phase (`./tracks.ts`). The document's constraint records as they stand —
+ * the live tracks mix no constraint timeline — and no physics timeline keyed.
  */
-export function steppedLocalsWorld(doc: CompiledDocument, bones: ModelBone[], plant: TimelinePlant, sliders: SliderApplication[], step: PoseStep, rows: boolean): Map<string, CoreWorld> {
-  const posed = steppedLocals(doc, bones, plant, () => constraintRecords(doc), [], 0, sliders, step);
-  if (rows) stepRows(posed);
-  return posed.world;
+export function steppedLocalsWorld(doc: CompiledDocument, bones: ModelBone[], plant: TimelinePlant, sliders: SliderApplication[], step: PoseStep): Map<string, CoreWorld> {
+  return steppedLocals(doc, bones, plant, () => constraintRecords(doc), [], 0, sliders, step).world;
 }
 
 /** Each path record with the curve its slot shows deformed by the sample's own deform timelines at `t` (`./deform.ts`), or as it was. */