spine-rigc 2.9.0 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/core/animation.ts

@@ -600,15 +600,33 @@ export function keyIndexAt(keys: ReadonlyArray<{ time: number }>, t: number): nu
   return found;
 }
 
+/**
+ * Each Bézier segment's polylines, one per channel, kept with the key that
+ * starts the segment and the key that ends it (issue #1134): a polyline is a
+ * function of those two keys' stated numbers and handles only, and a walk
+ * evaluated the same segment's on every step. A key read is never written; a
+ * plant that changes a key passes a copy, which keeps polylines of its own.
+ */
+const segmentPolylines = new WeakMap<CoreKey, { end: CoreKey; channels: Array<number[] | undefined> }>();
+
 /** Channel `channel` of the segment starting at key `index` (not the last), at `t` — the header's three curves. */
 export function channelAt(keys: readonly CoreKey[], index: number, channel: number, t: number): number {
   const a = keys[index];
   const b = keys[index + 1];
   if (b === undefined || a.curve === 'stepped') return a.values[channel];
   if (a.curve === 'linear') return a.values[channel] + ((t - a.time) / (b.time - a.time)) * (b.values[channel] - a.values[channel]);
-  const c = a.curve.slice(channel * 4, channel * 4 + 4);
-  const inner = bezierPolyline(a.stated.time, a.stated.values[channel], c[0], c[1], c[2], c[3], b.stated.time, b.stated.values[channel]);
-  const points = [a.time, a.values[channel], ...inner, b.time, b.values[channel]];
+  let kept = segmentPolylines.get(a);
+  if (kept === undefined || kept.end !== b) {
+    kept = { end: b, channels: [] };
+    segmentPolylines.set(a, kept);
+  }
+  let points = kept.channels[channel];
+  if (points === undefined) {
+    const c = a.curve.slice(channel * 4, channel * 4 + 4);
+    const inner = bezierPolyline(a.stated.time, a.stated.values[channel], c[0], c[1], c[2], c[3], b.stated.time, b.stated.values[channel]);
+    points = [a.time, a.values[channel], ...inner, b.time, b.values[channel]];
+    kept.channels[channel] = points;
+  }
   let i = 2;
   while (i < points.length - 2 && points[i] < t) i += 2;
   const [x0, y0, x1, y1] = [points[i - 2], points[i - 1], points[i], points[i + 1]];
@@ -635,9 +653,22 @@ function keyAt(keys: readonly CoreKey[], t: number, plant: TimelinePlant): CoreK
   return index < 0 ? null : keys[index];
 }
 
+/** Each animation's bone timelines by bone name, kept with the timelines they index (`posedBones`). */
+const boneTimelinesByName = new WeakMap<CoreAnimationTimelines, ReadonlyMap<string, CoreTarget<BoneTimelineKind>>>();
+
+/** The animation's bone timelines by bone name, built once per timelines object (issue #1134: a walk built it again on every step); timelines read are never written. */
+function boneTimelinesOf(timelines: CoreAnimationTimelines): ReadonlyMap<string, CoreTarget<BoneTimelineKind>> {
+  let byName = boneTimelinesByName.get(timelines);
+  if (byName === undefined) {
+    byName = new Map(timelines.bones.map((b) => [b.name, b]));
+    boneTimelinesByName.set(timelines, byName);
+  }
+  return byName;
+}
+
 /** The bones posed by the animation's bone timelines at `t`: copies of the setup bones with the posed fields — the header's rules. */
 export function posedBones(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant = {}): ModelBone[] {
-  const byName = new Map(timelines.bones.map((b) => [b.name, b]));
+  const byName = boneTimelinesOf(timelines);
   return doc.bones.map((setup) => {
     const target = byName.get(setup.name);
     if (target === undefined) return setup;
@@ -762,6 +793,38 @@ export function posedBoneRows(doc: CompiledDocument, timelines: CoreAnimationTim
 
 /** `posedBoneRows`, with the world transforms the rows were read off — what the sample's attachments are posed through. */
 export function posedBoneWorld(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant = {}, constraints?: CoreConstraintTimelines, sliders?: SliderApplication[], step?: { ctx: PhysicsStepContext; before: number }): { rows: CoreBoneRow[]; world: Map<string, CoreWorld> } {
+  const posed = posedBoneStep(doc, timelines, t, plant, constraints, sliders, step);
+  return { rows: stepRows(posed), world: posed.world };
+}
+
+/**
+ * One pose of the bones before its rows are read: the world transforms, and
+ * what the rows are rounded from. A stepped walk reads rows only off the step
+ * that lands on a sample (issue #1134: of the stepped run's poses, nine in ten
+ * are steps between samples), so `stepRows` rounds them when they are read,
+ * once; every bone's transform is required here, at every step.
+ */
+interface PosedStep {
+  bones: ModelBone[];
+  world: Map<string, CoreWorld>;
+  active: ReadonlySet<string>;
+  round: (v: number) => number | null;
+  rows?: CoreBoneRow[];
+}
+
+/** A step's bone rows, in the oracle's shape and rounding, rounded the first time they are read. */
+function stepRows(posed: PosedStep): CoreBoneRow[] {
+  if (posed.rows !== undefined) return posed.rows;
+  const { world, active, round } = posed;
+  posed.rows = posed.bones.map((b): CoreBoneRow => {
+    const w = world.get(b.name) as CoreWorld;
+    return [b.name, round(w.worldX), round(w.worldY), round(w.a), round(w.b), round(w.c), round(w.d), active.has(b.name) ? 1 : 0, b.parent ?? null];
+  });
+  return posed.rows;
+}
+
+/** `posedBoneWorld` up to its rows, refusing a bone the evaluator gave no transform (`PosedStep`). */
+function posedBoneStep(doc: CompiledDocument, timelines: CoreAnimationTimelines, t: number, plant: TimelinePlant, constraints: CoreConstraintTimelines | undefined, sliders: SliderApplication[] | undefined, step: { ctx: PhysicsStepContext; before: number } | undefined): PosedStep {
   const active = activeBones(doc);
   const bones = posedBones(doc, timelines, t, plant);
   let world = (plant.evaluate ?? worldTransforms)(bones, active);
@@ -777,14 +840,8 @@ export function posedBoneWorld(doc: CompiledDocument, timelines: CoreAnimationTi
     const previous = setupRecords.some((r) => r.kind === 'path') ? applyConstraints(doc.bones, (plant.evaluate ?? worldTransforms)(doc.bones, active), active, plant.constraints ? plant.constraints(setupRecords) : setupRecords, null, undefined, undefined, undefined, solverRules(plant.solver)) : null;
     world = applyConstraints(bones, world, active, plant.constraints ? plant.constraints(records) : records, previous, sliders, undefined, undefined, solverRules(plant.solver));
   }
-  const posed = world;
-  const round = plant.round ?? gridRound;
-  const rows = bones.map((b): CoreBoneRow => {
-    const w = posed.get(b.name);
-    if (w === undefined) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
-    return [b.name, round(w.worldX), round(w.worldY), round(w.a), round(w.b), round(w.c), round(w.d), active.has(b.name) ? 1 : 0, b.parent ?? null];
-  });
-  return { rows, world: posed };
+  for (const b of bones) if (world.get(b.name) === undefined) throw new CoreInputError(`the evaluator returned no transform for bone "${b.name}"`);
+  return { bones, world, active, round: plant.round ?? gridRound };
 }
 
 /** Each path record with the curve its slot shows deformed by the sample's own deform timelines at `t` (`./deform.ts`), or as it was. */
@@ -904,9 +961,9 @@ export function poseAnimations(doc: CompiledDocument, phase: SamplePhase, n: num
     const samples: CoreSample[] = [];
     let last = -1;
     // Under `--physics step` (issue #956): one walk per animation — reset at 0, then the oracle's schedule, each sample posed off its last step (`./constraints_physics.ts`).
-    const walk = dt === undefined || bonesReason !== null ? null : { ctx: freshStepContext(plant.physicsStep), now: 0, schedule: stepSchedule(phase, d, n, dt), sliders: [] as SliderApplication[], posed: null as { rows: CoreBoneRow[]; world: Map<string, CoreWorld> } | null };
+    const walk = dt === undefined || bonesReason !== null ? null : { ctx: freshStepContext(plant.physicsStep), now: 0, schedule: stepSchedule(phase, d, n, dt), sliders: [] as SliderApplication[], posed: null as PosedStep | null };
     if (walk !== null) {
-      walk.posed = posedBoneWorld(doc, anim.timelines, 0, plant, anim.constraints, walk.sliders, { ctx: walk.ctx, before: 0 });
+      walk.posed = posedBoneStep(doc, anim.timelines, 0, plant, anim.constraints, walk.sliders, { ctx: walk.ctx, before: 0 });
       walk.ctx.phase = 'update';
     }
     for (let i = 0; i < n; i++) {
@@ -918,11 +975,11 @@ export function poseAnimations(doc: CompiledDocument, phase: SamplePhase, n: num
           const before = walk.ctx.time;
           walk.ctx.time += s - walk.now;
           walk.sliders = [];
-          walk.posed = posedBoneWorld(doc, anim.timelines, s, plant, anim.constraints, walk.sliders, { ctx: walk.ctx, before });
+          walk.posed = posedBoneStep(doc, anim.timelines, s, plant, anim.constraints, walk.sliders, { ctx: walk.ctx, before });
           walk.now = s;
         }
         sliders = walk.sliders;
-        posed = walk.posed;
+        posed = walk.posed === null ? null : { rows: stepRows(walk.posed), world: walk.posed.world };
       } else posed = bonesReason === null ? posedBoneWorld(doc, anim.timelines, t, plant, anim.constraints, sliders) : null;
       const placeholders = new Map<string, string | null>();
       const slots = posedSlots(doc, anim.timelines, t, plant, sliders, placeholders);

package/src/core/constraints.ts

@@ -1518,7 +1518,12 @@ export type ConstraintPlant = (records: CoreConstraintRecord[]) => CoreConstrain
  * `./constraints_physics.ts`); without it, it applies nothing.
  */
 export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap<string, CoreWorld>, active: ReadonlySet<string>, records: readonly CoreConstraintRecord[], previous: ReadonlyMap<string, CoreWorld> | null = null, applied?: SliderApplication[], physics?: PhysicsStepContext, settled?: (state: SolverState) => void, rules: Readonly<SolverRules> = RUNTIME_SOLVER_RULES): Map<string, CoreWorld> {
-  const state: SolverState = { bones: bones.map((b) => ({ ...b })), index: new Map(bones.map((b, i) => [b.name, i])), world: new Map(world), active, rules };
+  // No record: nothing to solve, so the world as given, copied (issue #1134) — and what `sliderPhysicsTarget` leaves on the step's context with no record, an empty carry, under the plant that carries one.
+  if (records.length === 0 && settled === undefined) {
+    if (physics !== undefined && !rules.sliderPhysicsLastsOnePass) physics.carried = new Map();
+    return new Map(world);
+  }
+  const state: SolverState = { bones: bones.map((b) => ({ ...b })), index: boneIndex(bones, active), world: new Map(world), active, rules };
   const skipped = new Set<number>();
   records.forEach((c, i) => {
     if (inactiveWhy(state, c) !== null) skipped.add(i);
@@ -1573,19 +1578,45 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
   return state.world;
 }
 
+/** The last bone index each view's active set was asked for, with the names it was built over (`boneIndex`). */
+const indexOfView = new WeakMap<ReadonlySet<string>, { names: string[]; index: Map<string, number> }>();
+
+/**
+ * Each bone's position in `bones`, by name — the solver's index. Every pose of
+ * a view lists the same bones in the same order (issue #1134: a walk built it
+ * anew on each of its passes), so the index last built under the view's
+ * active set (`activeBones`, one object per view) is reused when the names
+ * agree position by position, and built again otherwise. Read, never written.
+ */
+function boneIndex(bones: readonly ModelBone[], active: ReadonlySet<string>): Map<string, number> {
+  const kept = indexOfView.get(active);
+  if (kept !== undefined && kept.names.length === bones.length && bones.every((b, i) => b.name === kept.names[i])) return kept.index;
+  const index = new Map(bones.map((b, i) => [b.name, i]));
+  indexOfView.set(active, { names: bones.map((b) => b.name), index });
+  return index;
+}
+
 /** After a constraint: the bones it moved in world space read back into local values, and every bone below one it moved posed again (the header's update order). */
 function repose(state: SolverState, changed: readonly string[], inWorld: readonly string[]): void {
   for (const name of inWorld) {
     const b = bone(state, name);
     localFromWorld(b, parentWorld(state, b), state.world.get(name) as CoreWorld, state.rules);
   }
-  const moved = new Set(changed);
+  // `changed` and `inWorld` are a constraint's few bones: read as they are rather than copied into sets on each of a walk's passes (issue #1134).
+  const moved = changed;
   const below = new Set(changed);
-  const keep = new Set(inWorld);
-  for (const b of state.bones) {
+  const keep = inWorld;
+  // Bones are parents first (`readModel` refuses any other order) and a bone joins `below` only through its parent, so none before the first bone moved can: the walk starts there (issue #1134).
+  let from = state.bones.length;
+  for (const name of changed) {
+    const at = state.index.get(name);
+    if (at !== undefined && at < from) from = at;
+  }
+  for (let k = from; k < state.bones.length; k++) {
+    const b = state.bones[k];
     // Not through an inactive bone the constraint did not move itself (issue #979): the bones below it keep what the constraints wrote into them.
-    if (b.parent !== undefined && below.has(b.parent) && (!state.rules.inactiveHoldsItsWorld || state.active.has(b.parent) || moved.has(b.parent))) below.add(b.name);
-    if (below.has(b.name) && !keep.has(b.name)) poseBone(state, b);
+    if (b.parent !== undefined && below.has(b.parent) && (!state.rules.inactiveHoldsItsWorld || state.active.has(b.parent) || moved.includes(b.parent))) below.add(b.name);
+    if (below.has(b.name) && !keep.includes(b.name)) poseBone(state, b);
   }
 }
 

package/src/core/index.ts

@@ -1111,8 +1111,26 @@ export const NOT_ADMITTED: ReadonlyArray<readonly [string, string]> = [];
 /** The setup blocks the core poses, in the document's order. */
 const POSED_BLOCKS = ['setup.bones', 'setup.slots', 'setup.drawOrder', 'setup.attachments', 'setup.clips', 'setup.clipped'] as const;
 
-/** Bones active under the skin view posed — the rule measured in the header (`all`) and in `./skins.ts` (a named skin). */
-export function activeBones(doc: CompiledDocument): Set<string> {
+/** Each view's active bones, kept for the view (`activeBones`). */
+const activeOfView = new WeakMap<CompiledDocument, ReadonlySet<string>>();
+
+/**
+ * Bones active under the skin view posed — the rule measured in the header
+ * (`all`) and in `./skins.ts` (a named skin). Derived once per view object and
+ * kept with it (issue #1134): the answer reads the view's bones and skins
+ * only, a view is never written once it is posed, and every pose of a walk
+ * asked again. Read-only to every caller; a view built anew (`underSkin`,
+ * `underNoSkin`, a plant's) derives its own.
+ */
+export function activeBones(doc: CompiledDocument): ReadonlySet<string> {
+  const kept = activeOfView.get(doc);
+  if (kept !== undefined) return kept;
+  const made = deriveActiveBones(doc);
+  activeOfView.set(doc, made);
+  return made;
+}
+
+function deriveActiveBones(doc: CompiledDocument): ReadonlySet<string> {
   const named = new Set(appliedSkins(doc).flatMap((s) => s.bones));
   const parentOf = new Map(doc.bones.map((b) => [b.name, b.parent]));
   const reached = new Set<string>();
@@ -1150,26 +1168,50 @@ export function shownRow(shown: CoreShown): { name: string; path: string | null
   return { name, path: CORE_REGION_KINDS.has(shown.record.kind) ? (shown.record.path ?? name) : null };
 }
 
+/** Each view's resolutions, by slot and placeholder, kept for the view (`shownAttachment`). */
+const shownOfView = new WeakMap<CompiledDocument, Map<string, Map<string, ShownResolution>>>();
+
 /**
  * What a slot shows at setup under every skin at once — the header's rule:
  * nothing for a `null` placeholder or one no skin fills; the one record where
  * every skin filling the placeholder gives the same row; a `conflict`, naming
  * each skin in the model's order, where they differ.
+ *
+ * The answer reads the view's skins and the slot's name and placeholder only,
+ * so it is resolved once per view, slot and placeholder and kept (issue
+ * #1134: every sample of a walk resolved every slot again). Read-only to every
+ * caller; a view built anew resolves its own.
  */
 export function shownAttachment(doc: CompiledDocument, slot: ModelSlot): ShownResolution {
   if (slot.setup === null) return null;
-  const placeholder = slot.setup;
+  let bySlot = shownOfView.get(doc);
+  if (bySlot === undefined) {
+    bySlot = new Map();
+    shownOfView.set(doc, bySlot);
+  }
+  let byPlaceholder = bySlot.get(slot.name);
+  if (byPlaceholder === undefined) {
+    byPlaceholder = new Map();
+    bySlot.set(slot.name, byPlaceholder);
+  }
+  if (byPlaceholder.has(slot.setup)) return byPlaceholder.get(slot.setup) as ShownResolution;
+  const resolved = resolveShown(doc, slot.name, slot.setup);
+  byPlaceholder.set(slot.setup, resolved);
+  return resolved;
+}
+
+function resolveShown(doc: CompiledDocument, slotName: string, placeholder: string): ShownResolution {
   // Under a named skin: that skin's record, else the default skin's, else nothing (`./skins.ts`).
   if (doc.skin !== CORE_ALL_SKINS) {
     for (const skin of lookupSkins(doc)) {
-      const record = skin.attachments[slot.name]?.[placeholder];
+      const record = skin.attachments[slotName]?.[placeholder];
       if (record !== undefined) return { skin: skin.name, placeholder, record };
     }
     return null;
   }
   const filling: CoreShown[] = [];
   for (const skin of doc.skins) {
-    const record = skin.attachments[slot.name]?.[placeholder];
+    const record = skin.attachments[slotName]?.[placeholder];
     if (record !== undefined) filling.push({ skin: skin.name, placeholder, record });
   }
   if (filling.length === 0) return null;

package/src/core/uvs.ts

@@ -369,7 +369,8 @@ export function shownAtSetup(doc: CompiledDocument): { shown: ShownGeometry[]; w
  */
 export function shownAtSample(doc: CompiledDocument, anim: CoreAnimation, t: number): { shown: ShownGeometry[]; why: string[] } {
   const sliders: SliderApplication[] = [];
-  posedBoneWorld(doc, anim.timelines, t, {}, anim.constraints, sliders);
+  // The bones are posed for what the sliders apply, and only a slider constraint applies one (`applySlider`): with none, the list stays empty and the pose would be read for nothing (issue #1134).
+  if (doc.constraints.some((c) => c.kind === 'slider')) posedBoneWorld(doc, anim.timelines, t, {}, anim.constraints, sliders);
   const placeholders = new Map<string, string | null>();
   posedSlots(doc, anim.timelines, t, {}, sliders, placeholders);
   return attachmentStates(doc, shownAttachment, placeholders, { timelines: anim.timelines, t }, sliders);