spine-rigc 1.7.0 → 1.8.0

package/src/assertions/model/slot_colour.ts

@@ -0,0 +1,80 @@
+/**
+ * The model side's supply of `SlotColourFacts` (issue #1025, step 4c of #380).
+ *
+ * - **The slot timelines, in the file's order and spelling.** The document
+ *   holds each animation's slot timelines in the order they are applied, with
+ *   every key as the compiler built it; the Spine file keys the animations in
+ *   the editor's order and passes every key through two passes. So the
+ *   animations are put in order by `editorAnimationOrder` (`src/compile.ts`,
+ *   the function the emitter is handed), and the timelines are laid out as the
+ *   file lays them and handed to the emitter's own `withoutParserDefaults` and
+ *   `inEditorKeyOrder` (`src/keyorder.ts`) — so a key field the emitter would
+ *   leave out at the parser's default is left out here too, and a body
+ *   printing `JSON.stringify(key.value)` prints what it prints over the file.
+ *   Nothing here restates either rule.
+ * - **Whether an animation exists**: the document's own roster.
+ * - **A slot's posed colour**: the core's raw entry (`poseRawAnimation`,
+ *   `src/core/raw.ts`) taking one step of the time on a fresh non-looping
+ *   track, under the view the core poses with no skin set (`noSkinView`,
+ *   `src/render_core.ts`) — the reading of what `validate()` does through
+ *   spine-core (a fresh skeleton, no skin, setup pose, the track stepped to the
+ *   time and applied). Its slot rows are the ones `CR03` holds bit for bit to
+ *   spine-core on every frame of the nineteen recipes; that the two readings
+ *   print the same A45 line is the selftest's supplier check, on every call
+ *   that poses one (`VF02`). A channel the pose read as no number is NaN, as a
+ *   non-finite channel reads on the runtime's side.
+ *
+ * Links nothing from the runtime.
+ */
+import { editorAnimationOrder } from '../../compile.ts';
+import type { CompiledDocument } from '../../core/index.ts';
+import { poseRawAnimation } from '../../core/raw.ts';
+import { inEditorKeyOrder, withoutParserDefaults } from '../../keyorder.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { SlotColourFacts, SlotTimelines } from '../facts/slot_colour.ts';
+import { isObj, type Json } from '../values.ts';
+import type { ReadDocument } from './parse.ts';
+
+const list = (v: unknown): Json[] => (Array.isArray(v) ? v.filter(isObj) : []);
+
+/** Every animation's slot timelines as the Spine file states them: `animations.<name>.slots.<slot>.<timeline> = keys`. */
+export function fileSlotTimelines(read: ReadDocument): SlotTimelines[] {
+  const byName = new Map<string, Json>();
+  for (const anim of list(read.json.animations)) if (typeof anim.name === 'string') byName.set(anim.name, anim);
+  const animations: Json = {};
+  for (const name of editorAnimationOrder([...byName.keys()])) {
+    const slots: Json = {};
+    for (const slot of list((byName.get(name) as Json).slots)) {
+      if (typeof slot.name !== 'string') continue;
+      const timelines: Json = {};
+      for (const timeline of list(slot.timelines)) {
+        if (typeof timeline.name === 'string') timelines[timeline.name] = list(timeline.keys).map((key) => ({ ...key }));
+      }
+      slots[slot.name] = timelines;
+    }
+    // An animation keying no slot writes no `slots` group — `emitAnimation`'s `if (animation.slots.size)`.
+    animations[name] = Object.keys(slots).length > 0 ? { slots } : {};
+  }
+  const file = inEditorKeyOrder(withoutParserDefaults({ animations }));
+  const out: SlotTimelines[] = [];
+  for (const [animation, anim] of Object.entries(file.animations)) {
+    if (!isObj(anim) || !isObj(anim.slots)) continue;
+    for (const [slot, timelines] of Object.entries(anim.slots)) if (isObj(timelines)) out.push({ animation, slot, timelines });
+  }
+  return out;
+}
+
+export function modelSlotColour(read: ReadDocument): SlotColourFacts {
+  let view: CompiledDocument | null = null;
+  return {
+    slotTimelines: fileSlotTimelines(read),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    posedSlot: (animation, slot, time) => {
+      view ??= noSkinView(read.doc);
+      const row = poseRawAnimation(view, animation, [time], {}, 'animation')[1].slots.find((r) => r[0] === slot);
+      if (row === undefined) return undefined;
+      const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+      return { color: { r: channel(row[2]), g: channel(row[3]), b: channel(row[4]), a: channel(row[5]) } };
+    },
+  };
+}

package/src/assertions/reasons.ts

@@ -0,0 +1,127 @@
+/**
+ * What a SKIP says, by what the assertion was denied (issues #568, #580, #608).
+ *
+ * Moved here from `src/validate.ts` by issue #1025 (step 4c of #380), words
+ * unchanged: an assertion body now lives in a module that links nothing from
+ * the runtime (`./bodies/`), and the bodies print these sentences on both
+ * sides — over what spine-core loaded and over the model document. A sentence
+ * kept in the file that links spine-core could not be read by the second.
+ * `src/validate.ts` re-exports every one, so nothing that imported them from
+ * there moves.
+ */
+
+/**
+ * What a SKIP says when `A00_ROUNDTRIP_PARSE` handed an assertion nothing to
+ * look at.
+ *
+ * Two of them rather than one, because what an assertion was denied is the whole
+ * content of its SKIP: `A20` wanted the loaded skeleton and `A06` wanted the
+ * loaded atlas, and a reader who is told which can tell a rule that is waiting
+ * on the parse from one that is waiting on the art. Both point at A00 instead of
+ * restating its detail, which the FAIL row prints in full.
+ *
+ * Exported so a control compares against them rather than quoting them — the
+ * same reason `ASSERTION_NAMES` is exported.
+ */
+export const SKIP_NO_SKELETON = 'the round trip did not produce a skeleton to measure (A00 owns that failure)';
+export const SKIP_NO_ATLAS = 'the round trip did not produce an atlas to measure (A00 owns that failure)';
+/**
+ * The third of them, and it is NOT waiting on A00 (issue #608): the atlas parsed
+ * and it has no pages, which is what a compile that measured no art writes. The
+ * four rules whose only subject is a page — A06, A17, A19, A27 — have nothing to
+ * look at, and an empty loop walking out of `check()` is reported as a PASS.
+ */
+/*
+ * **An empty subject list: SKIP or PASS, and which one is derived (issue #580).**
+ *
+ * `check()` records a pass when a body runs to its end without a `fail()` or a
+ * `skip()`, so a body whose main construct is a loop over a list that is EMPTY
+ * passes having measured nothing — the vacuous green one ring out from the bare
+ * `return` guards issue #568 converted. Two different things can be true of such
+ * a loop, and the criterion decides between them by reading the rule's own name
+ * and its `fail()` sentences rather than by preference:
+ *
+ *   * A name of the form ⟨subject⟩_⟨property⟩ — `REGION_WIDTH_HEIGHT_FINITE`,
+ *     `MESH_TRIANGLES_AND_ENCODING`, `PHYSICS_CONSTRAINT_EFFECTIVE`,
+ *     `ATLAS_PAGE_SIZE_MATCHES_PNG` — quantifies over the subject it names, and
+ *     its `fail()` names a member of that subject, the value found and the value
+ *     required. With no member, nothing was measured: it **SKIPs**, and the
+ *     reason names the subject that was absent.
+ *   * A name of the form NO_⟨construct⟩ — `NO_LEGACY_TOPLEVEL_CONSTRAINT_ARRAYS`,
+ *     `NO_BONE_TRANSFORM_KEY`, `NO_CLIPPING_ATTACHMENTS`, `NO_DARK_COLOR`,
+ *     `NO_FULL_FRAME_MESH` — quantifies over occurrences of something a correct
+ *     artifact has NONE of, and its `fail()` reports that the construct is
+ *     present rather than measuring a value on it. Zero occurrences IS the
+ *     measurement, so it **PASSes**: the loop is a search of the artifact, and
+ *     the artifact is what it measured.
+ *   * A name carrying both halves takes each at its word.
+ *     `A15_IDLE_NO_MESH_BONE_KEYS` is the pattern and already reads this way: no
+ *     `idle` animation, or an `idle` with no bone timeline, is the named subject
+ *     absent and SKIPs; no mesh-driving bone among the bones `idle` does key is
+ *     the construct absent and passes. `A10_NO_NAN_AFTER_STEPPING` was the same
+ *     shape until issue #902, and is the next bullet's now: #882 gave it a
+ *     setup-pose clause whose subject is the bones, beside the stepping clause
+ *     whose subject is the animations.
+ *   * An assertion with more than one clause SKIPs only when EVERY clause had
+ *     nothing to measure, which is the shape `A09`, `A33` and `A38` already
+ *     carry (`polygons.length === 0 && endsChecked === 0`), and `A10` since #902.
+ *     `A13_MESH_BUDGET` is why the clause is stated: a declared slot budget is
+ *     measured against a count of mesh slots, and zero is a count, so that half
+ *     passes on a rig with no mesh — while a rig that declares only a TRIANGLE
+ *     budget has nothing left to measure and skips.
+ *
+ * ⚠️ What the criterion is not allowed to become is a table of assertions with
+ * their verdicts written beside them. Every row above is decided by reading the
+ * name and the sentences the assertion already prints, so a rule added tomorrow
+ * is decided by the same reading and nobody re-opens this question.
+ */
+
+/**
+ * What a SKIP says when the artifact carries no member of the subject a rule
+ * quantifies over (issue #580), by subject.
+ *
+ * One constant per SUBJECT rather than one per assertion, for the reason the two
+ * above are two: what the rule was denied is the whole content of its SKIP, and
+ * three rules denied the same thing should say so in the same words. Exported so
+ * a control compares against them rather than quoting them.
+ */
+export const SKIP_NO_REGION_ATTACHMENT = 'the skeleton carries no region attachment';
+export const SKIP_NO_MESH_ATTACHMENT = 'the skeleton carries no mesh attachment';
+export const SKIP_NO_ANIMATION = 'the skeleton carries no animation';
+/**
+ * A10's (issue #902): its setup clause reads the bones and its stepping clause
+ * the animations, so it skips only when the skeleton carries neither — and the
+ * sentence is `SKIP_NO_ANIMATION`'s with the second subject added, so the two
+ * cannot drift into different words for the same absence.
+ */
+export const SKIP_NO_POSE = `${SKIP_NO_ANIMATION} and no bone, so there is no setup pose to read and nothing to step`;
+export const SKIP_NO_TIMELINE = 'no animation here carries a timeline';
+export const SKIP_NO_PHYSICS_CONSTRAINT = 'the skeleton declares no physics constraint';
+export const SKIP_NO_ATLAS_PAGE = 'the atlas declares no page';
+export const SKIP_NO_ATLAS_REGION = 'the atlas declares no region';
+export const SKIP_NO_ATTACHMENT_REGION_JOIN =
+  'no attachment names a region and the atlas declares none, so there is no attachment-to-region join to hold';
+export const SKIP_NO_TWO_COLOR_TINT =
+  'no slot declares a "dark" colour and no animation keys an "rgba2" or "rgb2" timeline, so there is no two-colour tint to read back';
+export const SKIP_NO_SEPARABLE_COLOR =
+  'no animation keys an "rgb" or "alpha" timeline, so there is no separable slot colour to read back';
+export const SKIP_NO_LINKED_MESH = 'no attachment in this skeleton takes its geometry from another one';
+export const SKIP_NO_SEQUENCE =
+  'no attachment carries a "sequence" block and no animation keys a "sequence" timeline, so there is no numbered series to read back';
+/**
+ * A09's, which predates this list and joins it rather than being rewritten: it
+ * is the same fact about the same subject, and a control that compares against
+ * eight constants and quotes the ninth is a control with a hand-kept exception
+ * in it.
+ */
+export const SKIP_NO_DECLARED_DURATION =
+  'the motion spec declares no animations and the skeleton has none — a static rig has no duration to compare';
+
+/**
+ * The model side's `SKIP_NO_SKELETON` (issue #1025): the reader refused the
+ * document, or the document names a region its pages lack, so a body that
+ * reads the model has nothing to read. It names the two model-side parse
+ * rules rather than A00, because on this side there is no round trip — the
+ * reader and the region rule are what stand in its place (`./model/parse.ts`).
+ */
+export const SKIP_NO_MODEL = 'the model side read no document to measure (A00_MODEL_READ or A00_MODEL_REGIONS_ON_PAGES owns that failure)';

package/src/assertions/values.ts

@@ -0,0 +1,39 @@
+/**
+ * How an assertion body reads a value — the helpers the bodies under
+ * `./bodies/` share with the ones still in `src/validate.ts` (issue #1025,
+ * step 4c of #380), moved here unchanged so both read a value one way. Links
+ * nothing from the runtime.
+ */
+
+/** A JSON object as `JSON.parse` returns it. */
+export type Json = Record<string, unknown>;
+
+/** A JSON object, and not an array or `null`. */
+export function isObj(v: unknown): v is Json {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+/**
+ * The time to pose a key at so that the runtime is AT it: the later of the
+ * file's number and that number as spine-core stores it (issue #771).
+ *
+ * 🚨 Every timeline keeps its key times in a `Float32Array`
+ * (`Utils.newFloatArray`), and a key time the float cannot hold exactly is
+ * stored at the nearest one — for `0.2`, `0.20000000298…`, which is LATER than
+ * the double `0.2`. Stepped to the file's own number, a timeline is then just
+ * BEFORE its key: before a first key it writes the setup value (`time <
+ * frames[0]`), and past a stepped key it still holds the one before
+ * (`frames[i] > time`). That is a pose one float step from the key, not the
+ * key's — measured on the selftest's own `ingest_probe`, whose `alpha` key at
+ * 0.2 posed the setup 1.0 and was refused as `the key states value 0.4`.
+ *
+ * ⚠️ The later of the two rather than `Math.fround` alone: where the float
+ * rounds DOWN, the file's number is already past the stored key, and a runtime
+ * built without typed arrays stores the double itself — in both, the file's
+ * number is the one at or after the key. What a key time rounds to is the
+ * runtime's storage and not the file's statement, so a rule judging what a KEY
+ * states poses at the key; the rounding itself is nothing an author can repair.
+ */
+export function atStoredKey(time: number): number {
+  return Math.max(time, Math.fround(time));
+}

package/src/check.ts

@@ -878,8 +878,12 @@ export interface TextureFromReport {
   atlas: string;
   /** Every `scale:` its text declares — the line that says a pack is coarser. */
   scales: number[];
-  /** The same for the CANDIDATE's own atlas, so the two are read side by side. */
-  candidateScales: number[];
+  /**
+   * The same for the CANDIDATE's own atlas, so the two are read side by side —
+   * `null` when the candidate has no atlas beside it to read them off (issue
+   * #1020), which is not the same claim as declaring none.
+   */
+  candidateScales: number[] | null;
   /**
    * Regions the substituting atlas does not have, or the candidate packs rotated
    * so its own corner order cannot be inverted — see `artUvsOf`. Those pieces kept
@@ -987,7 +991,13 @@ export interface CheckReport {
 
 export interface CheckOptions {
   skeletonText: string;
-  atlasText: string;
+  /**
+   * The candidate's atlas, or `null` when there is no file (issue #1020): a
+   * rigc build the core poses from a `rigc-compiled/2` document is drawn
+   * without one, and anything else is refused naming the file
+   * (`CandidateAtlasError`).
+   */
+  atlasText: string | null;
   /** Where the atlas's page paths resolve from. */
   atlasDir: string;
   framesDir: string;
@@ -1161,8 +1171,13 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
   // The substitution is loaded before anything is posed, because posing has to
   // record each piece's original-art UVs for it and that is the one thing about
   // this measure that cannot be added afterwards — see `PieceTexture`.
+  //
+  // Read by rigc's own atlas reader when the core poses the candidate, and by
+  // spine-core's when the runtime does (issue #1020, `SubstitutionReader`): a
+  // rigc build's `--texture-from` reads nothing through the runtime, and an
+  // export's reading is the one it always had.
   const substitution = options.textureFrom
-    ? textureSubstitutionFromText(options.textureFrom.atlasText, options.textureFrom.atlasDir)
+    ? textureSubstitutionFromText(options.textureFrom.atlasText, options.textureFrom.atlasDir, choice.core === null ? 'spine' : 'rigc')
     : null;
   // The skin is refused here rather than deeper in the sampler, for the reason
   // every miss in this project is refused where the names are: the skeleton is
@@ -1600,7 +1615,11 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
     );
   }
 
-  const candidateScales = atlasScales(options.atlasText);
+  // `null` when the candidate has no atlas to read them off (issue #1020): the
+  // model document a build is drawn from without one states where each region
+  // sits, not the `scale:` line, so the report says it was not read rather than
+  // that none was declared.
+  const candidateScales = options.atlasText === null ? null : atlasScales(options.atlasText);
   if (substitution === null) {
     // ⭐ Named at the top of every report rather than only when it is measured.
     // Issue #171's finding was not that the floor was mis-measured; it was that
@@ -1610,7 +1629,13 @@ export function checkAgainstFrames(options: CheckOptions): CheckReport {
     notes.push(
       'part of every MAE below is TEXTURE, not animation, and it is not attributed here. The frames were rendered ' +
         "through the reference's own atlas; this candidate samples its own" +
-        `${candidateScales.length > 0 ? ` (declared at scale: ${[...new Set(candidateScales)].join(', ')})` : ''}` +
+        `${
+          candidateScales === null
+            ? ' (its atlas is not beside it, so whether that declares a scale: line is not read — the model document does not state one)'
+            : candidateScales.length > 0
+              ? ` (declared at scale: ${[...new Set(candidateScales)].join(', ')})`
+              : ''
+        }` +
         ', and if the two were packed at different scales every edge of every part is filtered from a different ' +
         'source in every frame. That difference is a constant no key can move and is invisible to the content box, ' +
         'the fit residual and the whole-pixel refinement. Pass --texture-from <the atlas the frames were rendered ' +
@@ -3540,8 +3565,8 @@ export function checkLines(report: CheckReport, opts?: { allFrames?: boolean }):
   }
   if (report.textureFrom) {
     const t = report.textureFrom;
-    const scale = (values: number[]): string =>
-      values.length === 0 ? 'no scale: line' : `scale: ${[...new Set(values)].join(', ')}`;
+    const scale = (values: number[] | null): string =>
+      values === null ? 'no atlas beside it to read a scale: line from' : values.length === 0 ? 'no scale: line' : `scale: ${[...new Set(values)].join(', ')}`;
     lines.push(
       `  texture    from ${t.atlas} (${scale(t.scales)}) against the candidate's own (${scale(t.candidateScales)})` +
         `${t.unmatched.length === 0 ? '' : `   ⚠️ ${t.unmatched.length} region(s) not substituted`}`,

package/src/compile.ts

@@ -117,6 +117,7 @@ import {
 import { evaluateDeformTransform } from './deformgen.ts';
 import { evaluateTrackDerive, TRACK_DERIVE_PROJECTIONS, type TrackDeriveMember } from './trackgen.ts';
 import {
+  computeExactFrameTransforms,
   computeWorldTransforms,
   cropToSpineY,
   normaliseDegrees,
@@ -2564,8 +2565,13 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   }
   const boneNames = new Set(bones.map((b) => b.name));
   let transforms: Map<string, BoneTransform>;
+  // The frames a depth turn ceiling is measured in — the same bones without the
+  // runtime's last bits (`computeExactFrameTransforms`, issue #1021). Nothing is
+  // bound through them.
+  let exactFrames: Map<string, BoneTransform>;
   try {
     transforms = computeWorldTransforms(bones);
+    exactFrames = computeExactFrameTransforms(bones);
   } catch (err) {
     if (err instanceof TransformError) throw new CompileError(err.message);
     throw err;
@@ -2743,7 +2749,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
 
     if (part) {
       const perSlot: Record<string, SkinTableEntry> = {};
-      const mesh = part.mesh ? buildMesh(part, manifest!, bones, transforms, rigSlot.bone) : null;
+      const mesh = part.mesh ? buildMesh(part, manifest!, bones, transforms, exactFrames, rigSlot.bone) : null;
       for (const name of names) {
         const img = images.find((im) => im.region === name);
         if (!img) throw new CompileError(`internal: no image for attachment ${name}`);
@@ -2783,6 +2789,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           images,
           bones,
           transforms,
+          exactFrames,
           meshBones,
           meshes,
           slotName: rigSlot.name,
@@ -3770,6 +3777,8 @@ interface AttachmentContext {
   images: CompiledImage[];
   bones: ModelBone[];
   transforms: Map<string, BoneTransform>;
+  /** The same bones in `computeExactFrameTransforms`' frames: what a depth turn ceiling is measured in, and nothing else (issue #1021). */
+  exactFrames: Map<string, BoneTransform>;
   meshBones: Set<string>;
   meshes: CompileResult['meshes'];
   slotName: string;
@@ -5215,9 +5224,11 @@ function buildGeneratedMesh(
   // refusals, because the ring's control angles need the transform and the bind
   // needs the bone — and the two must refuse a bone the rig lacks in the same
   // words whichever of them asks for it first.
-  const resolve = (name: string): BoneTransform => {
+  // Two readings of one bone (issue #1021): the runtime's matrices to bind
+  // through, and the exact frame to measure the control angles in.
+  const resolve = (name: string, frames: Map<string, BoneTransform> = ctx.transforms): BoneTransform => {
     if (!ctx.bones.some((b) => b.name === name)) throw new CompileError(`${where}: mesh bone "${name}" is not in the rig's bone list`);
-    const transform = ctx.transforms.get(name);
+    const transform = frames.get(name);
     if (!transform) throw new CompileError(`${where}: no setup transform for mesh bone "${name}"`);
     return transform;
   };
@@ -5234,7 +5245,11 @@ function buildGeneratedMesh(
   const anchor = ctx.transforms.get(ctx.anchorBone);
   if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
   const place = (px: number, py: number): [number, number] => [anchor.worldX + px - w / 2, anchor.worldY + h / 2 - py];
-  const toPartLocal = (wx: number, wy: number): [number, number] => [wx - anchor.worldX + w / 2, anchor.worldY + h / 2 - wy];
+  // The inverse a control angle is measured through, in the exact frame: the
+  // anchor's and the control's positions as the spec put them, not as the
+  // runtime's last bits put them (issue #1021).
+  const exactAnchor = resolve(ctx.anchorBone, ctx.exactFrames);
+  const toPartLocal = (wx: number, wy: number): [number, number] => [wx - exactAnchor.worldX + w / 2, exactAnchor.worldY + h / 2 - wy];
   let geometry;
   try {
     geometry =
@@ -5247,7 +5262,7 @@ function buildGeneratedMesh(
             size: generator.size,
             bias: generator.bias,
             controlAngles: ringControlAngles(controls, generator.center, (name) => {
-              const transform = resolve(name);
+              const transform = resolve(name, ctx.exactFrames);
               return toPartLocal(transform.worldX, transform.worldY);
             }),
           });
@@ -5356,7 +5371,12 @@ function sampleMeshDepth(
   /**
    * A part-local pixel to the BIND space this mesh's vertices are emitted in —
    * the same composition `bindWeightedVertices` applies, handed in rather than
-   * rebuilt so the two cannot diverge.
+   * rebuilt so the two cannot diverge — taken in the slot bone's exact frame
+   * (`computeExactFrameTransforms`) rather than the runtime's. The two differ
+   * in the last bits only, and those bits are the runtime's π rather than the
+   * mesh: an unrotated bone reads `b = −2.3e-8` there, which turns the exact
+   * zero this ceiling reads as "this axis cannot fold" into a fold at
+   * 89.99997° (issue #1021; `TC03` and `TC06` are that claim).
    *
    * 🚨 The ceiling has to be taken in bind space and in no other. A deform
    * offset is authored there, so a rotated slot bone MIXES the two axes: a
@@ -5785,7 +5805,8 @@ function buildGridAttachment(
     throw new CompileError(`${where}: the spec says height ${att.height} and "${att.image}" measures ${h}`);
   }
   const anchor = ctx.transforms.get(ctx.anchorBone);
-  if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
+  const frame = ctx.exactFrames.get(ctx.anchorBone);
+  if (!anchor || !frame) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
   if (!ctx.bones.some((b) => b.name === ctx.anchorBone)) {
     throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
   }
@@ -5800,7 +5821,7 @@ function buildGridAttachment(
           'grid',
           geometry.points,
           geometry.triangles,
-          (px, py) => toBoneLocal(anchor, anchor.worldX + px * toArt - w / 2, anchor.worldY + h / 2 - py * toArt),
+          (px, py) => toBoneLocal(frame, frame.worldX + px * toArt - w / 2, frame.worldY + h / 2 - py * toArt),
           // The lattice's geometry takes nothing off the texels — its window is
           // the plate's size, which is the atlas's own `offsets` — so a page
           // whose file is not its declared size costs a grid only this one
@@ -5985,7 +6006,11 @@ function buildSegmentsAttachment(
 
   // -- the placement ---------------------------------------------------------
   const slotBone = ctx.transforms.get(ctx.anchorBone);
-  if (!slotBone) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
+  // The exact frame (issue #1021) is what the segments and the vertices are
+  // MEASURED in — distances, falloff, `minWeight`, the shared-origin refusal —
+  // and the runtime's is what the vertices are BOUND through (`place`).
+  const exactSlotBone = ctx.exactFrames.get(ctx.anchorBone);
+  if (!slotBone || !exactSlotBone) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
   let anchorAt: [number, number] = [w / 2, h / 2];
   if (generator.anchor !== undefined) {
     const stated = finitePair(generator.anchor);
@@ -5998,10 +6023,12 @@ function buildSegmentsAttachment(
     anchorAt = stated;
   }
   const [ax, ay] = anchorAt;
-  const place = (px: number, py: number): [number, number] => [
-    slotBone.worldX + (px - ax),
-    slotBone.worldY + (cropToSpineY(py, h) - cropToSpineY(ay, h)),
+  const placeIn = (bone: BoneTransform) => (px: number, py: number): [number, number] => [
+    bone.worldX + (px - ax),
+    bone.worldY + (cropToSpineY(py, h) - cropToSpineY(ay, h)),
   ];
+  const place = placeIn(slotBone);
+  const measuredAt = placeIn(exactSlotBone);
 
   // -- the segments ----------------------------------------------------------
   if (!Array.isArray(generator.bones) || generator.bones.length === 0) {
@@ -6025,7 +6052,7 @@ function buildSegmentsAttachment(
       named.push(name);
       refs.push(meshBoneRef(name, where, ctx));
     }
-    return { index, transform: ctx.transforms.get(name)! };
+    return { index, transform: ctx.exactFrames.get(name)! };
   };
   const tipOf = (name: string, transform: BoneTransform, at: string, chained: boolean): [number, number] => {
     const length = ctx.bones.find((b) => b.name === name)?.length ?? 0;
@@ -6093,7 +6120,7 @@ function buildSegmentsAttachment(
             `${JSON.stringify(from === null ? span.from : span.to)}; both ends are [x, y] in the part's pixels, y down`,
         );
       }
-      segments.push({ bone: index, a: place(from[0], from[1]), b: place(to[0], to[1]) });
+      segments.push({ bone: index, a: measuredAt(from[0], from[1]), b: measuredAt(to[0], to[1]) });
       return;
     }
     throw new CompileError(
@@ -6105,7 +6132,7 @@ function buildSegmentsAttachment(
   // -- the weights -----------------------------------------------------------
   const falloff = { power, radius: f.radius, maxBones, minWeight };
   const weights: MeshVertexWeight[][] = lattice.points.map(([px, py], v) => {
-    const got = segmentShares(place(px, py), segments, falloff);
+    const got = segmentShares(measuredAt(px, py), segments, falloff);
     if ('weights' in got) return got.weights;
     throw new CompileError(
       `${where}: vertex ${v}, at (${px}, ${py}) in the part's pixels, keeps no bone — the ${got.dropped.length} ` +
@@ -6284,7 +6311,8 @@ function buildContourAttachment(
     throw new CompileError(`${where}: the spec says height ${att.height} and "${att.image}" measures ${h}`);
   }
   const anchor = ctx.transforms.get(ctx.anchorBone);
-  if (!anchor) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
+  const frame = ctx.exactFrames.get(ctx.anchorBone);
+  if (!anchor || !frame) throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" has no setup transform`);
   if (!ctx.bones.some((b) => b.name === ctx.anchorBone)) {
     throw new CompileError(`${where}: slot bone "${ctx.anchorBone}" is not in the rig's bone list`);
   }
@@ -6308,7 +6336,7 @@ function buildContourAttachment(
           'contour',
           geometry.points,
           geometry.triangles,
-          (px, py) => toBoneLocal(anchor, anchor.worldX + px * toArt - w / 2, anchor.worldY + h / 2 - py * toArt),
+          (px, py) => toBoneLocal(frame, frame.worldX + px * toArt - w / 2, frame.worldY + h / 2 - py * toArt),
           alpha,
           sheetGridOf(img, plate),
           where,
@@ -7120,6 +7148,8 @@ function buildMesh(
   manifest: FaceManifest,
   bones: ModelBone[],
   transforms: Map<string, BoneTransform>,
+  /** The same bones in the exact frame (`computeExactFrameTransforms`): what the control angles are measured in. */
+  exactFrames: Map<string, BoneTransform>,
   anchorName: string,
 ): { attachment: ModelMeshAttachment; kind: 'ring' | 'ribbon' } {
   const spec = part.mesh!;
@@ -7152,9 +7182,12 @@ function buildMesh(
       // measures in crop pixels, y down, and Spine world is that crop flipped, so
       // `cropH - worldY` is the whole of it. `spec.center` is in the same crop
       // pixels, which is why the centre passed here is not the window-local
-      // `centre` two lines up.
+      // `centre` two lines up. The positions are read in the exact frame
+      // (issue #1021): an angle is a statement about where the spec put the
+      // bone, it orders the split and refuses a tie, and the runtime's last
+      // bits turned an authored 90 into 89.99999734089101 in that refusal.
       const controlAngles = ringControlAngles(controls, spec.center!, (name) => {
-        const m = transforms.get(name);
+        const m = exactFrames.get(name);
         if (!m) throw new CompileError(`internal: no setup transform for control bone "${name}"`);
         return [m.worldX, cropH - m.worldY];
       });
@@ -7894,6 +7927,13 @@ export function deformGeometryOf(
   // what makes that provable — the alternative, folding it into the world path
   // below, would re-evaluate every existing `transform` key at world
   // coordinates and emit a different file for a spec nobody edited.
+  //
+  // 🔸 Issue #1021: this reads the runtime's frame, not the exact one. The
+  // offsets are added by the runtime to exactly these numbers, so the model is
+  // evaluated on what the file holds; a compiler-bound vertex therefore carries
+  // the runtime's last bits (`b = −2.3e-8` on an unrotated bone) into its
+  // offset, about 1e-6 on gallery/look's hair locks. Evaluating on the authored
+  // positions instead would need them carried here from the binder.
   if (boneCounts.every((n) => n === 1) && bones.size === 1) {
     return { ...common, setup: bindSpace, influenceBones: null, setupWhy: null };
   }

package/src/core/index.ts

@@ -154,11 +154,13 @@
  * World transforms come from the core's own evaluator, `worldTransforms` in
  * `./world.ts`, written from what a bone's fields mean and from measurement
  * against the runtime's dump; its header states each measured choice. It is
- * not `src/transform.ts`'s `computeWorldTransforms`, and cannot be: that is
- * the compiler's arithmetic, frozen so that no emitted byte moves, and called
- * as it is it read IDENTICAL on 1 of the 12 recipes the core poses (DIFF on
- * 11, worst 61 millionths against a tolerance of one — issue #925's report).
- * The owner's decision is recorded on issue #380. `poseSetup` takes a
+ * not reached through `src/transform.ts`'s `computeWorldTransforms`: that is
+ * the compiler's adapter over this same evaluator (issues #1015 and #1021 —
+ * the same arithmetic since #1021), and the core importing the compiler would
+ * be a cycle. The compiler's evaluator before #1015, called as it was, read
+ * IDENTICAL on 1 of the 12 recipes the core poses (DIFF on 11, worst 61
+ * millionths against a tolerance of one — issue #925's report). The owner's
+ * decision is recorded on issue #380. `poseSetup` takes a
  * `CorePlant` — the evaluator, the skin resolution, the colour and blend readings — so
  * the suite's plants can pass a copy of one of them; nothing else passes one.
  *

package/src/core/world.ts

@@ -5,21 +5,22 @@
  * (`tools/pose_oracle.ts dump`, spine-core 4.3.13), and held to it by the core
  * suite's equivalence controls.
  *
- * ⭐ **The compiler's setup transforms are this evaluator too** (issue #1015).
- * `src/transform.ts` held a second evaluator of its own until then, and the
- * two differed in exactly three places, none of them a different matrix: the
- * degree factor (`Math.PI / 180` there, the runtime's 3.1415927 here), the
- * frame of a bone with scale 1 and no shear (`[cos, −sin, sin, cos]` of the
- * rotation there, the y column at `rotation + 90` here), and how a radian
- * angle is turned into degrees (divided by the degree factor there,
- * multiplied by `180 / pi` here). Every byte rigc emits was computed with the
- * compiler's three, so they are a parameter of this evaluator
- * (`WorldArithmetic`) rather than a rewrite of the emitter's numbers: the
- * compiler passes its own and the posing core passes none, which is
- * `RUNTIME_ARITHMETIC`, the measured choices below. Measured with the
- * compiler's degree factor and frame taken from here instead: 2 of 19
- * recipes moved, by at most 4e-5 (issue #1015's report) — whether the
- * compiler should bind with the runtime's constant is its own question.
+ * ⭐ **The compiler's setup transforms are this evaluator too** (issue #1015),
+ * under the same arithmetic (issue #1021). `src/transform.ts` held a second
+ * evaluator of its own until #1015, and the two differed in exactly three
+ * places, none of them a different matrix: the degree factor (`Math.PI / 180`
+ * there, the runtime's 3.1415927 here), the frame of a bone with scale 1 and
+ * no shear (`[cos, −sin, sin, cos]` of the rotation there, the y column at
+ * `rotation + 90` here), and how a radian angle is turned into degrees
+ * (divided by the degree factor there, multiplied by `180 / pi` here). #1015
+ * made them a parameter (`WorldArithmetic`) so that no byte moved; #1021
+ * measured which binds closer — every point the compiler binds from a world
+ * position, posed by spine-core from the emitted build, against that position
+ * — and the runtime's three put every one at the float32 floor where the
+ * compiler's left `gallery/look`'s up to 8.6e-5 off. So the compiler passes
+ * none now, and `RUNTIME_ARITHMETIC`, the measured choices below, is the only
+ * arithmetic anything here runs under; the parameter stays for the plants
+ * that swap one choice back in to show a control fire.
  *
  * ## What each measured choice is
  *
@@ -115,9 +116,9 @@ export const COLLAPSED_X_AXIS_SQ = 0.00001 * 0.00001;
 
 /**
  * The three places an evaluator's arithmetic may differ in the last bit while
- * computing the same matrix (issue #1015) — see the header. The core poses with
- * `RUNTIME_ARITHMETIC`; `src/transform.ts` passes the compiler's, so that what
- * rigc has always emitted is what it still emits.
+ * computing the same matrix (issue #1015) — see the header. The core poses and
+ * the compiler binds with `RUNTIME_ARITHMETIC` (issue #1021); another value is
+ * a plant's.
  */
 export interface WorldArithmetic {
   /** Degrees to radians: every angle is multiplied by it. */
@@ -254,8 +255,8 @@ function modeOf(bone: ModelBone): CoreInheritMode {
  * posed from those zeros like any child. `inherit` replaces the mode
  * computation — the core suite's plant passes a copy with one mode's sign
  * flipped, and nothing else does. `arithmetic` is the runtime's unless a
- * caller states its own: `src/transform.ts` passes the compiler's (issue
- * #1015), and no posing path does.
+ * caller states its own, and only a plant does: `src/transform.ts` takes the
+ * default since issue #1021, as every posing path does.
  */
 export function worldTransforms(
   bones: readonly ModelBone[],