spine-rigc 1.6.2 → 1.8.0

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,
@@ -128,6 +129,8 @@ import {
   type BoneTransform,
 } from './transform.ts';
 import { emitSkeleton, PHYSICS_PARAMS, UNSTATED_REFERENCE_SCALE, type SkeletonHeader } from './emit_spine.ts';
+import { curveLengthTable } from './core/constraints_path.ts';
+import { frameRegionName } from './core/uvs.ts';
 import {
   isModelVertexAttachment,
   type CarriedFromCompileResult,
@@ -1979,8 +1982,9 @@ function resolveFromAtlas(
  * ⭐ *Either way* was not true for a pack that turns a region until issue #570:
  * `extractRegion` refused a `rotate: 90`, so how the art was delivered decided
  * whether a measurement could be taken at all — on a foreign pack, where turning
- * is the norm rather than the exception. It now transcribes the runtime's own
- * mapping for all four rotations, which is what makes the sentence above a
+ * is the norm rather than the exception. It now lifts every rotation, measured
+ * as `extractRegion` states (`PKR02` against the runtime's own sampling, `PK29`
+ * against the packer's fixture), which is what makes the sentence above a
  * description rather than an aspiration.
  */
 function partPlate(img: CompiledImage): Plate {
@@ -2561,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;
@@ -2740,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}`);
@@ -2780,6 +2789,7 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
           images,
           bones,
           transforms,
+          exactFrames,
           meshBones,
           meshes,
           slotName: rigSlot.name,
@@ -3767,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;
@@ -3802,10 +3814,12 @@ interface AttachmentContext {
    * Linked meshes whose `source` is still unresolved — `resolveLinkedMeshes`
    * empties it once every skin has been built.
    *
-   * ⭐ Deferred for the reason spine-core defers its own (`this.linkedMeshes`,
-   * `SkeletonJson.js:56` filled at `:581` and drained at `:427-449`): a link may
-   * name a source in a skin or a slot this loop has not reached yet, so resolving
-   * it in place would refuse a correct rig on nothing but declaration order.
+   * ⭐ Deferred because the format resolves a link only once every skin is
+   * read — the reader queues each one (`this.linkedMeshes`, `SkeletonJson.js:56`
+   * filled at `:581`) and resolves the queue after the skins (`:427-449`) — so
+   * a link may name a source in a skin or a slot this loop has not reached yet,
+   * and resolving it in place would refuse a correct rig on nothing but
+   * declaration order.
    */
   links: PendingLink[];
 }
@@ -4195,8 +4209,11 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
 }
 
 /**
- * Cumulative arc length at the end of each curve of the chain, in world units —
- * **the runtime's own measurement, restated line for line**.
+ * Cumulative length at the end of each curve of the chain, in world units —
+ * **the core's curve table** (`curveLengthTable` in
+ * [`src/core/constraints_path.ts`](core/constraints_path.ts), issue #1015), the
+ * one the core's path constraint walks at constant speed. This function only
+ * flattens the chain and counts its curves.
  *
  * One entry per curve, which is what `lengths[curve]` indexes: the parser walks
  * curves with `if (p > lengths[curve]) continue`, and reads `lengths[curveCount]`
@@ -4206,12 +4223,16 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  * fact about the Bezier, it is the number the consumer of the field computes for
  * itself when it is not given one. `PathConstraint.computeWorldPositions`
  * (`PathConstraint.js:289-324` in `@esotericsoftware/spine-core` 4.3.13) measures
- * a `constantSpeed` path with a cubic **forward difference** taken at `t = 1/4`
- * — `0.1875 = 3t²`, `0.09375 = 6t³`, `0.75 = 3t`, `0.16666667` standing in for
- * 1/6 — accumulating four `Math.sqrt` terms per curve into a running
- * `pathLength`, and writing the running value into `curves[i]` at each curve's
- * end. The Spine editor's exported `lengths` are that same computation, and the
- * loop below is a transcription of it, not a sampler that happens to agree.
+ * a `constantSpeed` path for itself, and the Spine editor's exported `lengths`
+ * are the same number. What that number is was measured, not read: the core's
+ * table — four forward-difference steps per curve at `t = 1/4` (`0.1875`,
+ * `0.09375`, `0.75`, `0.16666667`), four `Math.sqrt` terms accumulated into a
+ * running total carried across curves — is the rule its header states with the
+ * readings that missed beside it, and `PS67`, `PS68` and `PS186` in
+ * `selftest.ts` hold this function to `PathConstraint`'s own `curves` array read
+ * off a posed skeleton, **bit for bit**. Since issue #1015 the core suite also
+ * holds the swap: 100,000 seeded chains through this function and through the
+ * arithmetic it replaced, 0 differing.
  *
  * 🚨 **What that computation is fed decides the number, and this comment once
  * claimed more than was measured** (issue #804). It said the loop matched the
@@ -4223,8 +4244,8 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  *     vertices. rigc blends weighted vertices through its own setup transforms,
  *     which until #804 ignored bone scale, shear and `inherit` — 2.35× the
  *     runtime's own `curves` on a production rig's weighted path, 0.752× on a
- *     50/50 probe over a bone at scale 2. `computeWorldTransforms` is now the
- *     runtime's, and the gap is gone on both.
+ *     50/50 probe over a bone at scale 2. `computeWorldTransforms` honours all
+ *     three now, and the gap is gone on both.
  *   - **Constraints.** The runtime measures the pose its update order hands the
  *     path constraint at the first `updateWorldTransform`: a transform
  *     constraint on the path's slot bone ordered BEFORE the path constraint
@@ -4232,11 +4253,11 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  *     not. A production 4.2 export's four numbers are the constrained pose's to
  *     the digit, and its unconstrained setup measures 76.08 against 76.65 on the
  *     first curve. Reproducing that means solving every constraint type in
- *     update order, which is posing — and `src/compile.ts` does not link the
- *     runtime. ⇒ **An omitted `lengths` is measured on the unconstrained setup
- *     pose**, and a path whose bones a constraint moves at rest gets that
- *     figure. What closes the gap for an editor export is not measuring at all:
- *     a stated `lengths` is carried (`buildRigPath`).
+ *     update order, which is posing — and `src/compile.ts` does not pose. ⇒
+ *     **An omitted `lengths` is measured on the unconstrained setup pose**, and
+ *     a path whose bones a constraint moves at rest gets that figure. What
+ *     closes the gap for an editor export is not measuring at all: a stated
+ *     `lengths` is carried (`buildRigPath`).
  *
  * ⚠️ rigc measured this with a 64-chord sum until issue #560, and the comment
  * that stood here argued the difference was inside anything's tolerance. It was
@@ -4247,46 +4268,17 @@ export function pathChain(points: Array<[number, number]>, closed: boolean): Arr
  * two apart and since issue #716 rigc's own file can only where the two land on
  * either side of a float's boundary. Under the six-decimal rounding that stood
  * until then it could: on both measured rigs the two spellings differed on the
- * LAST curve, where the accumulated difference is largest. `PS67`, `PS68` and `PS186` in `selftest.ts` compare
- * this against `PathConstraint`'s own `curves` array read off a posed skeleton,
- * which is the only oracle that can see that gap.
- *
- * 🔒 The transcription is deliberate down to the spelling: `Math.sqrt(dx * dx +
- * dy * dy)` rather than `Math.hypot`, `0.16666667` rather than `1 / 6`, and the
- * running total carried across curves rather than restarted. Each of those is a
- * place where a more accurate line would emit a different file.
+ * LAST curve, where the accumulated difference is largest.
+ *
+ * 🔒 The spelling is load-bearing: `Math.sqrt(dx * dx + dy * dy)` rather than
+ * `Math.hypot`, `0.16666667` rather than `1 / 6`, and the running total carried
+ * across curves rather than restarted. Each of those is a place where a more
+ * accurate line would emit a different file.
  */
 export function pathCurveLengths(chain: Array<[number, number]>): number[] {
-  const out: number[] = [];
-  let total = 0;
-  for (let c = 0; c + 3 < chain.length; c += 3) {
-    const [x1, y1] = chain[c];
-    const [cx1, cy1] = chain[c + 1];
-    const [cx2, cy2] = chain[c + 2];
-    const [x2, y2] = chain[c + 3];
-    const tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
-    const tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
-    const dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-    const dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-    let ddfx = tmpx * 2 + dddfx;
-    let ddfy = tmpy * 2 + dddfy;
-    let dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
-    let dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx;
-    dfy += ddfy;
-    ddfx += dddfx;
-    ddfy += dddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx;
-    dfy += ddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    dfx += ddfx + dddfx;
-    dfy += ddfy + dddfy;
-    total += Math.sqrt(dfx * dfx + dfy * dfy);
-    out.push(total);
-  }
-  return out;
+  const flat: number[] = [];
+  for (const [x, y] of chain) flat.push(x, y);
+  return curveLengthTable(flat, Math.max(0, Math.floor((chain.length - 1) / 3)));
 }
 
 /**
@@ -4516,20 +4508,22 @@ function meshTextureKeys(att: { name?: string; path?: string; image?: string; co
 }
 
 /**
- * The atlas region frame `i` of a sequence resolves to — `Sequence.getPath`
- * (`Sequence.js:124-132`) transcribed: the stem, then `start + i` left-padded
- * with zeros to `digits`. `start` and `digits` take the parser's own defaults
- * (`readSequence`: 1 and 0), which are the format's, not a guess.
- *
- * ⚠️ A second transcription of the rule exists in `validate.ts`
- * (`attachmentRegionLookups`, the walk `A08` joins the atlas with), and that is
- * deliberate: this module links no runtime, and the two are held to the loader
- * independently — the one by `A08`, both by `A00`'s round trip, which asks the
- * runtime's own `getPath` for every frame.
+ * The atlas region frame `i` of a sequence resolves to — the core's
+ * `frameRegionName` (`src/core/uvs.ts`, issue #1015): the stem, then `start + i`
+ * left-padded with zeros to `digits`. `start` and `digits` take the parser's
+ * defaults when the spec leaves them out (`readSequence`: 1 and 0).
+ *
+ * ⚠️ The same name is derived in `validate.ts` (`attachmentRegionLookups`, the
+ * walk `A08` joins the atlas with) through the same function. What holds it to
+ * the loader is a measurement, not this sentence: the core suite reads
+ * `Sequence.getPath` and the parser's defaults off spine-core over 7,680 cases
+ * and compares this function, the core's and A08's walk with them, and `A00`'s
+ * round trip asks the runtime's own `getPath` for every frame a build emits.
+ *
+ * Exported for the selftest alone.
  */
-function sequenceFrameRegion(stem: string, seq: RigSequence, i: number): string {
-  const frame = String((seq.start ?? 1) + i);
-  return `${stem}${'0'.repeat(Math.max(0, (seq.digits ?? 0) - frame.length))}${frame}`;
+export function sequenceFrameRegion(stem: string, seq: RigSequence, i: number): string {
+  return frameRegionName(stem, { count: seq.count, start: seq.start ?? 1, digits: seq.digits ?? 0, setup: seq.setup ?? 0 }, i);
 }
 
 /** The model's `sequence` record: the four fields exactly as the spec stated them. */
@@ -4796,8 +4790,8 @@ function bindNamedWeights(weights: RigMeshBinding[][], where: string, ctx: Attac
  * an `image` under `--atlas-in` ENDED the build, by a refusal raised inside a
  * measurement, on 36 of 42 atlases of the pack the card was filed from. The
  * repair was to make the refusal unnecessary rather than to catch it: reading a
- * turned region is a transcription of `MeshAttachment.computeUVs` and is now
- * what `extractRegion` does, so there is no unmeasurable case left for this
+ * turned region is now what `extractRegion` does, measured against
+ * `MeshAttachment.computeUVs` (`PKR02`), so there is no unmeasurable case left for this
  * function to report and no catch here to keep reachable.
  */
 function measureAuthoredFit(
@@ -5230,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;
   };
@@ -5249,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 =
@@ -5262,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);
             }),
           });
@@ -5371,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
@@ -5800,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`);
   }
@@ -5815,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
@@ -6000,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);
@@ -6013,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) {
@@ -6040,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;
@@ -6108,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(
@@ -6120,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} ` +
@@ -6299,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`);
   }
@@ -6323,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,
@@ -7135,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!;
@@ -7167,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];
       });
@@ -7909,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/constraints_path.ts

@@ -44,8 +44,9 @@
  *
  * 1. **A table of the curves' lengths**, each curve four forward-difference
  *    steps (`0.1875`, `0.09375`, `0.75` and `0.16666667`, the running total
- *    carried across curves) — `pathCurveLengths` in `src/compile.ts`, the
- *    same arithmetic. A ten-step table missed 460 of the grid's 976. The
+ *    carried across curves) — `curveLengthTable`, which `src/compile.ts`'s
+ *    `pathCurveLengths` also calls (issue #1015). A ten-step table missed
+ *    460 of the grid's 976. The
  *    last entry is the path's length; `percent` multiplies the position by
  *    it. The stated `lengths` are not read: the stated total in their place
  *    missed 680 of 1,000.
@@ -217,6 +218,60 @@ import type { CoreCurve, CoreKey } from './animation.ts';
 import type { CoreConstraintRecord } from './constraints.ts';
 
 const RAD = RUNTIME_PI / 180;
+
+/**
+ * The constant-speed walk's table of the curves' lengths — the header's *The
+ * walk*, step 1: each curve four forward-difference steps (`0.1875`,
+ * `0.09375`, `0.75`, `0.16666667`), the running total carried across curves,
+ * one cumulative entry per curve. `chain` is flat, `x, y` per point, knot
+ * handle handle knot …; `curveCount` curves are read off it.
+ *
+ * Exported because it has a second caller: an omitted `lengths` on a path
+ * attachment is measured by `src/compile.ts` through this function (issue
+ * #1015), so the number rigc writes into a file and the number the core walks
+ * are one computation. Measured as the header states it on the grid (a
+ * ten-step table missed 460 of 976) and held there by the core suite's `CP`
+ * controls.
+ */
+export function curveLengthTable(chain: readonly number[], curveCount: number): number[] {
+  const curveEnds: number[] = [];
+  let total = 0;
+  let x1 = chain[0];
+  let y1 = chain[1];
+  for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
+    const cx1 = chain[w];
+    const cy1 = chain[w + 1];
+    const cx2 = chain[w + 2];
+    const cy2 = chain[w + 3];
+    const x2 = chain[w + 4];
+    const y2 = chain[w + 5];
+    const h2x = (x1 - cx1 * 2 + cx2) * 0.1875;
+    const h2y = (y1 - cy1 * 2 + cy2) * 0.1875;
+    const d3x = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
+    const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
+    let d2x = h2x * 2 + d3x;
+    let d2y = h2y * 2 + d3y;
+    let d1x = (cx1 - x1) * 0.75 + h2x + d3x * 0.16666667;
+    let d1y = (cy1 - y1) * 0.75 + h2y + d3y * 0.16666667;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x;
+    d1y += d2y;
+    d2x += d3x;
+    d2y += d3y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x;
+    d1y += d2y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    d1x += d2x + d3x;
+    d1y += d2y + d3y;
+    total += Math.sqrt(d1x * d1x + d1y * d1y);
+    curveEnds.push(total);
+    x1 = x2;
+    y1 = y2;
+  }
+  return curveEnds;
+}
+
 const EPSILON = 0.00001;
 
 /** The three modes a path constraint names, each as the model spells it once its first letter is lower-cased. */
@@ -556,47 +611,14 @@ function positionsOf(state: PathSolverState, c: CorePathRecord, g: CorePathGeome
     chain.push(...P(0), ...P(1));
   } else for (let k = 1; k < n - 1; k++) chain.push(...P(k));
   const curveCount = closed ? n / 3 : n / 3 - 1;
-  const curveEnds: number[] = [];
-  let total = 0;
-  let x1 = chain[0];
-  let y1 = chain[1];
-  for (let i = 0, w = 2; i < curveCount; i++, w += 6) {
-    const cx1 = chain[w];
-    const cy1 = chain[w + 1];
-    const cx2 = chain[w + 2];
-    const cy2 = chain[w + 3];
-    const x2 = chain[w + 4];
-    const y2 = chain[w + 5];
-    const h2x = (x1 - cx1 * 2 + cx2) * 0.1875;
-    const h2y = (y1 - cy1 * 2 + cy2) * 0.1875;
-    const d3x = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-    const d3y = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-    let d2x = h2x * 2 + d3x;
-    let d2y = h2y * 2 + d3y;
-    let d1x = (cx1 - x1) * 0.75 + h2x + d3x * 0.16666667;
-    let d1y = (cy1 - y1) * 0.75 + h2y + d3y * 0.16666667;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x;
-    d1y += d2y;
-    d2x += d3x;
-    d2y += d3y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x;
-    d1y += d2y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    d1x += d2x + d3x;
-    d1y += d2y + d3y;
-    total += Math.sqrt(d1x * d1x + d1y * d1y);
-    curveEnds.push(total);
-    x1 = x2;
-    y1 = y2;
-  }
+  const curveEnds = curveLengthTable(chain, curveCount);
+  const total = curveEnds.length > 0 ? curveEnds[curveEnds.length - 1] : 0;
   if (c.positionMode === 'percent') position *= total;
   const spaceScale = c.spacingMode === 'percent' ? total : c.spacingMode === 'proportional' ? total / spaceCount : 1;
   const segmentEnds: number[] = new Array(10).fill(0);
   let curveTotal = 0;
   let lastCurve = -1;
-  let cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
+  let x1 = 0, y1 = 0, cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
   for (let i = 0, o = 0, curve = 0, segment = 0; i < spaceCount; i++, o += 3) {
     const space = spaces[i] * spaceScale;
     position += space;

package/src/core/constraints_physics.ts

@@ -561,6 +561,27 @@ export function physicsState(ctx: PhysicsStepContext, name: string): PhysicsStat
 const PI2 = RUNTIME_PI * 2;
 const INV_PI2 = 1 / PI2;
 
+/** What a physics constraint's step moves, by its five component fields. */
+export interface PhysicsDrives {
+  x: boolean;
+  y: boolean;
+  /** `rotate` or `shearX` above 0: the two share the angular part of the step. */
+  rotateOrShearX: boolean;
+  scaleX: boolean;
+}
+
+/**
+ * Which parts of the step a constraint drives: a component above 0 drives its
+ * part and nothing else does — the test `stepPhysics` takes before each part
+ * of *The step* above, posed against the runtime with the rest of it. Exported
+ * because `src/ingest.ts` asks the same question of a raw file (a
+ * constraint that drives none of the four moves no bone, issue #731) and
+ * answers it through this function (issue #1015).
+ */
+export function physicsDrives(r: { x: number; y: number; rotate: number; shearX: number; scaleX: number }): PhysicsDrives {
+  return { x: r.x > 0, y: r.y > 0, rotateOrShearX: r.rotate > 0 || r.shearX > 0, scaleX: r.scaleX > 0 };
+}
+
 /**
  * One physics constraint updated on its bone's world transform `w`
  * (mutated), `length` the bone's length — the header's *The step*, every
@@ -572,10 +593,7 @@ export function stepPhysics(r: CorePhysicsRecord, w: CoreWorld, length: number,
   const mix = r.mix;
   if (mix === 0) return false;
   const s = physicsState(ctx, r.name);
-  const x = r.x > 0;
-  const y = r.y > 0;
-  const rotateOrShearX = r.rotate > 0 || r.shearX > 0;
-  const scaleX = r.scaleX > 0;
+  const { x, y, rotateOrShearX, scaleX } = physicsDrives(r);
   const l = length;
   if (ctx.phase === 'reset') resetPhysicsState(s, ctx.time);
   const delta = Math.max(ctx.time - s.lastTime, 0);