spine-rigc 1.6.2 → 1.8.0

package/src/render_core.ts

@@ -2,14 +2,16 @@
  * The render's second poser (issue #968, step 3d of issue #380): the posing
  * seam of `src/render.ts` (`Poser` / `Posed`) implemented over rigc's own
  * core — the compiled model document (`skeleton.model.json`) posed by
- * `src/core/`, and the atlas the render samples read by rigc's own reader
- * (`src/atlas.ts`). Nothing here links spine-core, and nothing here is reached
+ * `src/core/`, each drawn region placed on its page by the document's own
+ * `pages` section (issue #1016; a `rigc-compiled/1` document, which has none,
+ * by the atlas beside it, read by rigc's own reader `src/atlas.ts`). Nothing
+ * here links spine-core, and nothing here is reached
  * from `src/core/`: the core stays pure, and this module is the adapter from
  * its raw entry to the renderer's shapes.
  *
  * ⭐ Why a module of its own rather than a second block in `src/render.ts`.
- * `render.ts` links spine-core (the atlas pages, texture substitution and
- * `spinePoser`), so a core poser written there would share an import list
+ * `render.ts` links spine-core (an export's atlas pages and texture
+ * substitution, and `spinePoser`), so a core poser written there would share an import list
  * with the runtime it replaces — and "the core poser imports nothing from
  * spine-core" could then only be said, not read off the file. Here it can be:
  * the value imports below are the core, the atlas reader and nothing else, and
@@ -32,7 +34,11 @@
  *   region a drawn attachment samples (`drawnRegions` over the pose's `shown`
  *   records and draw order), a region's four UVs (`regionPageUvs`) and a
  *   mesh's (`meshPageUvs`), each held to `sequence.getUVs(index)` at
- *   tolerance 0 on every corpus by `core_gate`'s `uvs` blocks.
+ *   tolerance 0 on every corpus by `core_gate`'s `uvs` blocks. Where each
+ *   region sits — its page, `x`, `y`, turn and the page's size — is the
+ *   document's `pages` section (issue #1016, `placementOf`), the atlas `build`
+ *   wrote spelled into the document, so a build draws with its `.atlas`
+ *   removed.
  * - **The tint** is the slot's light colour times the attachment's colour,
  *   channel by channel, as `src/render.ts`'s `tintOf` forms it; the dark
  *   colour is the slot's, absent where the slot carries none.
@@ -80,15 +86,16 @@ import type {
   PoseOptions,
   Posed,
   Poser,
+  SkinRoster,
   SlotSubset,
 } from './render.ts';
-import { atlasRegionLookup, parseAtlasText, type AtlasRegion } from './atlas.ts';
-import { spineFileSha256 } from './model.ts';
+import { atlasRegionLookup, parseAtlasText } from './atlas.ts';
+import { pagesOfAtlas, spineFileSha256, type ModelPage } from './model.ts';
 import { clipThrough, type ClipShape, type ShapeClipper } from './core/clipping.ts';
-import { CoreInputError, readModel, sourceOfDoc, underSkin, type CompiledDocument, type CoreSlotRow } from './core/index.ts';
+import { activeBones, CoreInputError, readModel, sourceOfDoc, underSkin, type CompiledDocument, type CoreSlotRow } from './core/index.ts';
 import { poseRawAnimation, poseRawSetup, type RawDrawn, type RawPose } from './core/raw.ts';
 import { CORE_ALL_SKINS, CORE_DEFAULT_SKIN, lookupSkins } from './core/skins.ts';
-import { drawnRegions, meshPageUvs, readUvSequences, regionPageUvs, type DrawnRegion, type UvSource } from './core/uvs.ts';
+import { documentPageLookup, drawnRegions, meshPageUvs, readUvSequences, regionPageUvs, type DrawnRegion, type UvRegion, type UvSource } from './core/uvs.ts';
 import { regionCorners, worldVertices } from './core/vertices.ts';
 import type { CoreWorld } from './core/world.ts';
 
@@ -256,20 +263,27 @@ export function clipSourceOf(
 /** The runtime's own triangulation of a region's quad — `src/render.ts`'s `QUAD_TRIANGLES`. */
 const QUAD_TRIANGLES: readonly number[] = [0, 1, 2, 2, 3, 0];
 
-/** Everything a core pose reads besides the pose: the document under one skin, and the atlas. */
+/** A region as texture substitution reads it: the page-UV rules' numbers, and the name and `index:` its key is made of (`regionKey`). */
+type TextureRegion = UvRegion & { name: string; index: number };
+
+/** Everything a core pose reads besides the pose: the document under one skin, and where each region sits on its page. */
 interface CoreInput {
   doc: CompiledDocument;
   source: UvSource;
-  /** The atlas region a name draws, as rigc's reader holds it — what an original-art UV reads its trim from. */
-  region: (name: string) => AtlasRegion | null;
+  /** The region a name draws — the document's `pages`, or for a `/1` document the atlas's — what an original-art UV reads its trim from. */
+  region: (name: string) => TextureRegion | null;
 }
 
 /**
  * The document posed with no skin set — spine-core's initial state, every slot
  * resolved through the default skin alone — or refused by name where that
  * equivalence was not measured (the header's *The skin*).
+ *
+ * Exported for the model side of the validator (issue #1025), which poses a
+ * slot the way `validate()` does — a fresh skeleton, no skin set — and must
+ * resolve that state by this rule rather than by a copy of it.
  */
-function noSkinView(doc: CompiledDocument): CompiledDocument {
+export function noSkinView(doc: CompiledDocument): CompiledDocument {
   if (doc.skins.length === 0) return underSkin(doc, CORE_ALL_SKINS);
   const fallback = doc.skins.find((k) => k.name === CORE_DEFAULT_SKIN);
   if (fallback === undefined) {
@@ -300,12 +314,12 @@ function worldOf(pose: RawPose): Map<string, CoreWorld> {
 }
 
 /** `regionKey` in `src/render.ts`: the trimmed name and the sequence index — the key a substitution matches on. */
-function regionKey(region: AtlasRegion): string {
+function regionKey(region: TextureRegion): string {
   return `${region.name.trim()}#${region.index}`;
 }
 
 /** `artUvsOf` in `src/render.ts`, over rigc's atlas reader: a mesh's own UVs, a region's kept rectangle in the drawing's space. */
-function artUvsOf(drawn: RawDrawn, region: AtlasRegion): PieceTexture | undefined {
+function artUvsOf(drawn: RawDrawn, region: TextureRegion): PieceTexture | undefined {
   if (drawn.kind === 'mesh') return { region: regionKey(region), artUvs: [...drawn.uvs] };
   if (region.degrees !== 0) return undefined;
   const ow = region.originalWidth;
@@ -515,9 +529,70 @@ function restOf(view: CompiledDocument, setup: RawPose, shown: readonly Attachme
 }
 
 /**
- * `Poser` over rigc's own core: `modelText` a `rigc-compiled/1` document
- * (`skeleton.model.json`), `atlasText` the atlas the render samples — the one
- * `build` wrote beside it. With `skeleton`, the Spine file beside the document
+ * The first place two `pages` sections differ, by path, or `null` when they
+ * are the same — the page count, a page's name or size, a region count, or a
+ * region's name or one of its numbers.
+ */
+export function firstPageDifference(stated: readonly ModelPage[], found: readonly ModelPage[]): string | null {
+  if (stated.length !== found.length) return `the document states ${stated.length} page(s), the atlas has ${found.length}`;
+  for (let i = 0; i < stated.length; i++) {
+    const a = stated[i];
+    const b = found[i];
+    for (const key of ['name', 'width', 'height'] as const) {
+      if (a[key] !== b[key]) return `pages[${i}].${key} is ${JSON.stringify(a[key])} in the document and ${JSON.stringify(b[key])} in the atlas`;
+    }
+    if (a.regions.length !== b.regions.length) return `pages[${i}] "${a.name}" holds ${a.regions.length} region(s) in the document and ${b.regions.length} in the atlas`;
+    for (let j = 0; j < a.regions.length; j++) {
+      const r = a.regions[j];
+      const q = b.regions[j];
+      for (const key of Object.keys(r) as Array<keyof typeof r>) {
+        if (r[key] !== q[key]) return `pages[${i}] "${a.name}" region ${JSON.stringify(r.name)}: ${key} is ${JSON.stringify(r[key])} in the document and ${JSON.stringify(q[key])} in the atlas`;
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Where each region a core pose draws sits on its page, read from the
+ * document's `pages` section (issue #1016) — or, for a `rigc-compiled/1`
+ * document, which has none, from `atlasText` as before. With both, the atlas
+ * must be the one the document was written beside: a page or region that
+ * differs is refused naming the first difference, so the core never draws the
+ * build's placement over another atlas's pages while spine-core, reading that
+ * atlas, would draw another picture.
+ */
+function placementOf(doc: CompiledDocument, atlasText: string, where: string): { lookup: UvSource['lookup']; region: CoreInput['region'] } {
+  if (doc.pages !== null) {
+    if (atlasText !== '') {
+      const differs = firstPageDifference(doc.pages, pagesOfAtlas(atlasText));
+      if (differs !== null) {
+        throw new CoreInputError(
+          `the atlas beside ${where} is not the one it was written beside: ${differs} — ` +
+            'the core would draw the build\'s placement over pages the atlas has rearranged',
+        );
+      }
+    }
+    const lookup = documentPageLookup(doc.pages);
+    return { lookup, region: (name) => lookup(name)?.region ?? null };
+  }
+  if (atlasText === '') {
+    throw new CoreInputError(
+      `${where} is a ${doc.spec} document, which does not state where each region sits on its page (the pages section, issue #1016), ` +
+        'and no atlas was given to read it from — rebuild it to carry them, or pose it beside the atlas it was built with',
+    );
+  }
+  const lookup = atlasRegionLookup(parseAtlasText(atlasText));
+  return { lookup, region: (name) => lookup(name)?.region ?? null };
+}
+
+/**
+ * `Poser` over rigc's own core: `modelText` a `rigc-compiled/2` document
+ * (`skeleton.model.json`), which states where each region sits on its page
+ * (`pages`, issue #1016), so `atlasText` may be `''`; given, it is held to
+ * the document's `pages` (`placementOf`). A `rigc-compiled/1` document states
+ * no placement and is drawn through `atlasText`, the atlas `build` wrote
+ * beside it, as before; with none given it is refused by name. With `skeleton`, the Spine file beside the document
  * is held to the digest the document records (`spine.sha256`, issue #968) and
  * refused, naming both digests, when it is not that build's. Refused by
  * `CoreInputError`, naming why, where the document or the atlas cannot be read; a pose the core leaves a block of out
@@ -542,8 +617,7 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
     throw new CoreInputError(`${where}: not JSON — ${(err as Error).message}`);
   }
   const sequences = readUvSequences(parsed);
-  const atlas = parseAtlasText(atlasText);
-  const lookup = atlasRegionLookup(atlas);
+  const { lookup, region } = placementOf(doc, atlasText, where);
   const views = new Map<string, CompiledDocument>();
   const inputOf = (skin: string | undefined): CoreInput => {
     const key = skin === undefined ? '' : `=${skin}`;
@@ -552,7 +626,7 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
       view = skin === undefined ? noSkinView(doc) : underSkin(doc, skin);
       views.set(key, view);
     }
-    return { doc: view, source: { lookup, sequences }, region: (name) => lookup(name)?.region ?? null };
+    return { doc: view, source: { lookup, sequences }, region };
   };
   const roster: SubsetRoster = {
     declared: doc.slots.map((s) => s.name),
@@ -580,3 +654,86 @@ export function corePoser(modelText: string, atlasText: string, where = 'skeleto
     },
   };
 }
+
+/**
+ * The skin roster behind the core poser (`SkinRoster` in `src/render.ts`,
+ * issue #1014): the bones each skin leaves unposed, read off the model
+ * document — `unposedBones` over `activeBones` of the skin's view, the
+ * predicate the raw pose flags its bones with, and under no skin the view the
+ * core poses with no skin set (`noSkinView`, refused by `CoreInputError` where
+ * it refuses to pose). `skins` is the Spine file's own list, in its order, which
+ * the document does not hold (`resolveSkinView`'s note in `./core/index.ts`).
+ *
+ * Measured against the runtime's reading (`skinRosterOf`, a fresh skeleton's
+ * `active` under each skin and under none) on every rigc build the tree
+ * carries: the same bones, under every skin. Since issue #1020 it is handed the
+ * document `coreDocumentFacts` read for the run's other facts, so the roster
+ * costs no reading of its own; a skin's view is still built only when a
+ * question is asked of it.
+ */
+function coreSkinRoster(doc: CompiledDocument, skins: readonly string[]): SkinRoster {
+  return {
+    skins,
+    unposedUnder: (skin) => {
+      const view = skin === undefined ? noSkinView(doc) : underSkin(doc, skin);
+      const active = activeBones(view);
+      return unposedBones(view.bones.map((b) => ({ name: b.name, parent: b.parent ?? null, active: active.has(b.name) })));
+    },
+  };
+}
+
+/**
+ * What `render` and `check` read off a rigc build's model document besides the
+ * pose (issue #1020) — so a build the core poses draws with its
+ * `skeleton.atlas` gone, and reads off `skeleton.json` only what the document
+ * does not state.
+ */
+export interface CoreDocumentFacts {
+  /** The document's spec: `rigc-compiled/2` states where each region sits on its page, `rigc-compiled/1` does not. */
+  spec: string;
+  /**
+   * Every page the `pages` section states, by name, in file order — the
+   * images the draw samples, read by these names; `null` for a
+   * `rigc-compiled/1` document, whose pages only its atlas names.
+   */
+  pageNames: readonly string[] | null;
+  /** The skin roster behind the core poser (`coreSkinRoster`), over this one reading. */
+  roster: SkinRoster;
+  /**
+   * The slot subset's roster (`subsetOver`): the slots in the document's draw
+   * order, its default skin, and the skins the document files a slot's
+   * attachments under. A refusal lists those skins, and the order it lists
+   * them in is the Spine file's, which the document does not hold
+   * (`./core/index.ts`, *Several skins filling one placeholder*) — so they are
+   * put in `skins`' order, the Spine file's own list.
+   */
+  subset: SubsetRoster;
+}
+
+/**
+ * The document's facts for `render` and `check` (`CoreDocumentFacts`), read
+ * once. `skins` is the Spine file's skin list, in its order — the one fact
+ * here the document does not state. Refused by `CoreInputError` where
+ * `readModel` refuses the document.
+ */
+export function coreDocumentFacts(modelText: string, where: string, skins: readonly string[]): CoreDocumentFacts {
+  const doc = readModel(modelText, where);
+  const rank = (name: string): number => {
+    const at = skins.indexOf(name);
+    return at < 0 ? skins.length : at;
+  };
+  return {
+    spec: doc.spec,
+    pageNames: doc.pages === null ? null : doc.pages.map((page) => page.name),
+    roster: coreSkinRoster(doc, skins),
+    subset: {
+      declared: doc.slots.map((s) => s.name),
+      carriers: (slot) =>
+        doc.skins
+          .filter((k) => Object.keys(k.attachments[slot] ?? {}).length > 0)
+          .map((k) => k.name)
+          .sort((a, b) => rank(a) - rank(b)),
+      defaultSkin: doc.skins.some((k) => k.name === CORE_DEFAULT_SKIN) ? CORE_DEFAULT_SKIN : null,
+    },
+  };
+}

package/src/transform.ts

@@ -11,7 +11,7 @@
  * measured polygon. That is why the old code refused rotation instead of ignoring
  * it, and why this file exists rather than a relaxed assertion.
  *
- * The composition mirrors spine-core exactly (`Bone.updateWorldTransform`):
+ * The composition, for a bone with a parent in the `normal` mode:
  *
  *   la = cos(rot)      lb = cos(rot + 90) = -sin(rot)
  *   lc = sin(rot)      ld = sin(rot + 90) =  cos(rot)
@@ -28,9 +28,44 @@
  * at scale 2 measured **0.752×** the runtime's own `PathConstraint.curves` on the
  * build's posed geometry, and a production rig's weighted path 2.35×. The
  * weights were blended all along; the matrices they were blended through were
- * wrong. `computeWorldTransforms` below is `BonePose.updateWorldTransform`
- * (spine-core 4.3.13, `BonePose.js:110-216`) at setup, with a skeleton scale of 1.
+ * wrong.
+ *
+ * ⭐ **`computeWorldTransforms` is the core's evaluator** (`worldTransforms` in
+ * [`src/core/world.ts`](core/world.ts), issue #1015), whose every rule — the five
+ * inherit modes, the collapsed parent axis, the operation orders — was measured
+ * against the runtime's pose dump and is held there by the core suite. Since
+ * issue #1021 it runs under the runtime's own arithmetic (`RUNTIME_ARITHMETIC`,
+ * the evaluator's default), so the matrices every point is bound through are the
+ * ones the runtime poses the build with, to the bit. This file keeps what is the
+ * compiler's own: the coordinate contract, the refusals by name, the world
+ * rotation a region cancels, and the inverses.
+ *
+ * ⚠️ **Why the runtime's arithmetic and not the textbook's** (issue #1021). A
+ * point is bound by inverting a setup matrix; the runtime then poses it through
+ * its own. The two used to differ in the last bits — `Math.PI` against the
+ * runtime's 3.1415927, `[cos, −sin, sin, cos]` against the y column taken at
+ * `rotation + 90`, radians to degrees by division against multiplication — and
+ * that is not noise below the file's precision: an unrotated root reads
+ * `b = −2.3e-8` in the runtime, so a point 256 units above its bone was bound
+ * 5.9e-6 off before the float32 spelling was even applied. Measured from inside
+ * `compile` (every authored world position `toBoneLocal` was handed) against
+ * spine-core's pose of the emitted build, the old arithmetic put `gallery/look`'s
+ * 312 bound points up to 8.6e-5 from where they were authored (RMS 5.1e-5) and
+ * `gallery/flex`'s 258 up to 2.3e-5; the runtime's puts every one of them at the
+ * float32 floor — the distance the float32 spelling of the exact inverse alone
+ * accounts for (look 8.1e-6, flex 4.1e-6). `CO24` holds it.
+ *
+ * 🔸 **The rule has a second half: what is MEASURED reads the exact frame.**
+ * The runtime's arithmetic is for what is bound — the matrices a point is
+ * inverted through. Anything the compiler measures of the authored rig and
+ * reports, compares against a threshold, sorts by or refuses on is a statement
+ * about the spec, and reads `computeExactFrameTransforms` (below): a depth turn
+ * ceiling, a ring's control angles, a `segments` mesh's segments and falloff.
+ * An angle the author stated as 90 has to print as 90.
  */
+import type { ModelBone } from './model.ts';
+import { modeMatrix, RUNTIME_ARITHMETIC, worldTransforms, type CoreWorld, type WorldArithmetic } from './core/world.ts';
+
 /**
  * What `computeWorldTransforms` reads off a bone — a structural type, so both a
  * Spine bone (`SpineBone`, what spine-parts and every skeleton reader hold) and
@@ -68,8 +103,6 @@ export interface BoneTransform {
 
 export class TransformError extends Error {}
 
-const DEG = Math.PI / 180;
-
 /**
  * Crop pixels (y down, origin top-left) -> Spine world (y up, origin at the
  * bottom-left of the crop).
@@ -85,6 +118,20 @@ export function cropToSpineY(cropY: number, cropHeight: number): number {
   return cropHeight - cropY;
 }
 
+/**
+ * The textbook's arithmetic — `Math.PI`, a bone with the default scale and no
+ * shear framed as `[cos, −sin, sin, cos]`, radians to degrees by dividing by
+ * the degree factor — in which an unrotated bone's frame is the identity
+ * exactly. Every point the compiler binds goes through the runtime's instead
+ * (the header's ⚠️); this is what `computeExactFrameTransforms` evaluates
+ * under, and nothing else.
+ */
+const EXACT_FRAME_ARITHMETIC: WorldArithmetic = {
+  radiansPerDegree: Math.PI / 180,
+  degreesOf: (radians) => radians / (Math.PI / 180),
+  rotationOnlyFrame: true,
+};
+
 /**
  * World transform of every bone, in declaration order.
  *
@@ -92,69 +139,76 @@ export function cropToSpineY(cropY: number, cropHeight: number): number {
  * requires (it resolves `parent` by name against the bones already read), so a
  * violation here is a violation there.
  *
- * 🔒 **A bone with the default scale and no shear takes the exact arithmetic
- * this function always used** — `lb = -sin`, `ld = cos` rather than the
- * runtime's `cos(rot + 90°)`/`sin(rot + 90°)`, which can differ in the last bit.
- * Every figure rigc emitted off an unscaled rig was computed that way, and one
- * bit there can move a float32 spelling in the file, so the general local matrix
- * is taken only where the old one was wrong: nothing an unscaled, normally
- * inheriting rig emits moves by a byte. The five `inherit` cases are the
- * runtime's, transcribed.
+ * The matrices and origins are the core's (`worldTransforms`, under the
+ * runtime's arithmetic — the header's ⚠️). What is decided here is what the core does not say:
+ * an undeclared parent and an `inherit` no mode answers to are refused by name
+ * as `TransformError`, a bone whose `parent` is empty is a root as it always was
+ * here, and `worldRotation` is read off the matrix — a root with the default
+ * scale and no shear keeps its stated rotation, unwrapped. The angle is turned
+ * into degrees as the runtime turns one (`RUNTIME_DEG`, by multiplying), so
+ * the rotation a region writes to cancel it is read back by the runtime as
+ * that angle.
  */
 export function computeWorldTransforms(bones: readonly PosableBone[]): Map<string, BoneTransform> {
-  const out = new Map<string, BoneTransform>();
+  return evaluate(bones, RUNTIME_ARITHMETIC);
+}
+
+/**
+ * The same bones under `EXACT_FRAME_ARITHMETIC`: the frame the compiler
+ * MEASURES the authored rig in, and binds nothing through (issue #1021) — a
+ * mesh's depth turn ceiling (`sampleMeshDepth` in `compile.ts`), a ring's
+ * control angles (`ringControlAngles`, which orders the split and refuses a
+ * tie by printing the angle), and a `segments` mesh's segments, the distances
+ * its falloff and `minWeight` read and its shared-origin refusal. It differs from
+ * `computeWorldTransforms` only in the last bits, and that is exactly why it is
+ * kept (issue #1021): the ceiling is a statement about the authored mesh, and
+ * its reader treats an axis whose area term is exactly zero as one that cannot
+ * fold. The runtime frames an unrotated bone with `b = −2.3e-8`, so in its
+ * bind space a sheet whose depth rises linearly in x — which cannot fold a
+ * pitch at any angle — reads a pitch ceiling of 89.99997°, and `gallery/look`'s
+ * two hair locks gained four such ceilings with their counts (`TC03`, `TC06`
+ * went red on it). A control angle read through the runtime's frame printed
+ * an authored 90 as 89.99999734089101 in its tie refusal (`RF46`). On the 19
+ * recipes the only bytes this keeps from moving are look's ceilings; no
+ * emitted position goes through it.
+ */
+export function computeExactFrameTransforms(bones: readonly PosableBone[]): Map<string, BoneTransform> {
+  return evaluate(bones, EXACT_FRAME_ARITHMETIC);
+}
+
+function evaluate(bones: readonly PosableBone[], arithmetic: WorldArithmetic): Map<string, BoneTransform> {
+  const model: ModelBone[] = [];
+  const declared = new Set<string>();
   for (const bone of bones) {
-    const rotation = bone.rotation ?? 0;
-    const scaleX = bone.scaleX ?? 1;
-    const scaleY = bone.scaleY ?? 1;
-    const shearX = bone.shearX ?? 0;
-    const shearY = bone.shearY ?? 0;
-    const plain = scaleX === 1 && scaleY === 1 && shearX === 0 && shearY === 0;
-    let la: number;
-    let lb: number;
-    let lc: number;
-    let ld: number;
-    if (plain) {
-      const cos = Math.cos(rotation * DEG);
-      const sin = Math.sin(rotation * DEG);
-      la = cos;
-      lb = -sin;
-      lc = sin;
-      ld = cos;
-    } else {
-      const rx = (rotation + shearX) * DEG;
-      const ry = (rotation + 90 + shearY) * DEG;
-      la = Math.cos(rx) * scaleX;
-      lb = Math.cos(ry) * scaleY;
-      lc = Math.sin(rx) * scaleX;
-      ld = Math.sin(ry) * scaleY;
-    }
-    const x = bone.x ?? 0;
-    const y = bone.y ?? 0;
-    if (!bone.parent) {
-      const worldRotation = plain ? rotation : (Math.atan2(lc, la) / DEG + 360) % 360;
-      out.set(bone.name, { a: la, b: lb, c: lc, d: ld, worldX: x, worldY: y, worldRotation });
-      continue;
+    const parent = bone.parent ? bone.parent : undefined;
+    if (parent !== undefined && !declared.has(parent)) {
+      throw new TransformError(`bone "${bone.name}" names parent "${parent}", which is not declared before it`);
     }
-    const p = out.get(bone.parent);
-    if (!p) throw new TransformError(`bone "${bone.name}" names parent "${bone.parent}", which is not declared before it`);
-    const [a, b, c, d] = inheritedMatrix(inheritMode(bone), p, [la, lb, lc, ld], rotation, scaleX, scaleY, shearX, shearY);
-    out.set(bone.name, {
-      a,
-      b,
-      c,
-      d,
-      worldX: p.a * x + p.b * y + p.worldX,
-      worldY: p.c * x + p.d * y + p.worldY,
-      worldRotation: (Math.atan2(c, a) / DEG + 360) % 360,
+    model.push({
+      name: bone.name,
+      parent,
+      x: bone.x,
+      y: bone.y,
+      rotation: bone.rotation,
+      scaleX: bone.scaleX,
+      scaleY: bone.scaleY,
+      shearX: bone.shearX,
+      shearY: bone.shearY,
+      inheritMode: parent === undefined ? undefined : inheritMode(bone),
     });
+    declared.add(bone.name);
+  }
+  const worlds = worldTransforms(model, null, modeMatrix, arithmetic);
+  const out = new Map<string, BoneTransform>();
+  for (const bone of model) {
+    const w = worlds.get(bone.name) as CoreWorld;
+    const plain = (bone.scaleX ?? 1) === 1 && (bone.scaleY ?? 1) === 1 && (bone.shearX ?? 0) === 0 && (bone.shearY ?? 0) === 0;
+    const worldRotation = bone.parent === undefined && plain ? (bone.rotation ?? 0) : (arithmetic.degreesOf(Math.atan2(w.c, w.a)) + 360) % 360;
+    out.set(bone.name, { a: w.a, b: w.b, c: w.c, d: w.d, worldX: w.worldX, worldY: w.worldY, worldRotation });
   }
   return out;
 }
 
-/** `MathUtils.epsilon2` — the threshold `noRotationOrReflection` tests a degenerate parent against. */
-const EPSILON2 = 0.00001 * 0.00001;
-
 type InheritMode = 'normal' | 'onlyTranslation' | 'noRotationOrReflection' | 'noScale' | 'noScaleOrReflection';
 
 const INHERIT_MODES: readonly InheritMode[] = ['normal', 'onlyTranslation', 'noRotationOrReflection', 'noScale', 'noScaleOrReflection'];
@@ -177,75 +231,6 @@ function inheritMode(bone: PosableBone): InheritMode {
   return mode;
 }
 
-/**
- * `BonePose.updateWorldTransform`'s switch (`BonePose.js:136-215`) for a bone
- * with a parent, at a skeleton scale of 1 — so every `sx`/`sy` factor there is 1
- * and is left out rather than multiplied in.
- */
-function inheritedMatrix(
-  inherit: InheritMode,
-  p: BoneTransform,
-  local: [number, number, number, number],
-  rotation: number,
-  scaleX: number,
-  scaleY: number,
-  shearX: number,
-  shearY: number,
-): [number, number, number, number] {
-  const [la, lb, lc, ld] = local;
-  if (inherit === 'normal') {
-    return [p.a * la + p.b * lc, p.a * lb + p.b * ld, p.c * la + p.d * lc, p.c * lb + p.d * ld];
-  }
-  if (inherit === 'onlyTranslation') return [la, lb, lc, ld];
-  if (inherit === 'noRotationOrReflection') {
-    let pa = p.a;
-    let pb = p.b;
-    let pc = p.c;
-    let pd = p.d;
-    let s = pa * pa + pc * pc;
-    let r: number;
-    if (s > EPSILON2) {
-      s = Math.abs(pa * pd - pb * pc) / s;
-      pb = pc * s;
-      pd = pa * s;
-      r = rotation - Math.atan2(pc, pa) / DEG;
-    } else {
-      pa = 0;
-      pc = 0;
-      r = rotation - 90 + Math.atan2(pd, pb) / DEG;
-    }
-    const rx = (r + shearX) * DEG;
-    const ry = (r + shearY + 90) * DEG;
-    const ra = Math.cos(rx) * scaleX;
-    const rb = Math.cos(ry) * scaleY;
-    const rc = Math.sin(rx) * scaleX;
-    const rd = Math.sin(ry) * scaleY;
-    return [pa * ra - pb * rc, pa * rb - pb * rd, pc * ra + pd * rc, pc * rb + pd * rd];
-  }
-  // noScale / noScaleOrReflection
-  const r = rotation * DEG;
-  const cos = Math.cos(r);
-  const sin = Math.sin(r);
-  let za = p.a * cos + p.b * sin;
-  let zc = p.c * cos + p.d * sin;
-  const s = 1 / Math.sqrt(za * za + zc * zc);
-  za *= s;
-  zc *= s;
-  let zb = -zc;
-  let zd = za;
-  if (inherit === 'noScale' && p.a * p.d - p.b * p.c < 0) {
-    zb = -zb;
-    zd = -zd;
-  }
-  const rx = shearX * DEG;
-  const ry = (90 + shearY) * DEG;
-  const ra = Math.cos(rx) * scaleX;
-  const rb = Math.cos(ry) * scaleY;
-  const rc = Math.sin(rx) * scaleX;
-  const rd = Math.sin(ry) * scaleY;
-  return [za * ra + zb * rc, za * rb + zb * rd, zc * ra + zd * rc, zc * rb + zd * rd];
-}
-
 /**
  * World point -> the bone's local space. Used for bind coordinates and offsets.
  *

package/src/types.ts

@@ -1098,11 +1098,12 @@ export interface SpineClippingAttachment {
  * is re-parameterised by the trip rather than corrupted by it.
  *
  * ⇒ **rigc emits that computation, not a sampler aimed at it** (issue #560).
- * `pathCurveLengths` in [`compile.ts`](compile.ts) is `PathConstraint.js:301-320`
- * transcribed, down to `Math.sqrt(dx * dx + dy * dy)` rather than `Math.hypot`
- * and `0.16666667` rather than `1 / 6`; `PS67`, `PS68` and `PS187` in `selftest.ts` hold it
- * there by requiring it to reproduce a real `PathConstraint.curves` array **bit
- * for bit** on the runtime's own posed chain. Measured after the change, all
+ * `pathCurveLengths` in [`compile.ts`](compile.ts) measures with the core's
+ * curve table (`curveLengthTable` in `src/core/constraints_path.ts`, issue
+ * #1015), down to `Math.sqrt(dx * dx + dy * dy)` rather than `Math.hypot` and
+ * `0.16666667` rather than `1 / 6`; `PS67`, `PS68` and `PS186` in `selftest.ts`
+ * hold it there by requiring it to reproduce a real `PathConstraint.curves`
+ * array **bit for bit** on the runtime's own posed chain. Measured after the change, all
  * seven entries of both editor exports above come back at the precision the
  * editor prints them.
  *