spine-rigc 1.6.2 → 1.8.0

package/src/core/index.ts

@@ -1,6 +1,7 @@
 /**
  * rigc's own core: it reads the compiled model as `build` writes it
- * (`rigc-compiled/1`, `skeleton.model.json`) and poses it (issue #925, step 2a
+ * (`rigc-compiled/2`, and `/1` before issue #1016; `skeleton.model.json`)
+ * and poses it (issue #925, step 2a
  * of issue #380). It is the second dumper `tools/pose_oracle.ts` was shaped
  * for: what it poses is written into the same `pose-oracle/2` document the
  * runtime's dump is, and `compare` holds the two to each other.
@@ -153,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.
  *
@@ -168,7 +171,7 @@
  * child process, no file system — `readModel` takes the document's TEXT — and
  * nothing from the Spine runtime package, as a value or as a type.
  */
-import type { ModelAtlasRect, ModelBone, ModelSlot, ModelVertices, SkinTableEntry } from '../model.ts';
+import type { ModelAtlasRect, ModelBone, ModelPage, ModelPageRegion, ModelSlot, ModelVertices, SkinTableEntry } from '../model.ts';
 import { worldTransforms, type CoreWorld } from './world.ts';
 import { readAnimationTimelines, type CoreAnimationTimelines } from './animation.ts';
 import { readEventDefs, type CoreEventDef } from './events.ts';
@@ -183,8 +186,19 @@ import { attachmentStates, type DeformBlender, type DeformEvaluator, type Sequen
 import { drawOrderAt, type DrawOrderEvaluator } from './draw_order.ts';
 import type { EventsFired } from './events.ts';
 
-/** The document spec this reader takes. */
-export const CORE_DOCUMENT_SPEC = 'rigc-compiled/1';
+/**
+ * The document spec `build` writes today, and the one this reader takes with
+ * the `pages` section (issue #1016).
+ */
+export const CORE_DOCUMENT_SPEC = 'rigc-compiled/2';
+
+/**
+ * The spec before issue #1016: the same sections without `pages`. Read as
+ * before — the draw then takes where each region sits from the atlas beside
+ * the document (`corePoser` in `src/render_core.ts` says so by name), because
+ * a `/1` document does not state it.
+ */
+export const CORE_DOCUMENT_SPEC_1 = 'rigc-compiled/1';
 
 /** Who posed a dump the core wrote — the oracle document's `dumper`. */
 export const CORE_DUMPER = 'rigc-core';
@@ -196,10 +210,19 @@ export class CoreInputError extends Error {}
 export const CORE_SECTIONS = [
   'referenceScale', 'bones', 'slots', 'skins', 'constraints', 'events', 'animations',
   'images', 'pageGrids', 'droppedStates', 'absentParts', 'meshBones', 'meshes', 'physics', 'deformTransforms', 'trackDerivations', 'rig',
+  // Issue #1016: where each region sits on its page, in the atlas written beside the document (`pagesOfAtlas` in `src/model.ts`). `/2` only.
+  'pages',
   // Issue #968: the digest of the `skeleton.json` written beside the document (`spineFileSha256` in `src/model.ts`).
   'spine',
 ] as const;
 
+/** The sections of a `rigc-compiled/1` document: `CORE_SECTIONS` without `pages`. */
+export const CORE_SECTIONS_1: readonly string[] = CORE_SECTIONS.filter((key) => key !== 'pages');
+
+/** The fields of a page and of a region in the `pages` section, as the writer lists them (`MODEL_PAGE_FIELDS`, `MODEL_PAGE_REGION_FIELDS` in `src/model.ts`, mirrored). */
+export const CORE_PAGE_FIELDS = ['name', 'width', 'height', 'regions'] as const;
+export const CORE_PAGE_REGION_FIELDS = ['name', 'x', 'y', 'width', 'height', 'offsetX', 'offsetY', 'originalWidth', 'originalHeight', 'degrees', 'index'] as const;
+
 /** The fields a bone record may carry, as the writer lists them. A field outside this list is refused. */
 export const CORE_BONE_FIELDS = ['name', 'parent', 'length', 'x', 'y', 'rotation', 'scaleX', 'scaleY', 'shearX', 'shearY', 'inheritMode', 'skinRequired', 'editor'] as const;
 const BONE_NUMBERS = ['length', 'x', 'y', 'rotation', 'scaleX', 'scaleY', 'shearX', 'shearY'] as const;
@@ -297,7 +320,7 @@ export interface CoreAnimation {
 }
 
 /**
- * A `rigc-compiled/1` document, read. `bones` and `slots` are checked field by
+ * A `rigc-compiled/2` (or `/1`) document, read. `bones` and `slots` are checked field by
  * field against the writer's own records; skins and constraints are read as
  * far as their names and memberships, and every other section is only
  * required to be present — no construct this card admits reads it.
@@ -319,6 +342,66 @@ export interface CompiledDocument {
   animations: CoreAnimation[];
   /** The digest of the `skeleton.json` `build` wrote beside the document (issue #968) — what a render holds the file beside it to before posing it here. */
   spine: { sha256: string };
+  /**
+   * Every page of the atlas `build` wrote beside the document and every region
+   * on it, in file order (issue #1016) — where each drawing sits, which the
+   * draw's page UVs read. `null` for a `rigc-compiled/1` document, which does
+   * not state it.
+   */
+  pages: ModelPage[] | null;
+}
+
+/**
+ * The `pages` section, checked: a list of pages, each holding exactly
+ * `CORE_PAGE_FIELDS` — a non-empty name, a size of two positive finite
+ * numbers, a list of regions — and each region exactly
+ * `CORE_PAGE_REGION_FIELDS`, a non-empty name and nine finite numbers. Every
+ * fault is named by its path. Nothing is defaulted: a field the writer always
+ * writes is required here.
+ */
+function readPages(value: unknown, problems: string[]): ModelPage[] {
+  if (!Array.isArray(value)) {
+    problems.push(`pages is ${JSON.stringify(value) ?? 'absent'}, not a list of pages`);
+    return [];
+  }
+  const out: ModelPage[] = [];
+  value.forEach((raw, i) => {
+    const where = `pages[${i}]`;
+    if (!isRecord(raw)) {
+      problems.push(`${where} is not an object`);
+      return;
+    }
+    const before = problems.length;
+    const label = typeof raw.name === 'string' ? `${where} "${raw.name}"` : where;
+    unknownFields(raw, CORE_PAGE_FIELDS, label, problems);
+    if (typeof raw.name !== 'string' || raw.name === '') problems.push(`${where}: name is ${JSON.stringify(raw.name) ?? 'absent'}, not a non-empty string`);
+    for (const key of ['width', 'height'] as const) {
+      const v = raw[key];
+      if (typeof v !== 'number' || !Number.isFinite(v) || v <= 0) problems.push(`${label}: ${key} is ${JSON.stringify(v) ?? 'absent'}, not a positive finite number — a page UV divides by it`);
+    }
+    const regions: ModelPageRegion[] = [];
+    if (!Array.isArray(raw.regions)) problems.push(`${label}: regions is not a list`);
+    else {
+      raw.regions.forEach((region, j) => {
+        const at = `${label}.regions[${j}]`;
+        if (!isRecord(region)) {
+          problems.push(`${at} is not an object`);
+          return;
+        }
+        const named = typeof region.name === 'string' ? `${at} "${region.name}"` : at;
+        unknownFields(region, CORE_PAGE_REGION_FIELDS, named, problems);
+        if (typeof region.name !== 'string' || region.name === '') problems.push(`${at}: name is ${JSON.stringify(region.name) ?? 'absent'}, not a non-empty string`);
+        for (const key of CORE_PAGE_REGION_FIELDS) {
+          if (key === 'name') continue;
+          const v = region[key];
+          if (typeof v !== 'number' || !Number.isFinite(v)) problems.push(`${named}: ${key} is ${JSON.stringify(v) ?? 'absent'}, not a finite number`);
+        }
+        regions.push(region as unknown as ModelPageRegion);
+      });
+    }
+    if (problems.length === before) out.push({ name: raw.name as string, width: raw.width as number, height: raw.height as number, regions });
+  });
+  return out;
 }
 
 /** The `spine` section's value, checked: `{ "sha256": <64 lowercase hex> }` and nothing else, each fault named by path (issue #968). */
@@ -615,7 +698,8 @@ function readConstraints(value: unknown, animations: readonly CoreAnimation[], b
 }
 
 /**
- * Read a `rigc-compiled/1` document from its text, refusing by name a text
+ * Read a `rigc-compiled/2` document — or a `rigc-compiled/1` one, which has
+ * no `pages` and is read with `pages: null` — from its text, refusing by name a text
  * that is not JSON, a wrong `spec`, a missing section (`referenceScale`
  * among them, issue #958), a section the document does not have, a
  * `referenceScale` that is not a finite number, and — in the records these constructs read (bones, slots,
@@ -633,12 +717,15 @@ export function readModel(text: string, where = 'the model document'): CompiledD
     throw new CoreInputError(`${where}: not JSON — ${(err as Error).message}`);
   }
   if (!isRecord(value)) throw new CoreInputError(`${where}: not a JSON object`);
-  if (value.spec !== CORE_DOCUMENT_SPEC) throw new CoreInputError(`${where}: spec is ${JSON.stringify(value.spec)}, not "${CORE_DOCUMENT_SPEC}"`);
+  if (value.spec !== CORE_DOCUMENT_SPEC && value.spec !== CORE_DOCUMENT_SPEC_1) throw new CoreInputError(`${where}: spec is ${JSON.stringify(value.spec)}, not "${CORE_DOCUMENT_SPEC}" (or "${CORE_DOCUMENT_SPEC_1}", read without its pages)`);
+  const spec = value.spec;
+  const sections: readonly string[] = spec === CORE_DOCUMENT_SPEC ? CORE_SECTIONS : CORE_SECTIONS_1;
   const problems: string[] = [];
-  for (const key of CORE_SECTIONS) if (!(key in value)) problems.push(`section "${key}" is missing`);
+  for (const key of sections) if (!(key in value)) problems.push(`section "${key}" is missing`);
   for (const key of Object.keys(value)) {
-    if (key !== 'spec' && !(CORE_SECTIONS as readonly string[]).includes(key)) problems.push(`section "${key}" is not one a ${CORE_DOCUMENT_SPEC} document has`);
+    if (key !== 'spec' && !sections.includes(key)) problems.push(`section "${key}" is not one a ${spec} document has`);
   }
+  const pages = spec === CORE_DOCUMENT_SPEC && 'pages' in value ? readPages(value.pages, problems) : null;
   // The skeleton's reference scale (issue #958): wind and gravity act over it, so a missing one is the section refusal above, and a value the runtime could not read as a number is refused here by name.
   const referenceScale = typeof value.referenceScale === 'number' && Number.isFinite(value.referenceScale) ? value.referenceScale : NaN;
   if ('referenceScale' in value && Number.isNaN(referenceScale)) problems.push(`referenceScale is ${JSON.stringify(value.referenceScale)}, not a finite number — wind and gravity act over it`);
@@ -666,7 +753,7 @@ export function readModel(text: string, where = 'the model document'): CompiledD
     });
   }
   if (problems.length > 0) throw new CoreInputError(`${where}: ${problems.length} problem(s): ${problems.join('; ')}`);
-  const doc: CompiledDocument = { spec: CORE_DOCUMENT_SPEC, skin: CORE_ALL_SKINS, referenceScale, bones, slots, skins, constraints, animations, spine: { sha256: spine } };
+  const doc: CompiledDocument = { spec, skin: CORE_ALL_SKINS, referenceScale, bones, slots, skins, constraints, animations, spine: { sha256: spine }, pages };
   resolveSkinView(doc);
   return doc;
 }

package/src/core/uvs.ts

@@ -5,12 +5,15 @@
  * and `sequence.getUVs(index)` — and `MeshAttachment.computeUVs`'s job, the
  * mapping texture substitution calls, as pure functions.
  *
- * The model document does not carry the page layout (`ModelAtlasRect`'s 🔸 in
+ * The page layout is not a model record (`ModelAtlasRect`'s 🔸 in
  * `src/model.ts`: the page, `x`, `y` and `rotate` are the packer's
- * arrangement, not the drawing), and this construct does not change that: the
- * atlas is a second input, read by rigc's own reader (`parseAtlasText` and
- * `atlasRegionLookup` in `src/atlas.ts`) and handed in as a lookup
- * (`UvLookup`), so nothing here links the runtime or opens a file.
+ * arrangement, not the drawing). It reaches these rules as a lookup
+ * (`UvLookup`), so nothing here links the runtime or opens a file: since
+ * issue #1016 from the document's own `pages` section, which `build` spells
+ * from the atlas it writes (`documentPageLookup` below); for a
+ * `rigc-compiled/1` document, which has none, from the atlas beside it, read
+ * by rigc's own reader (`parseAtlasText` and `atlasRegionLookup` in
+ * `src/atlas.ts`).
  *
  * ## How every rule below was fixed
  *
@@ -143,6 +146,7 @@ import { applyConstraints } from './constraints.ts';
 import type { SliderApplication } from './constraints_slider.ts';
 import { attachmentStates } from './deform.ts';
 import type { ShownGeometry } from './vertices.ts';
+import type { ModelPage, ModelPageRegion } from '../model.ts';
 import { worldTransforms } from './world.ts';
 
 /** A region as these rules read it — `AtlasRegion` in `src/atlas.ts` is one, and so is spine-core's `TextureAtlasRegion`. */
@@ -168,6 +172,22 @@ export interface UvPage {
 /** The region an atlas draws under a name, and its page — the first of that name, as the header states; `null` when there is none. */
 export type UvLookup = (name: string) => { page: UvPage; region: UvRegion } | null;
 
+/**
+ * The lookup over a document's `pages` section (issue #1016): the first region
+ * of a name in file order, pages in order and regions in each page's order —
+ * the order `pagesOfAtlas` in `src/model.ts` copies from the atlas, so this is
+ * `atlasRegionLookup` over the same text, with no atlas read. The name is
+ * compared as stored, untrimmed, as the header's *Which region* states.
+ */
+export function documentPageLookup(pages: readonly ModelPage[]): (name: string) => { page: UvPage; region: ModelPageRegion } | null {
+  const first = new Map<string, { page: UvPage; region: ModelPageRegion }>();
+  for (const page of pages) {
+    const at: UvPage = { name: page.name, width: page.width, height: page.height };
+    for (const region of page.regions) if (!first.has(region.name)) first.set(region.name, { page: at, region });
+  }
+  return (name) => first.get(name) ?? null;
+}
+
 /**
  * The readings the header's tables rejected, each a switch — what the core
  * suite's `CU` plants pass to show the gate names it. The functions below with

package/src/core/world.ts

@@ -3,9 +3,24 @@
  * the compiled model's bones (issue #925). Written from what a bone's fields
  * mean and from measurement against the runtime's pose dump
  * (`tools/pose_oracle.ts dump`, spine-core 4.3.13), and held to it by the core
- * suite's equivalence controls; it shares no code with `src/transform.ts`,
- * which is the compiler's arithmetic and stays frozen so that no emitted byte
- * moves.
+ * suite's equivalence controls.
+ *
+ * ⭐ **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
  *
@@ -99,6 +114,28 @@ export const RUNTIME_DEG = 180 / RUNTIME_PI;
 /** A parent x axis whose squared length is at most this is collapsed for `noRotationOrReflection` (issue #979): `1e-5` squared, as measured — see the header. */
 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 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. */
+  radiansPerDegree: number;
+  /** Radians to degrees — the angle `noRotationOrReflection` takes off a parent's axis. */
+  degreesOf: (radians: number) => number;
+  /** A bone with scale 1 and no shear takes `[cos r, −sin r, sin r, cos r]` instead of the y column at `r + 90`; the general frame everywhere else. */
+  rotationOnlyFrame: boolean;
+}
+
+/** The runtime's arithmetic, as measured (the header's three choices): what the core poses with. */
+export const RUNTIME_ARITHMETIC: WorldArithmetic = {
+  radiansPerDegree: RAD,
+  degreesOf: (radians) => radians * RUNTIME_DEG,
+  rotationOnlyFrame: false,
+};
+
 /** One bone's world transform: the matrix `[a b; c d]` and the origin, y up. */
 export interface CoreWorld {
   a: number;
@@ -114,16 +151,27 @@ export type CoreInheritMode = 'normal' | 'onlyTranslation' | 'noRotationOrReflec
 
 export type M2 = [number, number, number, number];
 
-/** What computes a child's world matrix from its mode, its parent's world and its own fields. */
-export type InheritComputation = (mode: CoreInheritMode, parent: CoreWorld, bone: ModelBone) => M2;
+/** What computes a child's world matrix from its mode, its parent's world, its own fields and the arithmetic in force. */
+export type InheritComputation = (mode: CoreInheritMode, parent: CoreWorld, bone: ModelBone, arithmetic: WorldArithmetic) => M2;
 
 /** The matrix of a rotation, shears and scales, in the column form the header states. */
-function frame(rotation: number, shearX: number, shearY: number, scaleX: number, scaleY: number): M2 {
-  const xAngle = (rotation + shearX) * RAD;
-  const yAngle = (rotation + 90 + shearY) * RAD;
+function frame(rotation: number, shearX: number, shearY: number, scaleX: number, scaleY: number, rad: number = RAD): M2 {
+  const xAngle = (rotation + shearX) * rad;
+  const yAngle = (rotation + 90 + shearY) * rad;
   return [Math.cos(xAngle) * scaleX, Math.cos(yAngle) * scaleY, Math.sin(xAngle) * scaleX, Math.sin(yAngle) * scaleY];
 }
 
+/** A bone's own frame — a root's matrix, and the local factor of `normal` and `onlyTranslation` — under `arithmetic`. */
+function localFrame(arithmetic: WorldArithmetic, rotation: number, shearX: number, shearY: number, scaleX: number, scaleY: number): M2 {
+  const rad = arithmetic.radiansPerDegree;
+  if (arithmetic.rotationOnlyFrame && scaleX === 1 && scaleY === 1 && shearX === 0 && shearY === 0) {
+    const cos = Math.cos(rotation * rad);
+    const sin = Math.sin(rotation * rad);
+    return [cos, -sin, sin, cos];
+  }
+  return frame(rotation, shearX, shearY, scaleX, scaleY, rad);
+}
+
 function times(p: M2, q: M2): M2 {
   return [p[0] * q[0] + p[1] * q[2], p[0] * q[1] + p[1] * q[3], p[2] * q[0] + p[3] * q[2], p[2] * q[1] + p[3] * q[3]];
 }
@@ -135,8 +183,8 @@ function times(p: M2, q: M2): M2 {
  * which builds the frame to read the bone's columns in from the rotation it
  * has just read, through this same arithmetic (issue #966).
  */
-export function noScaleDirection(p: M2, rotation: number): [number, number] {
-  const r = rotation * RAD;
+export function noScaleDirection(p: M2, rotation: number, rad: number = RAD): [number, number] {
+  const r = rotation * rad;
   const cos = Math.cos(r);
   const sin = Math.sin(r);
   const ux = p[0] * cos + p[1] * sin;
@@ -146,19 +194,20 @@ export function noScaleDirection(p: M2, rotation: number): [number, number] {
   return [ux * inverse, uy * inverse];
 }
 
-/** The world matrix of a child under `parent` in `mode`. */
-function modeMatrix(mode: CoreInheritMode, parent: CoreWorld, bone: ModelBone): M2 {
+/** The world matrix of a child under `parent` in `mode`, under `arithmetic` (the runtime's unless a caller passes its own). */
+function modeMatrix(mode: CoreInheritMode, parent: CoreWorld, bone: ModelBone, arithmetic: WorldArithmetic = RUNTIME_ARITHMETIC): M2 {
   const rotation = bone.rotation ?? 0;
   const shearX = bone.shearX ?? 0;
   const shearY = bone.shearY ?? 0;
   const scaleX = bone.scaleX ?? 1;
   const scaleY = bone.scaleY ?? 1;
+  const rad = arithmetic.radiansPerDegree;
   const p: M2 = [parent.a, parent.b, parent.c, parent.d];
   switch (mode) {
     case 'normal':
-      return times(p, frame(rotation, shearX, shearY, scaleX, scaleY));
+      return times(p, localFrame(arithmetic, rotation, shearX, shearY, scaleX, scaleY));
     case 'onlyTranslation':
-      return frame(rotation, shearX, shearY, scaleX, scaleY);
+      return localFrame(arithmetic, rotation, shearX, shearY, scaleX, scaleY);
     case 'noRotationOrReflection': {
       const xLengthSq = p[0] * p[0] + p[2] * p[2];
       let conformal: M2;
@@ -166,23 +215,23 @@ function modeMatrix(mode: CoreInheritMode, parent: CoreWorld, bone: ModelBone):
       if (xLengthSq > COLLAPSED_X_AXIS_SQ) {
         const k = Math.abs(p[0] * p[3] - p[1] * p[2]) / xLengthSq;
         conformal = [p[0], -p[2] * k, p[2], p[0] * k];
-        r = rotation - Math.atan2(p[2], p[0]) * RUNTIME_DEG;
+        r = rotation - arithmetic.degreesOf(Math.atan2(p[2], p[0]));
       } else {
         // A collapsed x axis (issue #979): the parent's y column with its x component negated, and the rotation less 90 plus the y column's angle — see the header.
         conformal = [0, -p[1], 0, p[3]];
-        r = rotation - 90 + Math.atan2(p[3], p[1]) * RUNTIME_DEG;
+        r = rotation - 90 + arithmetic.degreesOf(Math.atan2(p[3], p[1]));
       }
       // The y angle adds the shear before the right angle here, unlike `frame` (issue #966): `(r + 90 + shearY)` reads last-bit off on 81 of 205 sheared or scaled bones at a 1e9 amplifier, `(r + shearY + 90)` on none; `r = rotation − parentAngle` taken first (adding the shear before the parent's angle is taken off reads 102 of 205 off).
-      const xAngle = (r + shearX) * RAD;
-      const yAngle = (r + shearY + 90) * RAD;
+      const xAngle = (r + shearX) * rad;
+      const yAngle = (r + shearY + 90) * rad;
       return times(conformal, [Math.cos(xAngle) * scaleX, Math.cos(yAngle) * scaleY, Math.sin(xAngle) * scaleX, Math.sin(yAngle) * scaleY]);
     }
     case 'noScale':
     case 'noScaleOrReflection': {
-      const [ux, uy] = noScaleDirection(p, rotation);
+      const [ux, uy] = noScaleDirection(p, rotation, rad);
       const flip = mode === 'noScale' && p[0] * p[3] - p[1] * p[2] < 0 ? -1 : 1;
       const turned: M2 = [ux, -uy * flip, uy, ux * flip];
-      return times(turned, frame(0, shearX, shearY, scaleX, scaleY));
+      return times(turned, frame(0, shearX, shearY, scaleX, scaleY, rad));
     }
   }
 }
@@ -205,9 +254,16 @@ function modeOf(bone: ModelBone): CoreInheritMode {
  * world as a skeleton is created — and a bone under it, active or not, is
  * 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.
+ * flipped, and nothing else does. `arithmetic` is the runtime's unless a
+ * 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[], active: ReadonlySet<string> | null = null, inherit: InheritComputation = modeMatrix): Map<string, CoreWorld> {
+export function worldTransforms(
+  bones: readonly ModelBone[],
+  active: ReadonlySet<string> | null = null,
+  inherit: InheritComputation = modeMatrix,
+  arithmetic: WorldArithmetic = RUNTIME_ARITHMETIC,
+): Map<string, CoreWorld> {
   const out = new Map<string, CoreWorld>();
   for (const bone of bones) {
     if (active !== null && !active.has(bone.name)) {
@@ -217,13 +273,13 @@ export function worldTransforms(bones: readonly ModelBone[], active: ReadonlySet
     const x = bone.x ?? 0;
     const y = bone.y ?? 0;
     if (bone.parent === undefined) {
-      const [a, b, c, d] = frame(bone.rotation ?? 0, bone.shearX ?? 0, bone.shearY ?? 0, bone.scaleX ?? 1, bone.scaleY ?? 1);
+      const [a, b, c, d] = localFrame(arithmetic, bone.rotation ?? 0, bone.shearX ?? 0, bone.shearY ?? 0, bone.scaleX ?? 1, bone.scaleY ?? 1);
       out.set(bone.name, { a, b, c, d, worldX: x, worldY: y });
       continue;
     }
     const parent = out.get(bone.parent);
     if (parent === undefined) throw new Error(`bone "${bone.name}": parent "${bone.parent}" is not posed before it`);
-    const [a, b, c, d] = inherit(modeOf(bone), parent, bone);
+    const [a, b, c, d] = inherit(modeOf(bone), parent, bone, arithmetic);
     out.set(bone.name, { a, b, c, d, worldX: parent.a * x + parent.b * y + parent.worldX, worldY: parent.c * x + parent.d * y + parent.worldY });
   }
   return out;