spine-rigc 1.9.2 → 1.9.4

package/src/core/additive.ts

@@ -49,8 +49,9 @@
  *
  * So the class is a computation over the document, and the table below
  * carries only what the kind contributes — what its application does when it
- * writes, the runtime class the timeline loads as and the properties it
- * registers. The rest is computed per cell, as the probe reads it.
+ * writes. The rest is computed per cell, as the probe reads it. (What the
+ * runtime calls the timeline is the validator's table, `RUNTIME_TIMELINE`,
+ * since issue #1054.)
  *
  * ## The cells, per kind
  *
@@ -97,63 +98,52 @@ import { slotTimelinesApply } from './skins.ts';
 /** What a kind's application does when it writes (the header's *The cells, per kind*). */
 export type AdditiveMode = 'adds' | 'writes' | 'writes nothing';
 
-/** What a timeline's property ids are followed by: its target's index (and, for an attachment's, the attachment), or nothing. */
-export type AdditiveAddress = 'bone' | 'slot' | 'attachment' | 'constraint' | 'none';
-
-/** One timeline spelling: the runtime class it loads as, the properties it registers in order, what its ids carry, and its mode. */
-export interface AdditiveRow {
-  runtimeClass: string;
-  properties: readonly string[];
-  address: AdditiveAddress;
-  mode: AdditiveMode;
-}
-
-const row = (runtimeClass: string, properties: readonly string[], address: AdditiveAddress, mode: AdditiveMode): AdditiveRow => ({ runtimeClass, properties, address, mode });
-
 /**
- * Every timeline spelling a document's animation can hold, as measured (the
- * header): the class name each loads as and the property ids it registers were
- * read off the loaded timeline objects, and the mode off the probe's cells over
- * the seeded population.
+ * What each timeline spelling's application does when it writes, keyed by the
+ * document's own words (`additiveSpelling`) — measured off the probe's cells
+ * over the seeded population (the header). What the runtime calls each
+ * spelling — the class it loads as and the properties it registers, which A40's
+ * sentence prints — is the validator's to know and stands beside it
+ * (`RUNTIME_TIMELINE`, `src/assertions/model/runtime_timelines.ts`, issue
+ * #1054): this module speaks the document's words only.
  */
-export const ADDITIVE_APPLY: Readonly<Record<string, AdditiveRow>> = {
-  'bone rotate': row('RotateTimeline', ['rotate'], 'bone', 'adds'),
-  'bone translate': row('TranslateTimeline', ['x', 'y'], 'bone', 'adds'),
-  'bone translatex': row('TranslateXTimeline', ['x'], 'bone', 'adds'),
-  'bone translatey': row('TranslateYTimeline', ['y'], 'bone', 'adds'),
-  'bone scale': row('ScaleTimeline', ['scaleX', 'scaleY'], 'bone', 'adds'),
-  'bone scalex': row('ScaleXTimeline', ['scaleX'], 'bone', 'adds'),
-  'bone scaley': row('ScaleYTimeline', ['scaleY'], 'bone', 'adds'),
-  'bone shear': row('ShearTimeline', ['shearX', 'shearY'], 'bone', 'adds'),
-  'bone shearx': row('ShearXTimeline', ['shearX'], 'bone', 'adds'),
-  'bone sheary': row('ShearYTimeline', ['shearY'], 'bone', 'adds'),
-  'bone inherit': row('InheritTimeline', ['inherit'], 'bone', 'writes'),
-  'slot attachment': row('AttachmentTimeline', ['attachment'], 'slot', 'writes'),
-  'slot rgba': row('RGBATimeline', ['rgb', 'alpha'], 'slot', 'writes'),
-  'slot rgb': row('RGBTimeline', ['rgb'], 'slot', 'writes'),
-  'slot alpha': row('AlphaTimeline', ['alpha'], 'slot', 'writes'),
-  'slot rgba2': row('RGBA2Timeline', ['rgb', 'alpha', 'rgb2'], 'slot', 'writes'),
-  'slot rgb2': row('RGB2Timeline', ['rgb', 'rgb2'], 'slot', 'writes'),
-  'attachment deform': row('DeformTimeline', ['deform'], 'attachment', 'adds'),
-  'attachment sequence': row('SequenceTimeline', ['sequence'], 'attachment', 'writes'),
-  ik: row('IkConstraintTimeline', ['ikConstraint'], 'constraint', 'writes'),
-  transform: row('TransformConstraintTimeline', ['transformConstraint'], 'constraint', 'adds'),
-  'path position': row('PathConstraintPositionTimeline', ['pathConstraintPosition'], 'constraint', 'adds'),
-  'path spacing': row('PathConstraintSpacingTimeline', ['pathConstraintSpacing'], 'constraint', 'writes'),
-  'path mix': row('PathConstraintMixTimeline', ['pathConstraintMix'], 'constraint', 'adds'),
-  'physics inertia': row('PhysicsConstraintInertiaTimeline', ['physicsConstraintInertia'], 'constraint', 'writes'),
-  'physics strength': row('PhysicsConstraintStrengthTimeline', ['physicsConstraintStrength'], 'constraint', 'writes'),
-  'physics damping': row('PhysicsConstraintDampingTimeline', ['physicsConstraintDamping'], 'constraint', 'writes'),
-  'physics mass': row('PhysicsConstraintMassTimeline', ['physicsConstraintMass'], 'constraint', 'writes'),
-  'physics wind': row('PhysicsConstraintWindTimeline', ['physicsConstraintWind'], 'constraint', 'adds'),
-  'physics gravity': row('PhysicsConstraintGravityTimeline', ['physicsConstraintGravity'], 'constraint', 'adds'),
-  'physics mix': row('PhysicsConstraintMixTimeline', ['physicsConstraintMix'], 'constraint', 'writes'),
-  // A reset registers its property with no constraint index, named or not (measured: both read `physicsConstraintReset`).
-  'physics reset': row('PhysicsConstraintResetTimeline', ['physicsConstraintReset'], 'none', 'writes nothing'),
-  'slider time': row('SliderTimeline', ['sliderTime'], 'constraint', 'adds'),
-  'slider mix': row('SliderMixTimeline', ['sliderMix'], 'constraint', 'adds'),
-  drawOrder: row('DrawOrderTimeline', ['drawOrder'], 'none', 'writes'),
-  events: row('EventTimeline', ['event'], 'none', 'writes nothing'),
+export const ADDITIVE_MODE: Readonly<Record<string, AdditiveMode>> = {
+  'bone rotate': 'adds',
+  'bone translate': 'adds',
+  'bone translatex': 'adds',
+  'bone translatey': 'adds',
+  'bone scale': 'adds',
+  'bone scalex': 'adds',
+  'bone scaley': 'adds',
+  'bone shear': 'adds',
+  'bone shearx': 'adds',
+  'bone sheary': 'adds',
+  'bone inherit': 'writes',
+  'slot attachment': 'writes',
+  'slot rgba': 'writes',
+  'slot rgb': 'writes',
+  'slot alpha': 'writes',
+  'slot rgba2': 'writes',
+  'slot rgb2': 'writes',
+  'attachment deform': 'adds',
+  'attachment sequence': 'writes',
+  ik: 'writes',
+  transform: 'adds',
+  'path position': 'adds',
+  'path spacing': 'writes',
+  'path mix': 'adds',
+  'physics inertia': 'writes',
+  'physics strength': 'writes',
+  'physics damping': 'writes',
+  'physics mass': 'writes',
+  'physics wind': 'adds',
+  'physics gravity': 'adds',
+  'physics mix': 'writes',
+  'physics reset': 'writes nothing',
+  'slider time': 'adds',
+  'slider mix': 'adds',
+  drawOrder: 'writes',
+  events: 'writes nothing',
 };
 
 /** One timeline of a document's animation, as the core reads it — enough to pose the probe. */
@@ -208,7 +198,7 @@ export const ADDITIVE_DISPLACEMENT = 0.375;
 
 /** A plant: rows of the table read otherwise (the core suite's `CO27`). */
 export interface AdditivePlant {
-  rows?: Readonly<Record<string, AdditiveRow>>;
+  modes?: Readonly<Record<string, AdditiveMode>>;
 }
 
 /** Every time the probe applies a timeline at: its keys' own times, the midpoints between them, and one past the last. */
@@ -453,11 +443,11 @@ function cellOf(view: AdditiveView, state: 'setup' | 'displaced', t: AdditiveTim
 
 /** Every cell of the probe over `views` — each view under the setup state, then the displaced one. */
 export function additiveCells(views: readonly AdditiveView[], t: AdditiveTimeline, plant: AdditivePlant = {}): AdditiveCell[] {
-  const rows = plant.rows ?? ADDITIVE_APPLY;
+  const modes = plant.modes ?? ADDITIVE_MODE;
   const spelled = additiveSpelling(t);
-  const r = rows[spelled];
-  if (r === undefined) throw new Error(`internal: "${spelled}" is no row of the additive table`);
-  return views.flatMap((view) => [cellOf(view, 'setup', t, r.mode), cellOf(view, 'displaced', t, r.mode)]);
+  const mode = modes[spelled];
+  if (mode === undefined) throw new Error(`internal: "${spelled}" is no row of the additive table`);
+  return views.flatMap((view) => [cellOf(view, 'setup', t, mode), cellOf(view, 'displaced', t, mode)]);
 }
 
 /** The class the probe reads over its cells: `accumulates` where any cell does, `overwrites` where any cell only wrote, `inert` otherwise. */

package/src/core/constraints.ts

@@ -470,7 +470,7 @@ import { activeBones, type CompiledDocument, type CoreConstraintKind } from './i
 import { fillingSkins } from './skins.ts';
 import { readPathTimelines, slotBonePlan, solvePath, type CorePathRecord, type CorePathTimelines, type SlotBoneEvent } from './constraints_path.ts';
 import { physicsTimelineCount, readPhysicsTimelines, stepPhysics, type CorePhysicsRecord, type CorePhysicsTimeline, type PhysicsStepContext } from './constraints_physics.ts';
-import { applySlider, posedSlider, readSliderTimelines, sliderBonesWhy, type CoreSliderRecord, type CoreSliderTimeline, type SliderApplication } from './constraints_slider.ts';
+import { applySlider, posedSlider, sliderPhysicsTarget, readSliderTimelines, sliderBonesWhy, type CoreSliderRecord, type CoreSliderTimeline, type SliderApplication } from './constraints_slider.ts';
 
 const DEG = 180 / RUNTIME_PI;
 const RAD = RUNTIME_PI / 180;
@@ -917,6 +917,20 @@ export interface SolverRules {
   sliderAdditiveScaleProduct: boolean;
   /** A slider's scale key at mix exactly 1 writes `setup·v` itself (issue #989), not `from + (setup·v − from)·1`. */
   sliderScaleMixOneIsTarget: boolean;
+  /**
+   * Issue #1049, each the rule `./constraints_slider.ts` *Physics timelines* states — `false` (or the named reading)
+   * plants the reading it rejected: a slider's physics keys write the pass's physics records (`false`: write nothing);
+   * a non-additive one blends from the CURRENT value (`false`: from the setup value); only `wind` and `gravity` add
+   * (`false`: every value kind adds); a `mass` key blends the mass (`false`: the inverse); the write lasts one pass
+   * (`false`: what a slider wrote stands on the next step wherever the step's own animation does not key it); a
+   * `reset` key fires nothing (`false`: a key at or before the slider's time resets its constraints on every pass).
+   */
+  sliderWritesPhysics: boolean;
+  sliderPhysicsFromCurrent: boolean;
+  sliderPhysicsAddsWindGravityOnly: boolean;
+  sliderPhysicsBlendsMass: boolean;
+  sliderPhysicsLastsOnePass: boolean;
+  sliderPhysicsResetIsDead: boolean;
 }
 
 /** The runtime's rules, as measured. */
@@ -939,6 +953,12 @@ export const RUNTIME_SOLVER_RULES: Readonly<SolverRules> = {
   sliderReposesKeyedBones: true,
   sliderAdditiveScaleProduct: true,
   sliderScaleMixOneIsTarget: true,
+  sliderWritesPhysics: true,
+  sliderPhysicsFromCurrent: true,
+  sliderPhysicsAddsWindGravityOnly: true,
+  sliderPhysicsBlendsMass: true,
+  sliderPhysicsLastsOnePass: true,
+  sliderPhysicsResetIsDead: true,
 };
 
 /** The runtime's rules with a plant's over them. */
@@ -1508,6 +1528,8 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
   // An ik over an inactive bone reads the frame above it as the pass left it (issue #979).
   const updated = records.some((c) => c.kind === 'ik' && c.bones.some((b) => !active.has(b))) ? frameUpdatedBefore(bones, active, records, skipped) : new Map<number, boolean>();
   const snapshots = new Map<number, CoreWorld>();
+  // Issue #1049: under the step a slider's physics timelines write the pass's physics records, which a later physics constraint steps with.
+  const physicsPose = physics === undefined ? undefined : sliderPhysicsTarget(records, active, physics, rules);
   const snap = (i: number, when: 'before' | 'after'): void => {
     for (const [k, e] of plan) if (e !== null && e.at === i && e.when === when && !(k === i && when === 'before')) snapshots.set(k, { ...(state.world.get((records[k] as CorePathRecord).slotBone) as CoreWorld) });
   };
@@ -1521,14 +1543,15 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
       // Under Physics.none a physics constraint applies nothing; stepped, it moves its bone in world space (`./constraints_physics.ts`).
       if (physics !== undefined) {
         const w = { ...(state.world.get(c.bone) as CoreWorld) };
-        if ((physics.step ?? stepPhysics)(c, w, bone(state, c.bone).length ?? 0, physics)) {
+        const posed = physicsPose?.records.get(c.name) ?? c;
+        if ((physics.step ?? stepPhysics)(posed, w, bone(state, c.bone).length ?? 0, physics)) {
           state.world.set(c.bone, w);
           changed = [c.bone];
           inWorld = [c.bone];
         }
       }
     } else if (c.kind === 'slider') {
-      changed = applySlider(state, c, applied);
+      changed = applySlider(state, c, applied, physicsPose);
     } else if (c.kind === 'ik') {
       if (c.mix !== 0) {
         const frame = inactiveIkFrame(state, c, i, updated);

package/src/core/constraints_physics.ts

@@ -172,7 +172,9 @@
  * no value, on each of the seven, read exact — the `mass` one NaN in both
  * dumps). The timeline that
  * names no constraint (`*`) writes every active constraint whose `…Global`
- * flag for that value is on, and resets every active constraint.
+ * flag for that value is on, and resets every active constraint. A
+ * slider's animation keys them too, at the slider's place in the update
+ * order (issue #1049, `./constraints_slider.ts` *Its physics timelines*).
  *
  * **reset.** A `reset` key resets its constraints on the step whose apply
  * crosses it — a key in `(last, t]`, `last` the time the walk last applied
@@ -569,6 +571,12 @@ export interface PhysicsStepContext {
    * names for that. Absent on every walk but the looping one.
    */
   loop?: boolean;
+  /** A plant only (issue #1049, `sliderPhysicsLastsOnePass: false`): what the sliders wrote on the step before, by constraint and field. */
+  carried?: Map<string, Partial<Record<'inertia' | 'strength' | 'damping' | 'massInverse' | 'wind' | 'gravity' | 'mix', number>>>;
+  /** Each `constraint/field` the step's own animation keys — what the planted carried write gives way to. */
+  keyedNow?: Set<string>;
+  /** A plant only (issue #1049, `sliderPhysicsFromCurrent: false`): each physics record's setup values, before the step's own animation. */
+  setupRecords?: Map<string, CorePhysicsRecord>;
 }
 
 /** A constraint's state in `ctx`, created fresh on its first update. */
@@ -813,6 +821,8 @@ export function stepPhysicsRecords(records: readonly CoreConstraintRecord[], key
   const physics = records.filter((r): r is CorePhysicsRecord => r.kind === 'physics');
   const posed = posedPhysics(physics, keyed, t, ctx.last, (r) => physicsActive(r, active), {}, ctx.loop === true && t < ctx.last);
   ctx.last = t;
+  ctx.setupRecords = new Map(physics.map((r) => [r.name, r]));
+  ctx.keyedNow = new Set(keyed.flatMap((tl) => (tl.kind === 'reset' ? [] : (tl.name === EVERY_GLOBAL_PHYSICS ? unnamedPhysicsTargets(physics, tl.kind, (r) => physicsActive(r, active)).map((r) => r.name) : [tl.name]).map((n) => `${n}/${tl.kind === 'mass' ? 'massInverse' : tl.kind}`))));
   for (const name of posed.reset) resetPhysicsState(physicsState(ctx, name), before);
   return records.map((r) => (r.kind === 'physics' ? (posed.records.get(r.name) as CorePhysicsRecord) : r));
 }

package/src/core/constraints_slider.ts

@@ -137,9 +137,52 @@
  * animation deforms a curve a path constraint walks (unmeasured). A slider's
  * deform, sequence and draw-order keys are posed since issue #955, after the
  * sample's own (`./deform.ts`, `./draw_order.ts`; they were `sliderAttachmentsWhy`'s
- * absence before). Physics timelines under `Physics.none` pose nothing
- * (`./constraints_physics.ts`) and events a slider does not fire, so neither
- * leaves anything out.
+ * absence before). Its physics timelines are posed since issue #1049 (below),
+ * and events a slider does not fire, so neither leaves anything out.
+ *
+ * ## Its physics timelines (issue #1049)
+ *
+ * Under `Physics.none` a physics constraint applies nothing
+ * (`./constraints_physics.ts`), so neither do a slider's physics keys. Under
+ * the step they do, and until issue #1049 the core applied none of them: on
+ * the selftest's own builds where a dial's animation keys `wind` or
+ * `gravity` of a constraint declared after it, every bone the constraint
+ * drives left spine-core from the third step (`tip` worldX
+ * 14.87037037037037 against 12.092592592592593 at 0.025 s), and with a slot
+ * on that bone `render` drew wrong frames with no refusal. Measured against
+ * spine-core 4.3.13's output only — A10's looping walk, `render`'s recipe at
+ * 60 and 12 fps and the oracle's stepped grid under `--raw`, on 400 compiled
+ * rigs of one or two sliders and one or two physics constraints in random
+ * order, every kind keyed, at tolerance 0 — the rule is:
+ *
+ * - **A slider writes its physics keys into the pass's physics records, at
+ *   its place in the update order**, at the time it applies its animation at
+ *   (`at`), after the step's own animation posed them; a physics constraint
+ *   after it steps with what it wrote, one before it has already stepped.
+ *   Applying the writes to every constraint of the pass whatever its place
+ *   read 239 of the 400 rigs off; not applying them, 205.
+ * - **A write lasts one pass.** The next step's records start again from the
+ *   step's own animation: a write that stood where the step's animation does
+ *   not key read 323 of 400 off.
+ * - **Before the timeline's first key it writes nothing**, as for bones.
+ * - **`wind`, `gravity` under `additive`: `current + v·mix`.** Every other
+ *   value (`inertia`, `strength`, `damping`, `mass`, `mix`), and every value
+ *   of a slider that is not additive: `current + (v − current)·mix`, with
+ *   `current` the value as the pass holds it (the step's own animation and
+ *   any slider before). Adding every kind read 104 of 400 off; blending from
+ *   the setup value (before the step's own animation), 80; writing the key
+ *   itself at mix exactly 1, 20 — in the last bit.
+ * - **A `mass` key blends the mass**, `1 / (m + (v − m)·mix)` with `m =
+ *   1 / massInverse`; blending the inverse read 28 of 400 off.
+ * - **A `reset` key fires nothing** — the slider applies its animation at one
+ *   time, from that time, so no key is crossed (the path-slider suite's
+ *   `PS159` measured the same on the pose); firing a key at or before `at` on
+ *   every pass read 112 of 400 off.
+ * - The timeline naming no constraint (`*`) writes every active constraint
+ *   whose `…Global` flag for that value is on, as a step's own does.
+ *
+ * `CO31` holds the rule on the `core_gate` probe rows and a seeded population
+ * on all three entries; `CO32` plants each rejected reading (`SolverRules`).
  *
  * ## Purity
  *
@@ -148,8 +191,9 @@
  */
 import type { ModelBone } from '../model.ts';
 import { channelAt, keyIndexAt, type CoreAnimationTimelines, type CoreCurve, type CoreKey } from './animation.ts';
-import { sourceValue, TRANSFORM_PROPERTIES, type SolverState, type TransformProperty } from './constraints.ts';
+import { sourceValue, TRANSFORM_PROPERTIES, type CoreConstraintRecord, type SolverRules, type SolverState, type TransformProperty } from './constraints.ts';
 import type { CompiledDocument, CoreAnimation } from './index.ts';
+import { EVERY_GLOBAL_PHYSICS, physicsActive, physicsState, resetPhysicsState, unnamedPhysicsTargets, type CorePhysicsRecord, type CorePhysicsTimeline, type PhysicsStepContext } from './constraints_physics.ts';
 
 /** The fields a slider's record may carry after `kind`, `name`, `declaredIn` (`buildRigConstraint` in `src/compile.ts`). */
 export const SLIDER_FIELDS = ['animation', 'additive', 'loop', 'mix', 'bone', 'property', 'from', 'to', 'scale', 'max', 'local', 'time', 'skin'] as const;
@@ -160,6 +204,8 @@ export interface CoreSliderRecord {
   name: string;
   animation: string;
   timelines: CoreAnimationTimelines;
+  /** Its animation's physics timelines, in the animation's order (issue #1049) — set by `readModel` once the animations' constraint timelines are read, which is after the records. */
+  physics: readonly CorePhysicsTimeline[];
   /** The setup bones its animation keys, by name — what a non-additive key's value is added to. */
   setup: ReadonlyMap<string, ModelBone>;
   additive: boolean;
@@ -252,7 +298,7 @@ export function readSliderRecord(raw: Record<string, unknown>, name: string, whe
     if (b !== undefined) setup.set(b.name, b);
   }
   const record: CoreSliderRecord = {
-    kind: 'slider', name, animation: anim?.name ?? '', timelines: anim?.timelines ?? { declared: 0, duration: 0, bones: [], slots: [], later: [], attachments: [], drawOrder: [], events: [] }, setup,
+    kind: 'slider', name, animation: anim?.name ?? '', timelines: anim?.timelines ?? { declared: 0, duration: 0, bones: [], slots: [], later: [], attachments: [], drawOrder: [], events: [] }, physics: [], setup,
     additive: flag('additive'), loop, mix: num('mix', 1), time: num('time', 0), bone, property,
     from: num('from', 0), to: num('to', 0), scale: num('scale', 1), local: flag('local'), skin: flag('skin'), listedBySkin: false,
   };
@@ -380,13 +426,14 @@ function valuesAt(keys: readonly CoreKey[], t: number): number[] | null {
  * loop to pose again with everything below them. The application is pushed
  * onto `applied` for the slots.
  */
-export function applySlider(state: SolverState, r: CoreSliderRecord, applied?: SliderApplication[]): string[] {
+export function applySlider(state: SolverState, r: CoreSliderRecord, applied?: SliderApplication[], physics?: SliderPhysicsTarget): string[] {
   if (r.mix === 0) return [];
   const time = sliderTime(state, r);
   const d = r.timelines.duration;
   const at = r.loop && d !== 0 ? time % d : time;
   applied?.push({ name: r.name, timelines: r.timelines, at, alpha: r.mix, additive: r.additive, time });
   const alpha = r.mix;
+  if (physics !== undefined && state.rules.sliderWritesPhysics) applySliderPhysics(r, at, alpha, physics);
   const changed: string[] = [];
   for (const target of r.timelines.bones) {
     const index = state.index.get(target.name);
@@ -445,6 +492,89 @@ export function applySlider(state: SolverState, r: CoreSliderRecord, applied?: S
   return changed;
 }
 
+/** The physics records a stepped pass carries, by name — what a slider's physics timelines write and a later physics constraint steps with (issue #1049, the header's *Its physics timelines*). */
+export interface SliderPhysicsTarget {
+  records: Map<string, CorePhysicsRecord>;
+  /** Each record's setup values, before the step's own animation — what a planted blend from the setup reads. */
+  setup: ReadonlyMap<string, CorePhysicsRecord>;
+  active: (r: CorePhysicsRecord) => boolean;
+  rules: Readonly<SolverRules>;
+  ctx: PhysicsStepContext;
+  /** What the sliders wrote this pass, by constraint and field — kept only under the planted reading that a write outlasts its pass. */
+  written: Map<string, Partial<Record<PhysicsField, number>>>;
+}
+
+/** The fields of a physics record a timeline writes. */
+type PhysicsField = 'inertia' | 'strength' | 'damping' | 'massInverse' | 'wind' | 'gravity' | 'mix';
+
+/**
+ * The physics records of one stepped pass, ready for the sliders to write
+ * (issue #1049): every physics record as the step's own animation posed it.
+ * Under the planted reading that a slider's write outlasts its pass, what
+ * the sliders wrote on the step before stands wherever the step's own
+ * animation does not key it (`PhysicsStepContext.keyedNow`).
+ */
+export function sliderPhysicsTarget(records: readonly CoreConstraintRecord[], active: ReadonlySet<string>, ctx: PhysicsStepContext, rules: Readonly<SolverRules>): SliderPhysicsTarget {
+  const posed = new Map(records.flatMap((r): Array<[string, CorePhysicsRecord]> => (r.kind === 'physics' ? [[r.name, r]] : [])));
+  const out = new Map(posed);
+  const written = new Map<string, Partial<Record<PhysicsField, number>>>();
+  if (!rules.sliderPhysicsLastsOnePass) {
+    for (const [name, fields] of ctx.carried ?? new Map<string, Partial<Record<PhysicsField, number>>>()) {
+      const r = out.get(name);
+      if (r === undefined) continue;
+      const next = { ...r };
+      const kept: Partial<Record<PhysicsField, number>> = {};
+      for (const [f, v] of Object.entries(fields) as Array<[PhysicsField, number]>) {
+        if (ctx.keyedNow?.has(`${name}/${f}`)) continue;
+        next[f] = v;
+        kept[f] = v;
+      }
+      out.set(name, next);
+      written.set(name, kept);
+    }
+    ctx.carried = written;
+  }
+  return { records: out, setup: ctx.setupRecords ?? posed, active: (r) => physicsActive(r, active), rules, ctx, written };
+}
+
+/** The value kinds a slider's physics timeline adds under `additive` (`./additive.ts`'s table); the rest write. */
+const PHYSICS_ADDS: ReadonlySet<string> = new Set(['wind', 'gravity']);
+
+/** A slider's physics timelines applied at `at` with alpha `alpha` onto the pass's physics records (the header's *Its physics timelines*). */
+function applySliderPhysics(r: CoreSliderRecord, at: number, alpha: number, target: SliderPhysicsTarget): void {
+  const rules = target.rules;
+  for (const tl of r.physics) {
+    const named = target.records.get(tl.name);
+    const targets = tl.name === EVERY_GLOBAL_PHYSICS ? unnamedPhysicsTargets([...target.records.values()], tl.kind, target.active) : named !== undefined && target.active(named) ? [named] : [];
+    if (tl.kind === 'reset') {
+      // A slider applies its animation at one time, from that time: no key is crossed, so a reset key fires nothing (PS159).
+      if (!rules.sliderPhysicsResetIsDead && tl.keys.some((k) => k.time <= at)) for (const p of targets) resetPhysicsState(physicsState(target.ctx, p.name), target.ctx.time);
+      continue;
+    }
+    const i = keyIndexAt(tl.keys, at);
+    if (i < 0) continue;
+    const v = channelAt(tl.keys, i, 0, at);
+    const adds = r.additive && (PHYSICS_ADDS.has(tl.kind) || !rules.sliderPhysicsAddsWindGravityOnly);
+    for (const p of targets) {
+      const from = rules.sliderPhysicsFromCurrent ? p : (target.setup.get(p.name) as CorePhysicsRecord);
+      const next = { ...p };
+      let field: PhysicsField;
+      if (tl.kind === 'mass') {
+        field = 'massInverse';
+        if (rules.sliderPhysicsBlendsMass) {
+          const m = 1 / from.massInverse;
+          next.massInverse = 1 / (adds ? 1 / p.massInverse + v * alpha : m + (v - m) * alpha);
+        } else next.massInverse = adds ? p.massInverse + (1 / v) * alpha : from.massInverse + (1 / v - from.massInverse) * alpha;
+      } else {
+        field = tl.kind;
+        next[field] = adds ? p[field] + v * alpha : from[field] + (v - from[field]) * alpha;
+      }
+      target.records.set(p.name, next);
+      if (!rules.sliderPhysicsLastsOnePass) target.written.set(p.name, { ...target.written.get(p.name), [field]: next[field] });
+    }
+  }
+}
+
 /** A slot's pose as the sliders move it: what it shows, its light colour and its dark colour (`null` when it states none). */
 export interface SlotPoseState {
   placeholder: string | null;

package/src/core/index.ts

@@ -352,9 +352,10 @@ export interface CompiledDocument {
   /**
    * The skin the document is posed under (issue #932, `./skins.ts`): `all` —
    * every skin merged, the oracle's `--skin all` and `readModel`'s reading —
-   * or one skin's name, `underSkin`'s.
+   * one skin's name, `underSkin`'s, or `null` — no skin set, the runtime's
+   * `Skeleton.skin` before `setSkin` is called (`underNoSkin`, issue #1051).
    */
-  skin: string;
+  skin: string | null;
   /** The skeleton's reference scale (issue #958), which every physics record carries too (`CorePhysicsRecord.referenceScale`). */
   referenceScale: number;
   bones: ModelBone[];
@@ -390,7 +391,7 @@ export interface CoreStated {
 /**
  * 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
+ * numbers, a list of at least one region (issue #1054) — 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.
@@ -422,6 +423,10 @@ function readPages(value: unknown, problems: string[], flags: boolean): ModelPag
     }
     const regions: ModelPageRegion[] = [];
     if (!Array.isArray(raw.regions)) problems.push(`${label}: regions is not a list`);
+    // Issue #1054: a page holding no region is one no build writes — the atlas text's block for it would end before any region line, which
+    // the round trip refuses (A07_ATLAS_TEXT_SHAPE: "the last page block declares no region") — so a document stating one is refused here by
+    // the page's name rather than read, where nothing on the model side would name it.
+    else if (raw.regions.length === 0) problems.push(`${label}: regions is an empty list — a page holds at least one region; the atlas text cannot state a page with none (its block would end before a region line, which A07_ATLAS_TEXT_SHAPE refuses), so no build writes one`);
     else {
       raw.regions.forEach((region, j) => {
         const at = `${label}.regions[${j}]`;
@@ -880,6 +885,11 @@ export function readModel(text: string, where = 'the model document'): CompiledD
       if (isRecord(raw) && animations[i] !== undefined) animations[i].constraints = readConstraintTimelines(raw.constraints, `animations[${i}] "${animations[i].name}"`, constraints, problems);
     });
   }
+  // A slider's physics timelines are its animation's (issue #1049), read only now.
+  for (const c of constraints) {
+    const r = c.record;
+    if (r?.kind === 'slider') r.physics = animations.find((a) => a.name === r.animation)?.constraints.physicsKeyed ?? [];
+  }
   const editorOrder = spec === CORE_DOCUMENT_SPEC && 'editorOrder' in value ? readEditorOrder(value.editorOrder, skins, animations, problems) : null;
   if (problems.length > 0) throw new CoreInputError(`${where}: ${problems.length} problem(s): ${problems.join('; ')}`);
   const stated: CoreStated | null = editorOrder === null ? null : { stage, editorOrder };
@@ -904,6 +914,20 @@ export function underSkin(doc: CompiledDocument, name: string): CompiledDocument
   return view;
 }
 
+/**
+ * The document posed with no skin set (issue #1051): no skin's `bones` or
+ * constraint lists applied — the default skin's included — and every slot
+ * resolved through the default skin alone, or through nothing where the
+ * document declares none (`./skins.ts`, *No skin set*, for the measurement).
+ * The view a fresh skeleton is in: `render` without `--skin`, A10's walk and
+ * `validate()`'s poses (`noSkinView` in `src/render_core.ts`).
+ */
+export function underNoSkin(doc: CompiledDocument): CompiledDocument {
+  const view: CompiledDocument = { ...doc, skin: null, constraints: doc.constraints.map((c) => (c.record === undefined ? c : { ...c, record: { ...c.record } as CoreConstraintRecord })) };
+  resolveSkinView(view);
+  return view;
+}
+
 /**
  * What a skin view decides on the constraint records: whether an applied
  * skin's list names each (`listedBySkin`, `./skins.ts`), and what each path

package/src/core/skins.ts

@@ -54,6 +54,30 @@
  *   not what the slot shows; under `all` every bone some skin names is
  *   active, so a one-skin rig is unchanged.
  *
+ * - **No skin set** (issue #1051): a fresh skeleton whose `setSkin` was never
+ *   called — `underNoSkin`, the state `render` without `--skin`, A10's walk
+ *   and `validate()` pose in. No skin's `bones` or constraint lists are
+ *   applied, the default skin's included, and a slot shows the default
+ *   skin's record for its placeholder, else nothing — so over a document
+ *   with skins and no `default` one every slot shows nothing. Measured with
+ *   `tools/pose_oracle.ts dump --skin none` on 93 skeletons rebuilt through
+ *   `ingest` and `compile` (31 with no default skin, 31 whose default names
+ *   skin-required members, 31 with a plain default): `Skeleton.skin` read
+ *   `null` on all 93; all 311 skin-required bones read inactive — the 51 a
+ *   default skin names among them, and the 66 a constraint writes — and the
+ *   125 bones that are not skin-required under one read active and unposed;
+ *   all 73 skin-required constraints read inactive and moved nothing when
+ *   removed — the 12 a default skin lists among them — and the 81 that are
+ *   not read active; 199 slots whose placeholder the default skin fills
+ *   showed it and 359 only named skins fill showed nothing; a colour key on
+ *   a slot whose bone is inactive held its setup colour (50 of 50) and moved
+ *   it on an active one (46 of 46), and a draw-order key applied either way
+ *   (93 of 93). The core suite's `CO29` holds the same population against
+ *   the core under `--raw` at tolerance 0, and `CO30` plants each rejected
+ *   reading (the old one among them: no skin set read as the default skin,
+ *   which differs exactly where the default skin names a skin-required
+ *   member).
+ *
  * Under `all` every skin is applied at once: `bones` and the constraint
  * lists of every skin count, and a placeholder several skins fill shows the
  * LAST of them in the Spine file's order — the case `./index.ts` leaves out
@@ -68,15 +92,16 @@ export const CORE_ALL_SKINS = 'all';
 /** The skin a document names its default skin with — Spine's `SkeletonData.defaultSkin` is the skin of this name. */
 export const CORE_DEFAULT_SKIN = 'default';
 
-/** The skins whose `bones` and constraint lists are applied: every skin under `all`, the named skin alone otherwise (the header's measurement). */
+/** The skins whose `bones` and constraint lists are applied: every skin under `all`, none with no skin set, the named skin alone otherwise (the header's measurements). */
 export function appliedSkins(doc: CompiledDocument): CoreSkin[] {
+  if (doc.skin === null) return [];
   return doc.skin === CORE_ALL_SKINS ? doc.skins : doc.skins.filter((k) => k.name === doc.skin);
 }
 
-/** Under a named skin, the skins a placeholder is looked up in, in precedence order: the named skin, then the default skin (the header's measurement). */
+/** Under a named skin or none, the skins a placeholder is looked up in, in precedence order: the named skin, then the default skin (the header's measurements). */
 export function lookupSkins(doc: CompiledDocument): CoreSkin[] {
   if (doc.skin === CORE_ALL_SKINS) return doc.skins;
-  const named = doc.skins.find((k) => k.name === doc.skin);
+  const named = doc.skin === null ? undefined : doc.skins.find((k) => k.name === doc.skin);
   const fallback = doc.skin === CORE_DEFAULT_SKIN ? undefined : doc.skins.find((k) => k.name === CORE_DEFAULT_SKIN);
   return [named, fallback].filter((k): k is CoreSkin => k !== undefined);
 }