@rig-c/core 2.70.0 → 2.71.0

package/src/core/index.ts

@@ -176,7 +176,7 @@ import type { ModelAtlasRect, ModelBone, ModelEditorOrder, ModelPage, ModelPageR
 import { worldTransforms, type CoreWorld } from './world.ts';
 import { readAnimationTimelines, type CoreAnimationTimelines } from './animation.ts';
 import { readEventDefs, type CoreEventDef } from './events.ts';
-import { poseGeometry, readGeometry, type CoreAttachmentRow, type CoreClipRow, type CoreGeometry, type DrawWalk, type MeshArraysOf, type RegionPoser, type ShownGeometry, type VertexPoser } from './vertices.ts';
+import { poseGeometry, readGeometry, type CoreAttachmentRow, type CoreClipRow, type CoreGeometry, type DeformedVertexPoser, type DrawWalk, type MeshArraysOf, type RegionPoser, type ShownGeometry, type VertexPoser } from './vertices.ts';
 import type { CoreClippedRow, ShapeClipper, TriangleClipper } from './clipping.ts';
 import { applyConstraints, constraintsAbsentWhy, readConstraintRecord, readConstraintTimelines, solverRules, type ConstraintPlant, type CoreConstraintRecord, type CoreConstraintTimelines, type SolverRules } from './constraints.ts';
 import { readPathRecord } from './constraints_path.ts';
@@ -1062,6 +1062,23 @@ export type BlendReader = (slot: ModelSlot) => CoreBlendMode;
 /** What reads a stated light colour into its four channels: `readColour` unless a caller passes another. */
 export type ColourReader = (hex: string) => [number, number, number, number];
 
+/**
+ * The five pose stages a step passes through when instrumented (`StageHooks`,
+ * issue #1589):
+ * - `timeline`: timeline evaluation, animated bone local copy, attachment/deform/sequence timeline states
+ * - `world`: bone hierarchy world-transform composition (`worldTransforms`)
+ * - `constraints`: constraint record posing, physics step, and constraint solver orchestration (`applyConstraints`)
+ * - `geometry`: region corners, mesh/deformed world vertices, and triangle clipping (`drawnGeometry`)
+ * - `readout`: slot rows, draw-order resolution/sorting, bone rows, drawn row packaging, and events
+ */
+export type CoreStage = 'timeline' | 'world' | 'constraints' | 'geometry' | 'readout';
+
+/** Zero-cost-when-absent per-stage instrumentation callbacks on `CorePlant` (issue #1589). */
+export interface StageHooks {
+  begin(stage: CoreStage): void;
+  end(stage: CoreStage): void;
+}
+
 /**
  * What the core poses with, each part replaceable. The core suite's plants
  * pass a copy of one of them — a mode's sign flipped, the wrong skin, a
@@ -1077,6 +1094,8 @@ export interface CorePlant {
   region?: RegionPoser;
   /** A vertex array's world positions (`worldVertices` in `./vertices.ts`). */
   vertices?: VertexPoser;
+  /** A deformed vertex array's world positions (`deformedWorldVertices` in `./vertices.ts`). */
+  deformedVertices?: DeformedVertexPoser;
   /** A drawn mesh's read-only UVs and triangles (`meshArraysOf` in `./vertices.ts`) — the raw entry's `drawn`; nothing but a control passes one. */
   meshArrays?: MeshArraysOf;
   /** The ik, transform and path constraints as posed, rewritten before they are applied (`./constraints.ts`). */
@@ -1107,6 +1126,8 @@ export interface CorePlant {
    * `rawNumber`, the unrounded double.
    */
   round?: (v: number) => number | null;
+  /** Per-stage instrumentation callbacks for `tools/pose_bench.ts` (issue #1589); absent on every uninstrumented walk. */
+  stage?: StageHooks;
 }
 
 /** The document's ik, transform and path constraint records, in its order — what `applyConstraints` runs. */
@@ -1166,6 +1187,46 @@ export function readColour(hex: string): [number, number, number, number] {
   return [channel(0), channel(1), channel(2), hex.length === 8 ? channel(3) : 1];
 }
 
+/** A stated colour's channels, read once and shared (`viewColours`): read, or copied before a write — never handed out. */
+export type StatedColour = Readonly<[number, number, number, number]>;
+
+/** Each view's stated colours, by spelling, read once (`viewColours`). */
+const coloursOfView = new WeakMap<CompiledDocument, Map<string, StatedColour>>();
+
+/**
+ * The view's reader of a stated colour: `readColour(hex)` read the first time
+ * the view meets that spelling and kept, frozen, for every pose after it. The
+ * slot rows read every slot's colours on every pose, and a drawn row its
+ * record's (the parse was a measured share of a step). The reading is the
+ * spelling's alone, so the cache is keyed on the spelling rather than on a
+ * slot or a record — a colour respelled in place reads its new spelling, and
+ * a view built anew starts its own. The tuple is shared by every pose, so no
+ * caller hands it out or writes it (`StatedColour` is read-only): a pose's
+ * channels are copied out of it. It is not frozen because a frozen array is
+ * read several times slower under JavaScriptCore, measured on Bun 1.4.4, and
+ * the read is the whole of what the cache is for. The core suite's `CO63`
+ * holds a pose's colours to their spelling and to the pose.
+ */
+export function viewColours(doc: CompiledDocument): (hex: string) => StatedColour {
+  let kept = coloursOfView.get(doc);
+  if (kept === undefined) {
+    kept = new Map();
+    coloursOfView.set(doc, kept);
+  }
+  const colours = kept;
+  return (hex) => {
+    let c = colours.get(hex);
+    if (c === undefined) {
+      c = readColour(hex);
+      colours.set(hex, c);
+    }
+    return c;
+  };
+}
+
+/** A slot or record that states no light colour: white, opaque. */
+export const WHITE: StatedColour = [1, 1, 1, 1];
+
 /**
  * A slot's blend mode: `Normal` when it states none, else the stated
  * spelling folded (the header's measurement). `readModel` has already refused

package/src/core/raw.ts

@@ -113,8 +113,8 @@
  * naming why (`CoreInputError`): a renderer handed a pose with a block
  * missing would draw a different picture in silence.
  */
-import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, readColour, shownAttachment, sourceOfDoc, underNoSkin, underSkin, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
-import { posedBoneWorld, posedBoneWorldAlone, posedSlots, type CoreAnimationTimelines, type LocalAdjust, type TimelinePlant } from './animation.ts';
+import { activeBones, CoreInputError, drawWalkOf, poseSetup, rawNumber, shownAttachment, sourceOfDoc, underNoSkin, underSkin, viewColours, WHITE, type CompiledDocument, type CorePlant, type CoreSlotRow } from './index.ts';
+import { posedBoneWorldAlone, posedSlots, type CoreAnimationTimelines, type LocalAdjust, type TimelinePlant } from './animation.ts';
 import { constraintsAbsentWhy, pathAnimationsWhy } from './constraints.ts';
 import { freshStepContext, rotatePhysics, steppedPreviousPassWhy, translatePhysics, DEFAULT_PHYSICS_ENVIRONMENT, type PhysicsEnvironment, type PhysicsStepContext } from './constraints_physics.ts';
 import { attachmentStates } from './deform.ts';
@@ -342,7 +342,7 @@ function scanBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>)
  */
 function drawnGeometry(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode): { rows: CoreAttachmentRow[]; clips: CoreClipRow[]; drawnClipped: CoreClippedRow[] } {
   const draw = drawWalkOf(doc, order, plant);
-  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, mode.loop && mode.live !== true && plant.through === undefined ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
+  const geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices, deformedVertices: plant.deformedVertices }, mode.loop && mode.live !== true && plant.through === undefined ? { ...draw, through: NO_CLIPPED_ROWS } : draw);
   if (geometry.attachments === null) throw new CoreInputError(`the raw pose leaves the attachments out: ${geometry.attachmentsWhy}`);
   // The drawn rows (issue #964): the oracle's `clipped` rows where it is posed, and a concave or inverse clip cut through the core's own decomposition.
   if (geometry.drawnClipped === null) throw new CoreInputError(`the raw pose leaves the clipped triangles out: ${geometry.drawnClippedWhy}`);
@@ -423,12 +423,20 @@ export interface ScanPlant {
 
 /** Every region and mesh the shown records draw, with what the renderer reads past the vertices (the header's `drawn`). */
 function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world: ReadonlyMap<string, CoreWorld>, order: readonly string[], plant: CorePlant, mode: WalkMode = RAW_MODE): { drawn: RawDrawn[]; clips: RawClip[]; clipped: RawClipped[] } {
+  const stage = plant.stage;
+  if (stage !== undefined) stage.begin('geometry');
   const geometry = drawnGeometry(doc, shown, world, order, plant, mode);
+  if (stage !== undefined) {
+    stage.end('geometry');
+    stage.begin('readout');
+  }
   // Under a concave or inverse clip the oracle's `clipped` block is absent (the runtime's own triangle list); what the core draws is `drawnClipped`,
   // its own decomposition, and the render samples each drawn triangle at its source triangle's affine UV, so the pixels are the decomposition's
   // coverage alone (issue #964, `Mesh.source` in src/render.ts).
   const rows = geometry.rows;
   const drawn: RawDrawn[] = [];
+  // Each record's stated colour, read once per view (`viewColours`) and copied into the pose's own tuple, as the pose's arrays are its own.
+  const stated = viewColours(doc);
   let k = 0;
   for (const s of shown) {
     const g = s.geometry;
@@ -436,7 +444,8 @@ function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world:
     const row = rows[k++];
     if (row === undefined || row[0] !== s.slot) throw new CoreInputError(`slot "${s.slot}": the attachment rows are not in the shown records' order`);
     const record = doc.skins.find((x) => x.name === s.skin)?.attachments[s.slot]?.[s.placeholder];
-    const colour = record?.color === undefined ? ([1, 1, 1, 1] as [number, number, number, number]) : readColour(record.color);
+    const read = record?.color === undefined ? WHITE : stated(record.color);
+    const colour: [number, number, number, number] = [read[0], read[1], read[2], read[3]];
     let uvs: readonly number[];
     let triangles: readonly number[];
     let hull: number | null = null;
@@ -454,6 +463,7 @@ function rawDrawn(doc: CompiledDocument, shown: readonly ShownGeometry[], world:
   }
   const clips = geometry.clips.map((c): RawClip => [c[0], c[1], c[2], numbersOf(c[3], `clip vertex of slot "${c[0]}"`, mode)]);
   const clipped = geometry.drawnClipped.map((c): RawClipped => [c[0], c[1], c[2], numbersOf(c[3], `clipped vertex of slot "${c[0]}"`, mode), numbersOf(c[4], `clipped uv of slot "${c[0]}"`, mode), c[5]]);
+  if (stage !== undefined) stage.end('readout');
   return { drawn, clips, clipped };
 }
 
@@ -785,12 +795,16 @@ interface WalkStep {
  * (`walkEach`) is one body: every number a pose carries is computed there and
  * in the two assemblers below, by the same calls, whatever the shape. A shape
  * chooses only what is assembled from what was posed — the scan drops the
- * readings, rows and copies nothing it reads is computed from — and keeps the
+ * readings and copies nothing it reads is computed from — and keeps the
  * order of every call that can refuse.
+ *
+ * No shape forms the oracle's bone rows: no walk pose carries them, and the
+ * rounding they are formed through refuses nothing, so every step poses the
+ * world alone (`posedBoneWorldAlone`). The rows are the sample's
+ * (`posedBoneRows`, `posedBoneWorld`), formed there as before. The core
+ * suite's `CO62` reads the walk's modules for a call that forms them.
  */
 interface PoseShape<P> {
-  /** Whether a step forms the oracle's bone rows beside its world (`posedBoneWorld`), which no walk pose carries; `false` poses the world alone (`posedBoneWorldAlone`). */
-  rows: boolean;
   /** The reset pose at the setup (`reset: 'setup'`). */
   setup: (doc: CompiledDocument, world: Map<string, CoreWorld>, slots: CoreSlotRow[], drawOrder: string[], shown: ShownGeometry[], plant: CorePlant, mode: WalkMode) => P;
   /** One step's pose. */
@@ -799,19 +813,21 @@ interface PoseShape<P> {
 
 /** The raw entry's pose, assembled as it always was: at the reset the bones, then the drawn rows; at a step the drawn rows, the events, then the bones. */
 const RAW_SHAPE: PoseShape<RawPose> = {
-  rows: true,
   setup: (doc, world, slots, drawOrder, shown, plant, mode) => ({ trackTime: 0, animationTime: 0, bones: rawBones(doc, world), slots, drawOrder, ...rawDrawn(doc, shown, world, drawOrder, plant, mode), events: [], shown: drawOrderOf(shown, drawOrder) }),
   step: (doc, p, plant, mode) => {
     const drawn = rawDrawn(doc, p.shown, p.world, p.drawOrder, plant, mode);
+    const stage = plant.stage;
+    if (stage !== undefined) stage.begin('readout');
     const events = p.events();
-    return { trackTime: p.trackTime, animationTime: p.animationTime, bones: rawBones(doc, p.world), slots: p.slots, drawOrder: p.drawOrder, ...drawn, events, shown: p.shown };
+    const pose: RawPose = { trackTime: p.trackTime, animationTime: p.animationTime, bones: rawBones(doc, p.world), slots: p.slots, drawOrder: p.drawOrder, ...drawn, events, shown: p.shown };
+    if (stage !== undefined) stage.end('readout');
+    return pose;
   },
 };
 
 /** The scan's pose (`ScanPose`), in the raw shape's order: the scan's walk is a looping one, which fires no event. */
 function scanShape(scanPlant: ScanPlant): PoseShape<ScanPose> {
   return {
-    rows: false,
     setup: (doc, world, slots, drawOrder, shown, plant, mode) => {
       const bones = scanBones(doc, world);
       return { animationTime: 0, bones, slots, drawn: scanDrawn(doc, shown, world, drawOrder, plant, mode, scanPlant) };
@@ -908,7 +924,7 @@ function stepWalk<P>(track: TrackState<P>, dt: number, first = false): P {
   const keys = anim.timelines.events;
   const adjustment = adjust === undefined ? undefined : { callback: adjust, context: { trackTime, animation: anim.name, globalTime: trackTime } };
   const pose = poseStepFrom(doc, plant, resolve, shape, mode, ctx, first, trackTime, t, {
-    world: (sliders) => (shape.rows ? posedBoneWorld(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }).world : posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment })),
+    world: (sliders) => posedBoneWorldAlone(doc, anim.timelines, t, raw, anim.constraints, sliders, { ctx, before, adjustment }),
     slots: (sliders, placeholders) => posedSlots(doc, anim.timelines, t, raw, sliders, placeholders),
     drawOrder: anim.timelines.drawOrder,
     at: t,
@@ -948,20 +964,30 @@ export interface StepPosers {
  * and a live tracks' step share.
  */
 function poseStepFrom<P>(doc: CompiledDocument, plant: TimelinePlant, resolve: NonNullable<TimelinePlant['shown']>, shape: PoseShape<P>, mode: WalkMode, ctx: ReturnType<typeof freshStepContext>, first: boolean, trackTime: number, animationTime: number, posers: StepPosers): P {
+  const stage = plant.stage;
   const sliders: SliderApplication[] = [];
   const world = posers.world(sliders);
   if (first) ctx.phase = 'update';
+  if (stage !== undefined) stage.begin('readout');
   const placeholders = new Map<string, string | null>();
   const slots = posers.slots(sliders, placeholders);
   if (slots.conflicts.length > 0) throw new CoreInputError(`the raw walk leaves the slots out: ${slots.conflicts.join('; ')}`);
   const evalOrder = plant.drawOrder ?? drawOrderAt;
-  let order = evalOrder(doc.slots.length, posers.drawOrder, posers.at) ?? doc.slots.map((_s, k) => k);
+  const baseOrder = evalOrder(doc.slots.length, posers.drawOrder, posers.at) ?? doc.slots.map((_s, k) => k);
+  let order = baseOrder;
   for (const app of sliders) order = evalOrder(doc.slots.length, app.timelines.drawOrder, app.at) ?? order;
   const drawOrder = order.map((k) => doc.slots[k].name);
+  if (stage !== undefined) {
+    stage.end('readout');
+    stage.begin('timeline');
+  }
   const states = attachmentStates(doc, resolve, placeholders, posers.sample, sliders, plant, posers.mixed);
+  if (stage !== undefined) stage.end('timeline');
   if (states.why.length > 0) throw new CoreInputError(`the raw walk leaves the attachments out: ${states.why.join('; ')}`);
+  if (stage !== undefined) stage.begin('readout');
   const rank = new Map(drawOrder.map((n, r) => [n, r]));
   const shown = [...states.shown].sort((a, b) => (rank.get(a.slot) ?? 0) - (rank.get(b.slot) ?? 0));
+  if (stage !== undefined) stage.end('readout');
   const events = (): RawEvent[] => posers.events().map((e): RawEvent => [e[0], finite(e[1], 'event time'), e[2], finite(e[3], 'event float'), e[4]]);
   return shape.step(doc, { trackTime, animationTime, world, slots: slots.rows, drawOrder, shown, events }, plant, mode);
 }

package/src/core/tracks.ts

@@ -160,7 +160,7 @@
  * every later call refuses naming the call it was refused at.
  */
 import type { ModelBone, ModelSlot, ModelVertices } from '../model.ts';
-import { activeBones, CoreInputError, rawNumber, readColour, shownAttachment, type CompiledDocument, type CoreShown } from './index.ts';
+import { activeBones, CoreInputError, rawNumber, shownAttachment, viewColours, WHITE, type CompiledDocument, type CoreShown, type StatedColour } from './index.ts';
 import { channelAt, keyIndexAt, SLOT_COLOUR_TIMELINES, slotRowsFrom, steppedLocalsWorld, type BoneTimelineKind, type CoreKey, type LocalAdjust, type SlotBase, type SlotColourKind, type TimelinePlant } from './animation.ts';
 import { deformAt, setupArray, type CoreAttachmentTimeline } from './deform.ts';
 import { eventsFired, type CoreEventKey, type CoreEventRow } from './events.ts';
@@ -440,6 +440,9 @@ function trackComplete(e: Entry): number {
 const signum = (v: number): number => (v > 0 ? 1 : v < 0 ? -1 : 0);
 const clamp01 = (v: number): number => (v < 0 ? 0 : v > 1 ? 1 : v);
 
+/** A slot's setup dark colour where it states none: never read, since such a slot carries no dark channel and a two-colour timeline returns before it (`applyColour`). */
+const NO_DARK: readonly number[] = [0, 0, 0];
+
 // ---------------------------------------------------------------------------
 // one step's skeleton — the pose the entries are applied to
 // ---------------------------------------------------------------------------
@@ -473,6 +476,8 @@ class Pose {
   private readonly active: ReadonlySet<string>;
   private readonly live: boolean[];
   private readonly resolved = new Map<string, Resolved>();
+  /** The view's stated colours (`viewColours`). */
+  readonly stated: (hex: string) => StatedColour;
 
   constructor(
     private readonly doc: CompiledDocument,
@@ -480,12 +485,16 @@ class Pose {
   ) {
     this.bones = [...doc.bones];
     this.active = activeBones(doc);
-    const colour = plant.colour ?? readColour;
+    // The view's stated colours, read once (`viewColours`) and copied into the step's own channels; a planted reader of the light colour is called as it always was.
+    const stated = viewColours(doc);
+    this.stated = stated;
+    const colour = plant.colour ?? stated;
     const gate = plant.slotTimelines ?? slotTimelinesApply;
     this.live = doc.slots.map((s) => gate(doc, s, this.active));
     this.slots = doc.slots.map((slot): SlotState => {
-      const setupDark = slot.dark === undefined ? null : readColour(slot.dark);
-      return { placeholder: slot.setup, light: slot.color === undefined ? [1, 1, 1, 1] : colour(slot.color), dark: setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]], deform: null, seen: [], attachmentState: ATTACH_NONE };
+      const setupDark = slot.dark === undefined ? null : stated(slot.dark);
+      const setupLight = slot.color === undefined ? WHITE : colour(slot.color);
+      return { placeholder: slot.setup, light: [setupLight[0], setupLight[1], setupLight[2], setupLight[3]], dark: setupDark === null ? null : [setupDark[0], setupDark[1], setupDark[2]], deform: null, seen: [], attachmentState: ATTACH_NONE };
     });
   }
 
@@ -1103,9 +1112,9 @@ class Mixer {
     const s = pose.slots[tl.slot];
     const l = s.light;
     const d = s.dark;
-    const sl = slot.color === undefined ? [1, 1, 1, 1] : (this.plant.colour ?? readColour)(slot.color);
-    const sdFull = slot.dark === undefined ? null : readColour(slot.dark);
-    const sd = sdFull === null ? [0, 0, 0] : [sdFull[0], sdFull[1], sdFull[2]];
+    // The setup colours, read only: the view's (`viewColours`), or a planted reader's light colour.
+    const sl = slot.color === undefined ? WHITE : (this.plant.colour ?? pose.stated)(slot.color);
+    const sd = slot.dark === undefined ? NO_DARK : pose.stated(slot.dark);
     const clampLight = (): void => {
       for (let k = 0; k < 4; k++) l[k] = clamp01(l[k]);
     };
@@ -1466,7 +1475,10 @@ class Tracks implements LiveTracks {
     if (typeof dt !== 'number' || !Number.isFinite(dt) || dt < 0) throw new CoreInputError(`the live tracks' step ${n} is ${String(dt)}, not a finite time at or above 0`);
     return this.guard(`step ${n}`, () => {
       this.time += dt;
+      const stage = this.plant.stage;
+      if (stage !== undefined) stage.begin('timeline');
       this.mixer.update(dt);
+      if (stage !== undefined) stage.end('timeline');
       const pose = this.pose(dt, false);
       this.steps = n;
       return pose;
@@ -1489,6 +1501,8 @@ class Tracks implements LiveTracks {
     const ctx = path.ctx;
     const before = ctx.time;
     ctx.time += this.clock === undefined ? dt : this.clock(dt);
+    const stage = this.plant.stage;
+    if (stage !== undefined) stage.begin('timeline');
     const pose = new Pose(doc, this.plant);
     const animationTime = this.mixer.apply(pose);
     const entry = this.mixer.tracks[0] ?? null;
@@ -1497,8 +1511,9 @@ class Tracks implements LiveTracks {
       context: { trackTime: entry?.trackTime ?? null, animation: entry?.anim.name ?? null, globalTime: this.time },
     };
     const mixed = new Map(doc.slots.map((s, k) => [s.name, { deform: pose.slots[k].deform, seen: pose.slots[k].seen }]));
+    if (stage !== undefined) stage.end('timeline');
     return path.step(first, this.time, animationTime, {
-      world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjustment }, true),
+      world: (sliders) => steppedLocalsWorld(doc, pose.bones, path.raw, sliders, { ctx, before, adjustment }),
       slots: (sliders, placeholders) => slotRowsFrom(doc, path.raw, sliders, placeholders, (_slot, _live): SlotBase => {
         const s = pose.slots[doc.slots.indexOf(_slot)];
         return { placeholder: s.placeholder, light: s.light, dark: s.dark };

package/src/core/vertices.ts

@@ -191,6 +191,8 @@ export type CoreClipRow = [string, string, string | null, Array<number | null>];
 export type RegionPoser = (region: CoreRegionGeometry & { atlas: ModelAtlasRect }, bone: CoreWorld) => number[];
 /** What computes a vertex array's world positions: `worldVertices` unless a caller passes another. */
 export type VertexPoser = (vertices: ModelVertices, bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>, coords?: (v: number) => number) => number[];
+/** What computes a deformed vertex array's world positions in one pass: `deformedWorldVertices` unless a caller passes another. */
+export type DeformedVertexPoser = (vertices: ModelVertices, deform: readonly number[], bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>) => number[];
 
 /** A deformed array's coordinates are read as they are (`./deform.ts`, `deformedVertices`): they are not the stored float32s. */
 export const EXACT_COORDS = (v: number): number => v;
@@ -222,31 +224,157 @@ export function regionCorners(region: CoreRegionGeometry & { atlas: ModelAtlasRe
   return out;
 }
 
+/** A weighted vertex array as the model states it. */
+export type WeightedVertices = Extract<ModelVertices, { weighted: true }>;
+
 /**
- * A vertex array's world positions — the header's mesh rule, every stored
- * number through `Math.fround`; with `coords`, the coordinates through it
- * instead (a deformed array's are read as they are, `EXACT_COORDS`), the
- * weights through `Math.fround` still.
+ * One influence of a compiled weighted vertex (issue #1580): its bone as an
+ * index into `CompiledWeightedVertices.bones`, its raw coordinates (`x`, `y`)
+ * for a caller passing a custom `coords`, and its `Math.fround`-rounded
+ * coordinates (`fx`, `fy`) and `weight` for the default posing path.
  */
-export function worldVertices(vertices: ModelVertices, bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>, coords: (v: number) => number = Math.fround): number[] {
+export interface CompiledBinding {
+  readonly bone: number;
+  readonly x: number;
+  readonly y: number;
+  readonly fx: number;
+  readonly fy: number;
+  readonly weight: number;
+}
+
+/**
+ * A weighted vertex array's bone bindings compiled to integer indices into
+ * `bones` (issue #1580): `bones` lists the distinct bone names in exact
+ * first-occurrence order across `vertices.bindings`, and `bindings` keeps the
+ * outer vertex order and inner influence order untouched so the summation
+ * order and every posed coordinate stay bit-for-bit (`Object.is`) identical.
+ */
+export interface CompiledWeightedVertices {
+  readonly bones: readonly string[];
+  readonly bindings: ReadonlyArray<readonly CompiledBinding[]>;
+}
+
+/** Each weighted vertex array's compiled index table, keyed on the `WeightedVertices` object itself. */
+const compiledWeightedByVertices = new WeakMap<WeightedVertices, CompiledWeightedVertices>();
+
+/**
+ * Compile `vertices`'s bone names to integer indices in first-occurrence order
+ * (issue #1580). With `mapIndex`, each binding's index is passed through it
+ * instead (the core suite's wrong-index plant).
+ */
+export function compileWeightedVertices(
+  vertices: WeightedVertices,
+  mapIndex?: (boneIndex: number, boneCount: number) => number,
+): CompiledWeightedVertices {
+  const bones: string[] = [];
+  const indexByName = new Map<string, number>();
+  for (const influences of vertices.bindings) {
+    for (const binding of influences) {
+      if (!indexByName.has(binding.bone)) {
+        indexByName.set(binding.bone, bones.length);
+        bones.push(binding.bone);
+      }
+    }
+  }
+  const count = bones.length;
+  const bindings: CompiledBinding[][] = vertices.bindings.map((influences) =>
+    influences.map((binding) => {
+      const idx = indexByName.get(binding.bone) as number;
+      return {
+        bone: mapIndex === undefined ? idx : mapIndex(idx, count),
+        x: binding.x,
+        y: binding.y,
+        fx: Math.fround(binding.x),
+        fy: Math.fround(binding.y),
+        weight: Math.fround(binding.weight),
+      };
+    }),
+  );
+  return { bones, bindings };
+}
+
+/**
+ * The cached `CompiledWeightedVertices` for `vertices`, compiled once per
+ * `WeightedVertices` object and never shared across two different vertex
+ * objects.
+ */
+export function compiledWeightedOf(vertices: WeightedVertices): CompiledWeightedVertices {
+  let kept = compiledWeightedByVertices.get(vertices);
+  if (kept === undefined) {
+    kept = compileWeightedVertices(vertices);
+    compiledWeightedByVertices.set(vertices, kept);
+  }
+  return kept;
+}
+
+/**
+ * Resolve each distinct bone of `bones` once per pose call into a dense array
+ * indexed by `CompiledBinding.bone`. Because `bones` is in first-occurrence
+ * order across `vertices.bindings`, a missing bone throws the same error on
+ * the same bone name as a per-influence lookup.
+ */
+function resolveBindingBones(bones: readonly string[], world: ReadonlyMap<string, CoreWorld>): CoreWorld[] {
+  const transforms = new Array<CoreWorld>(bones.length);
+  for (let i = 0; i < bones.length; i++) {
+    const name = bones[i];
+    const t = world.get(name);
+    if (t === undefined) throw new Error(`a binding names bone "${name}", which has no world transform (readModel refuses it first)`);
+    transforms[i] = t;
+  }
+  return transforms;
+}
+
+/**
+ * Evaluate a compiled weighted vertex table against `world` (issue #1580),
+ * looking up each distinct bone once per call and summing influences in their
+ * original order.
+ */
+export function compiledWorldVertices(
+  compiled: CompiledWeightedVertices,
+  world: ReadonlyMap<string, CoreWorld>,
+  coords: (v: number) => number = Math.fround,
+): number[] {
+  const transforms = resolveBindingBones(compiled.bones, world);
   const out: number[] = [];
-  if (!vertices.weighted) {
-    for (let i = 0; i + 1 < vertices.xy.length; i += 2) {
-      const x = coords(vertices.xy[i]);
-      const y = coords(vertices.xy[i + 1]);
-      out.push(x * bone.a + y * bone.b + bone.worldX, x * bone.c + y * bone.d + bone.worldY);
+  const fround = coords === Math.fround;
+  for (const influences of compiled.bindings) {
+    let wx = 0;
+    let wy = 0;
+    for (const binding of influences) {
+      const t = transforms[binding.bone];
+      const x = fround ? binding.fx : coords(binding.x);
+      const y = fround ? binding.fy : coords(binding.y);
+      const weight = binding.weight;
+      wx += (x * t.a + y * t.b + t.worldX) * weight;
+      wy += (x * t.c + y * t.d + t.worldY) * weight;
     }
-    return out;
+    out.push(wx, wy);
   }
-  for (const influences of vertices.bindings) {
+  return out;
+}
+
+/**
+ * Evaluate a compiled weighted vertex table with `deform` in one pass
+ * (issues #1530, #1580), looking up each distinct bone once per call and
+ * summing influences in their original order.
+ */
+export function compiledDeformedWorldVertices(
+  compiled: CompiledWeightedVertices,
+  deform: readonly number[],
+  world: ReadonlyMap<string, CoreWorld>,
+): number[] {
+  const transforms = resolveBindingBones(compiled.bones, world);
+  const out: number[] = [];
+  let k = 0;
+  for (const influences of compiled.bindings) {
     let wx = 0;
     let wy = 0;
     for (const binding of influences) {
-      const t = world.get(binding.bone);
-      if (t === undefined) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
-      const x = coords(binding.x);
-      const y = coords(binding.y);
-      const weight = Math.fround(binding.weight);
+      const t = transforms[binding.bone];
+      const x = binding.fx + deform[k];
+      const y = binding.fy + deform[k + 1];
+      k += 2;
+      const weight = binding.weight;
       wx += (x * t.a + y * t.b + t.worldX) * weight;
       wy += (x * t.c + y * t.d + t.worldY) * weight;
     }
@@ -255,20 +383,42 @@ export function worldVertices(vertices: ModelVertices, bone: CoreWorld, world: R
   return out;
 }
 
+/**
+ * A vertex array's world positions — the header's mesh rule, every stored
+ * number through `Math.fround`; with `coords`, the coordinates through it
+ * instead (a deformed array's are read as they are, `EXACT_COORDS`), the
+ * weights through `Math.fround` still. Weighted bone bindings are compiled once
+ * per vertex object to integer indices (`compiledWeightedOf`, issue #1580) so
+ * each pose looks up each distinct bone once rather than per influence.
+ */
+export function worldVertices(vertices: ModelVertices, bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>, coords: (v: number) => number = Math.fround): number[] {
+  if (!vertices.weighted) {
+    const out: number[] = [];
+    for (let i = 0; i + 1 < vertices.xy.length; i += 2) {
+      const x = coords(vertices.xy[i]);
+      const y = coords(vertices.xy[i + 1]);
+      out.push(x * bone.a + y * bone.b + bone.worldX, x * bone.c + y * bone.d + bone.worldY);
+    }
+    return out;
+  }
+  return compiledWorldVertices(compiledWeightedOf(vertices), world, coords);
+}
+
 /**
  * `worldVertices(deformedVertices(vertices, deform), bone, world, EXACT_COORDS)`
- * in one pass (issue #1530): the same operations on the same numbers in the
+ * in one pass (issues #1530, #1580): the same operations on the same numbers in the
  * same order — an unweighted vertex's coordinates are the deform array's,
  * read as they are; a weighted binding's are its float32 coordinate plus the
- * deform's pair, its weight through `Math.fround` — without building the
- * deformed array (and, weighted, one binding record per influence) on every
- * pose only to map it again. A planted vertex poser still reads the deformed
- * array (`poseGeometry`). Posed output is held equal by the core gate's
- * sample attachments and by `tools/posed_frames.ts` across the change.
+ * deform's pair, its weight through `Math.fround`, its bone transform indexed
+ * through `compiledWeightedOf` — without building the deformed array (and,
+ * weighted, one binding record per influence) on every pose only to map it
+ * again. A planted vertex poser still reads the deformed array (`poseGeometry`).
+ * Posed output is held equal by the core gate's sample attachments and by
+ * `tools/posed_frames.ts` across the change.
  */
 export function deformedWorldVertices(vertices: ModelVertices, deform: readonly number[], bone: CoreWorld, world: ReadonlyMap<string, CoreWorld>): number[] {
-  const out: number[] = [];
   if (!vertices.weighted) {
+    const out: number[] = [];
     for (let i = 0; i + 1 < deform.length; i += 2) {
       const x = deform[i];
       const y = deform[i + 1];
@@ -276,23 +426,7 @@ export function deformedWorldVertices(vertices: ModelVertices, deform: readonly
     }
     return out;
   }
-  let k = 0;
-  for (const influences of vertices.bindings) {
-    let wx = 0;
-    let wy = 0;
-    for (const binding of influences) {
-      const t = world.get(binding.bone);
-      if (t === undefined) throw new Error(`a binding names bone "${binding.bone}", which has no world transform (readModel refuses it first)`);
-      const x = Math.fround(binding.x) + deform[k];
-      const y = Math.fround(binding.y) + deform[k + 1];
-      k += 2;
-      const weight = Math.fround(binding.weight);
-      wx += (x * t.a + y * t.b + t.worldX) * weight;
-      wy += (x * t.c + y * t.d + t.worldY) * weight;
-    }
-    out.push(wx, wy);
-  }
-  return out;
+  return compiledDeformedWorldVertices(compiledWeightedOf(vertices), deform, world);
 }
 
 const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -342,7 +476,10 @@ function readVertices(value: unknown, where: string, bones: ReadonlySet<string>,
       for (const key of ['x', 'y', 'weight'] as const) if (!finite(b[key])) problems.push(`${at}: ${key} is ${JSON.stringify(b[key]) ?? 'absent'}, not a finite number`);
     });
   });
-  return problems.length === before ? { weighted: true, bindings: bindings as ModelBinding[][] } : undefined;
+  if (problems.length !== before) return undefined;
+  const weighted: WeightedVertices = { weighted: true, bindings: bindings as ModelBinding[][] };
+  compiledWeightedByVertices.set(weighted, compileWeightedVertices(weighted));
+  return weighted;
 }
 
 /**
@@ -529,11 +666,12 @@ export function poseGeometry(
   world: ReadonlyMap<string, CoreWorld>,
   sourceOf: SourceOf,
   round: (v: number) => number | null,
-  plant: { region?: RegionPoser; vertices?: VertexPoser } = {},
+  plant: { region?: RegionPoser; vertices?: VertexPoser; deformedVertices?: DeformedVertexPoser } = {},
   draw?: DrawWalk,
 ): { attachments: CoreAttachmentRow[] | null; attachmentsWhy: string | null; clips: CoreClipRow[]; clipped: CoreClippedRow[] | null; clippedWhy: string | null; drawnClipped: CoreClippedRow[] | null; drawnClippedWhy: string | null } {
   const region = plant.region ?? regionCorners;
   const vertices = plant.vertices ?? worldVertices;
+  const deformPoser = plant.deformedVertices ?? deformedWorldVertices;
   const attachments: CoreAttachmentRow[] = [];
   const clips: CoreClipRow[] = [];
   const nulls: string[] = [];
@@ -548,7 +686,7 @@ export function poseGeometry(
     // A deform array replaces the stored vertices, its coordinates read as they are (`./deform.ts`).
     // Unplanted, the deformed positions are read in one pass (`deformedWorldVertices`, issue #1530) rather than through a deformed copy of the array.
     const deform = s.deform;
-    const drawn = (v: ModelVertices): number[] => (deform === undefined ? vertices(v, bone, world) : plant.vertices === undefined ? deformedWorldVertices(v, deform, bone, world) : vertices(deformedVertices(v, deform), bone, world, EXACT_COORDS));
+    const drawn = (v: ModelVertices): number[] => (deform === undefined ? vertices(v, bone, world) : plant.vertices === undefined || plant.deformedVertices !== undefined ? deformPoser(v, deform, bone, world) : vertices(deformedVertices(v, deform), bone, world, EXACT_COORDS));
     if (g.kind === 'region') {
       const rect = s.frame === undefined ? g.region.atlas : (g.region.frames?.[s.frame] ?? g.region.atlas);
       if (rect === null) {