spine-rigc 2.12.0 → 2.13.1

package/README.md

@@ -63,8 +63,13 @@ it cuts both ways:
   selftest call, and on a private corpus of production rigs measured before each
   release. Of the 51 assertions, 50 run on both; `A00_ROUNDTRIP_PARSE`, the official
   parser's own parse, runs only where the runtime is installed and is reported as a
-  SKIP elsewhere. Install it beside rigc (`bun add -d @esotericsoftware/spine-core`)
-  and the same `rigc` runs the round trip on every build. The
+  SKIP elsewhere. There, in the parse's place, the report also carries the model
+  side's own two parse rules, `A00_MODEL_READ` and `A00_MODEL_REGIONS_ON_PAGES`,
+  which no round-trip rule matches and the registry does not hold — so its summary
+  totals 53 on the core entry, and its last line counts 44 rules on the model side
+  ([AUTHORING §5.2](docs/AUTHORING.md) has a row for each). Install it beside rigc
+  (`bun add -d @esotericsoftware/spine-core`) and the same `rigc` runs the round
+  trip on every build. The
   [Spine Runtimes License Agreement](https://esotericsoftware.com/spine-runtimes-license)
   applies to that dependency wherever it is installed.
 

package/docs/AUTHORING.md

@@ -155,9 +155,11 @@ That entry's `build` takes the same flags and writes the same files, byte for by
 `skeleton.json`, `skeleton.atlas`, `skeleton.model.json`, and the pages `--pack` or
 `--copy-images` put in `--out`.
 Only the gate differs, because the round trip is spine-core's: it runs the model
-side over the document, and the round trip's own rules restated over the text the
-emitter wrote (A01, A02, A05, A07, A16, A31, A35, and A18 over a second compile's
-three files), and it does not run `A00_ROUNDTRIP_PARSE`, which reports **SKIP**
+side over the document — its own two parse rules first, `A00_MODEL_READ` and
+`A00_MODEL_REGIONS_ON_PAGES`, which stand where spine-core's parse stands and are
+not in the registry, then the registry's rules that read the model — and the round
+trip's own rules restated over the text the emitter wrote (A01, A02, A05, A07, A16,
+A31, A35, and A18 over a second compile's three files), and it does not run `A00_ROUNDTRIP_PARSE`, which reports **SKIP**
 naming spine-core. Its report ends on a line saying which rules ran there and
 which did not, and it writes only when none of them fails (§5.2).
 
@@ -6358,6 +6360,16 @@ you can reproduce by counting rows:
 assertions and not `FAIL` lines: one assertion that finds six wrong vertices
 prints six rows and is one failure here.
 
+🔢 **On the entry without the runtime the report has two rows the registry does not.**
+`cli_core.ts build` (and `repack`) prints the model side's own parse rules,
+`A00_MODEL_READ` and `A00_MODEL_REGIONS_ON_PAGES` — the first two rows of the
+table below — which stand where `A00_ROUNDTRIP_PARSE`'s parse stands and have no
+round-trip counterpart, so they are not in the registry. That is the whole of the
+difference between the two totals: `<N>` is 53 on the core entry and 51 on `cli.ts build`,
+and the core report's last line states the split — 44 rules on the model side,
+which are the 42 registry assertions the model side runs and those two; the 8 restated over the emitted text;
+and `A00_ROUNDTRIP_PARSE`, which it reports as a SKIP.
+
 🚨 **When `A00_ROUNDTRIP_PARSE` fails, read the report as a report about A00 and
 nothing else.** Most of the rules read the skeleton or the atlas that A00 loads,
 and with no parse there is nothing for them to look at — so they report `SKIP`
@@ -6368,7 +6380,9 @@ Fix A00 and run it again.
 
 | Assertion | Profile | What tripped it, and where to fix it |
 | --- | --- | --- |
-| `A00_ROUNDTRIP_PARSE` | both | `spine-core` could not parse the skeleton or the atlas. Almost everything else in the report is downstream of this one — fix it first. When it fails, every rule that reads the loaded skeleton or the loaded atlas reports **SKIP** saying so by name, so the row count stays at the full registry and the summary's *measured* figure tells you how little was actually asked. ⚠️ **Two rules run before it and can be upstream of it**: `A31_DRAW_ORDER_OFFSETS_RESOLVE`, because a bad draw-order key makes the loader spin rather than return, and `A08_REGION_NAMES_MATCH_ATTACHMENTS`, because a `path` naming no region makes it throw. The round trip is still attempted either way; when the loader refuses a path A08 has already refused, this row **defers** to A08 by name instead of restating the miss in the parser's poorer words Under `cli_core.ts build`, which links none of spine-core, it is a **SKIP** naming spine-core — the one rule of the 50 that entry does not run. The entry that links spine-core runs it on `build` and `validate`: installed, the same `rigc` once `@esotericsoftware/spine-core` is installed beside the package; from a clone, `bun cli.ts` (`RC28`). |
+| `A00_MODEL_READ` | both | **Printed only by `cli_core.ts build` and `repack`**, where it runs before every other rule and its line leads the lines of its verdict; `cli.ts` never prints it, because there the parse is `A00_ROUNDTRIP_PARSE`'s. rigc's own reader of the model document (`readModel`) refused the `skeleton.model.json` this build compiled — the model side's parse, and like A00 the row to read first: when it fails, `A00_MODEL_REGIONS_ON_PAGES` **SKIPs** naming it and every registry rule of the model side **SKIPs** with *the model side read no document to measure*. The detail is the reader's own sentence, naming each path it refused, the value there and what it must be: `the model document: 1 problem(s): skins[0] "default".attachments["torso"]["torso"]: width is "wide", not a finite number`, `spec is "rigc-compiled/9", not "rigc-compiled/3" (…)`, `section "rig" is missing`, or `… in the rig section the model side reads its declarations from: rig.archetype is 7, not a string`. ⚠️ **No file of yours reaches it, written or edited**: the document it reads is the one the compiler just wrote in the same process, before anything is on disk, and `validate` on this entry refuses a rigc build rather than reading one (`RC36`). So a FAIL here is the compiler writing a document its own reader refuses — a rigc fault, whatever the spec says. Report it with the rig spec, the motion spec, the manifest and art if the build used them, and the command line. Not one of the registry's assertions: it is one of the two rows that make a core-entry summary total two more than `cli.ts`'s (§5.2 above) |
+| `A00_MODEL_REGIONS_ON_PAGES` | both | **Printed only by `cli_core.ts build` and `repack`**, run second, after `A00_MODEL_READ`. A record of the document that draws through an atlas region — a region, a mesh or a linked mesh, every frame of a `sequence` by its numbered name — resolves through a region no page of the document holds, or states that the build had no rectangle for it: `skin "default" slot "torso" placeholder "torso": resolves through the region "torso_typo", which no page of the document holds`, beside `…: the region record's atlas is null — the build had no rectangle for "torso_typo", and a runtime loading it finds no region`. **The rig spec reaches this one**: an attachment with no `image`, its `width` and `height` given, whose `path` names a region the build atlases no art for. `A08_REGION_NAMES_MATCH_ATTACHMENTS` fails on the same record with the attachment's own name, and the round trip refuses the same build at A08 and `A00_ROUNDTRIP_PARSE`. Change the attachment's `path` in the rig spec to a region the build has — a PNG under `images`, or a region of the `--atlas-in` pack — or give it the `image` it draws. Two more shapes it prints are documents a build of this rigc does not write, so on `build` they are a rigc fault, reported as for `A00_MODEL_READ`: `the document is rigc-compiled/1, which states no pages, …` and `the model document's sequences: … start is "x", not a whole number of at least 0`. **SKIP** when `A00_MODEL_READ` refused the document (it names that row), and when no record draws through a region — a rig with no region, mesh or linked-mesh attachment. Not one of the registry's assertions, for the reason the row above gives |
+| `A00_ROUNDTRIP_PARSE` | both | `spine-core` could not parse the skeleton or the atlas. Almost everything else in the report is downstream of this one — fix it first. When it fails, every rule that reads the loaded skeleton or the loaded atlas reports **SKIP** saying so by name, so the row count stays at the full registry and the summary's *measured* figure tells you how little was actually asked. ⚠️ **Two rules run before it and can be upstream of it**: `A31_DRAW_ORDER_OFFSETS_RESOLVE`, because a bad draw-order key makes the loader spin rather than return, and `A08_REGION_NAMES_MATCH_ATTACHMENTS`, because a `path` naming no region makes it throw. The round trip is still attempted either way; when the loader refuses a path A08 has already refused, this row **defers** to A08 by name instead of restating the miss in the parser's poorer words Under `cli_core.ts build`, which links none of spine-core, it is a **SKIP** naming spine-core — the one rule of the registry that entry does not run. The entry that links spine-core runs it on `build` and `validate`: installed, the same `rigc` once `@esotericsoftware/spine-core` is installed beside the package; from a clone, `bun cli.ts` (`RC28`). |
 | `A01_NO_LEGACY_TOPLEVEL_CONSTRAINT_ARRAYS` | both | a 4.1/4.2-shaped `ik`/`transform`/`path`/`physics`/`slider` array. rigc emits the 4.3 `constraints` array, so this normally means hand-edited JSON Under `cli_core.ts build` the same clause runs over the text the emitter wrote and prints this line in the same words (`RC28`). |
 | `A02_NO_BONE_TRANSFORM_KEY` | both | `bone "…" uses "transform", the key 4.0 and 4.1 spelled; 4.2 and 4.3 spell it "inherit"` — rename it `inherit` in the rig spec Under `cli_core.ts build` the same clause runs over the text the emitter wrote and prints this line in the same words (`RC28`). |
 | `A03_REGION_WIDTH_HEIGHT_FINITE` | both | a region loaded `NaN` or a non-positive size — the attachment has no `image` and no `width`/`height`. **SKIP** when the skeleton carries no region attachment |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "2.12.0",
+  "version": "2.13.1",
   "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/skills/rigc/SKILL.md

@@ -49,7 +49,10 @@ through `@esotericsoftware/spine-core`: install it beside the package
 (`bun add -d @esotericsoftware/spine-core`) and the same `rigc` runs them, and
 `build` runs the round trip as well. Without it they are refused by name, and
 `build` writes the same files gated without the parse — `rigc --version` names the
-entry that ran.
+entry that ran. In the parse's place that `build` runs two rules of its own over
+rigc's model document, `A00_MODEL_READ` and `A00_MODEL_REGIONS_ON_PAGES`; they are
+not registry assertions, so its summary counts two more, and AUTHORING §5.2 has a
+row for each.
 
 ## The loop
 

package/src/assertions/model/stepped_poses.ts

@@ -42,9 +42,11 @@ const modeOf = (bone: ModelBone): string | null => (foldInheritMode(bone.inherit
 /** A channel the walk computed; a slot row holds `null` only where a rounding wrote one, which the walk does not. */
 const channel = (v: number | null): number => (v === null ? Number.NaN : v);
 
-/** One walk pose as A10 reads it, each bone's mode taken from `posed` (the bones the timelines posed at the pose's time). */
-function frameOf(pose: WalkPose, posed: readonly ModelBone[]): SteppedFrame {
-  const modes = new Map(posed.map((b) => [b.name, modeOf(b)]));
+/** Each bone's posed mode as the facts spell it (`modeOf`), by name. */
+const modesOf = (posed: readonly ModelBone[]): ReadonlyMap<string, string | null> => new Map(posed.map((b) => [b.name, modeOf(b)]));
+
+/** One walk pose as A10 reads it, each bone's mode taken from `modes` (`modesOf` the bones the timelines posed at the pose's time). */
+function frameOf(pose: WalkPose, modes: ReadonlyMap<string, string | null>): SteppedFrame {
   return {
     bones: pose.bones.map((b) => ({ name: b.name, a: b.a, b: b.b, c: b.c, d: b.d, worldX: b.worldX, worldY: b.worldY, inherit: modes.get(b.name) ?? null })),
     drawn: pose.drawn.map((d) => ({ slot: d.slot, attachment: d.attachment, vertices: d.vertices })),
@@ -80,11 +82,15 @@ export function modelSteppedPoses(read: ReadDocument): SteppedPoseFacts {
     },
     // The document's stated mode — asked only of a bone posing none, which the reader leaves this side no document to hold.
     statedInherit: (name) => `${JSON.stringify(read.doc.bones.find((b) => b.name === name)?.inheritMode)}`,
-    setup: () => frameOf(poseWalkSetup(viewOf()), viewOf().bones),
+    setup: () => frameOf(poseWalkSetup(viewOf()), modesOf(viewOf().bones)),
     walk: (animation, step, frames) => {
       const anim = animationOf(animation);
       const poses = poseLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
-      return poses.slice(1).map((pose) => frameOf(pose, posedBones(viewOf(), anim.timelines, pose.animationTime)));
+      // A bone's posed mode moves only by an `inherit` timeline: every other one `posedBones` reads leaves the setup's mode on its copy. So an animation
+      // keying none poses the setup's modes at every time, and they are read once rather than posed again at each of its frames (issue #1179).
+      const keysInherit = anim.timelines.bones.some((target) => target.timelines.some((tl) => tl.kind === 'inherit'));
+      const setupModes = keysInherit ? null : modesOf(viewOf().bones);
+      return poses.slice(1).map((pose) => frameOf(pose, setupModes ?? modesOf(posedBones(viewOf(), anim.timelines, pose.animationTime))));
     },
   };
 }

package/src/core/constraints.ts

@@ -1529,9 +1529,9 @@ export function applyConstraints(bones: readonly ModelBone[], world: ReadonlyMap
     if (inactiveWhy(state, c) !== null) skipped.add(i);
   });
   // A path constraint's offset reads its slot bone's world as the runtime last brought it up to date (`./constraints_path.ts`, *Which slot bone*).
-  const plan = records.some((c) => c.kind === 'path') ? slotBonePlan(bones, active, records, skipped) : new Map<number, SlotBoneEvent | null>();
+  const plan = records.some((c) => c.kind === 'path') ? keptPlan(slotBonePlans, state, records, skipped, () => slotBonePlan(bones, active, records, skipped)) : new Map<number, SlotBoneEvent | null>();
   // 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 updated = records.some((c) => c.kind === 'ik' && c.bones.some((b) => !active.has(b))) ? keptPlan(frameUpdates, state, records, skipped, () => 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);
@@ -1578,24 +1578,111 @@ 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> }>();
+/**
+ * What `slotBonePlan` (`./constraints_path.ts`) and `frameUpdatedBefore` read
+ * of a record: its kind and the names it orders — a name by value, a list by
+ * identity. Every pass of a walk poses its records afresh (`posedRecords`,
+ * `pathDeformed`, `stepPhysicsRecords` spread each one), and a spread carries
+ * these lists over as the same arrays.
+ */
+function planShape(c: CoreConstraintRecord): readonly unknown[] {
+  switch (c.kind) {
+    case 'slider':
+      return [c.kind, c.timelines.bones];
+    case 'ik':
+      return [c.kind, c.target, c.bones];
+    case 'physics':
+      return [c.kind, c.bone];
+    case 'transform':
+      return [c.kind, c.source, c.bones];
+    case 'path':
+      return [c.kind, c.bones, c.slotDeps, c.slotBone];
+  }
+}
+
+/** A plan kept per solver index, with the record shapes (`planShape`) and the skipped records it was built over. */
+interface KeptPlan<T> {
+  shapes: ReadonlyArray<readonly unknown[]>;
+  skipped: readonly number[];
+  plan: T;
+}
+const slotBonePlans = new WeakMap<ReadonlyMap<string, number>, KeptPlan<Map<number, SlotBoneEvent | null>>>();
+const frameUpdates = new WeakMap<ReadonlyMap<string, number>, KeptPlan<Map<number, boolean>>>();
+
+/**
+ * A pass's ordering plan — `slotBonePlan` or `frameUpdatedBefore` — reused
+ * from the pass before when nothing it reads has changed (issue #1179): the
+ * bones' names and parents and the active set (one solver index stands for
+ * those, `boneIndex`), each record's shape, and which records are skipped.
+ * Otherwise built again. Both read names and nothing else, so a reused plan is
+ * the plan the pass would have built; neither is written once built.
+ */
+function keptPlan<T>(kept: WeakMap<ReadonlyMap<string, number>, KeptPlan<T>>, state: SolverState, records: readonly CoreConstraintRecord[], skipped: ReadonlySet<number>, build: () => T): T {
+  const shapes = records.map(planShape);
+  const skips = [...skipped];
+  const last = kept.get(state.index);
+  if (
+    last !== undefined &&
+    last.shapes.length === shapes.length &&
+    shapes.every((sh, i) => sh.length === last.shapes[i].length && sh.every((v, j) => v === last.shapes[i][j])) &&
+    last.skipped.length === skips.length &&
+    skips.every((k, i) => k === last.skipped[i])
+  ) {
+    return last.plan;
+  }
+  const plan = build();
+  kept.set(state.index, { shapes, skipped: skips, plan });
+  return plan;
+}
+
+/** The last bone index each view's active set was asked for, with the names and parents it was built over (`boneIndex`). */
+const indexOfView = new WeakMap<ReadonlySet<string>, { names: string[]; parents: Array<string | undefined>; 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.
+ * and the parents agree position by position, and built again otherwise —
+ * the parents because `repose` keeps each bone's subtree beside the index
+ * (`subtreesOf`), and a subtree is a reading of them. 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;
+  if (kept !== undefined && kept.names.length === bones.length && bones.every((b, i) => b.name === kept.names[i] && b.parent === kept.parents[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 });
+  indexOfView.set(active, { names: bones.map((b) => b.name), parents: bones.map((b) => b.parent), index });
   return index;
 }
 
+/** Each bone's subtree as `subtreesOf` built it, kept per solver index (one object per view's bones, `boneIndex`). */
+const subtreesOfIndex = new WeakMap<ReadonlyMap<string, number>, ReadonlyArray<readonly number[]>>();
+
+/**
+ * For the bone at each position of `state.bones`, the positions of the bone
+ * and of every bone below it, ascending (issue #1179). Bones are parents
+ * first, so each position is appended to its own list and its ancestors' in
+ * ascending order. Built from the bones' parents once per solver index —
+ * `boneIndex` hands back one index only while the names and the parents are
+ * the ones it was built over, and the other two solver states (`previousPassSlotBones`,
+ * `historyTaint`) build an index of their own.
+ */
+function subtreesOf(state: SolverState): ReadonlyArray<readonly number[]> {
+  const kept = subtreesOfIndex.get(state.index);
+  if (kept !== undefined) return kept;
+  const lists: number[][] = state.bones.map(() => []);
+  for (let k = 0; k < state.bones.length; k++) {
+    let at: number | undefined = k;
+    while (at !== undefined) {
+      lists[at].push(k);
+      const parent: string | undefined = state.bones[at].parent;
+      at = parent === undefined ? undefined : state.index.get(parent);
+    }
+  }
+  subtreesOfIndex.set(state.index, lists);
+  return lists;
+}
+
 /** 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) {
@@ -1606,13 +1693,17 @@ function repose(state: SolverState, changed: readonly string[], inWorld: readonl
   const moved = changed;
   const below = new Set(changed);
   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;
+  // A bone joins `below` only through its parent, so the bones that can are the moved bones' subtrees: the walk visits those, in bone order (issue
+  // #1179), where it visited every bone from the first one moved (issue #1134) — the bones it no longer visits are the ones whose parent `below`
+  // could never hold, so each bone it does visit reads the same `below`, and is posed again in the same order.
+  const subtrees = subtreesOf(state);
+  const lists: Array<readonly number[]> = [];
   for (const name of changed) {
     const at = state.index.get(name);
-    if (at !== undefined && at < from) from = at;
+    if (at !== undefined) lists.push(subtrees[at]);
   }
-  for (let k = from; k < state.bones.length; k++) {
+  const visit = lists.length === 1 ? lists[0] : [...new Set(lists.flat())].sort((x, y) => x - y);
+  for (const k of visit) {
     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.includes(b.parent))) below.add(b.name);

package/src/core/raw.ts

@@ -120,7 +120,7 @@ import { freshStepContext, steppedPreviousPassWhy } from './constraints_physics.
 import { attachmentStates } from './deform.ts';
 import { drawOrderAt } from './draw_order.ts';
 import { eventsFired } from './events.ts';
-import { REGION_TRIANGLES, REGION_UVS } from './clipping.ts';
+import { REGION_TRIANGLES, REGION_UVS, type ShapeClipper } from './clipping.ts';
 import { poseGeometry, type ShownGeometry } from './vertices.ts';
 import { RUNTIME_DEG, type CoreWorld } from './world.ts';
 import type { SliderApplication } from './constraints_slider.ts';
@@ -240,6 +240,16 @@ function numberOf(v: number | null, what: string, mode: WalkMode): number {
   return mode.keep ? (v === null ? Number.NaN : v) : finite(v, what);
 }
 
+/**
+ * What the looping walk cuts a drawn attachment through under a clip: nothing
+ * (issue #1179). Its one reader, A10, reads no clipped row — `./walk.ts`
+ * narrows them away with the events — so the walk does not cut them; what it
+ * still does is plan every clip it starts (`poseClipped`'s `clipShapeOf`), so
+ * a clip the core does not draw refuses the walk by name as before. Every
+ * number a looping pose carries is computed as it was.
+ */
+const NO_CLIPPED_ROWS: ShapeClipper = () => null;
+
 /** The bones of a pose from the world transforms (the header's `bones`). */
 function rawBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>): RawBone[] {
   const active = activeBones(doc);
@@ -266,7 +276,8 @@ function rawBones(doc: CompiledDocument, world: ReadonlyMap<string, CoreWorld>):
 
 /** 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 geometry = poseGeometry(shown, world, sourceOfDoc(doc), mode.keep ? keptNumber : rawNumber, { region: plant.region, vertices: plant.vertices }, drawWalkOf(doc, order, plant));
+  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 && 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}`);
@@ -399,7 +410,8 @@ export function walkIn(doc: CompiledDocument, animation: string, steps: readonly
     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));
     const drawn = rawDrawn(doc, shown, posed.world, drawOrder, plant, mode);
-    // A looping walk fires no event here: what fires across the wrap was not measured, and the walk's one reader (A10) reads none.
+    // A looping walk fires no event here: what fires across the wrap was not measured, and the walk's one reader (A10) reads none. Nor does it cut its
+    // drawn attachments through a clip (`NO_CLIPPED_ROWS`), so its `clipped` rows are empty.
     const events = mode.loop ? [] : (plant.events ?? eventsFired)(anim.timelines.events, last, t, rawNumber).map((e): RawEvent => [e[0], finite(e[1], 'event time'), e[2], finite(e[3], 'event float'), e[4]]);
     last = t;
     poses.push({ trackTime, animationTime: t, bones: rawBones(doc, posed.world), slots: slots.rows, drawOrder, ...drawn, events, shown });

package/src/core/walk.ts

@@ -58,7 +58,9 @@
  *   NaN and Infinity stood where spine-core's did.
  *
  * Events are not carried: A10 reads none, and what a looping track fires
- * across the wrap was not measured.
+ * across the wrap was not measured. Nor are the clipped rows, and the walk
+ * does not cut them (issue #1179): every clip it starts is still planned, so
+ * a clip the core does not draw refuses the walk by name, as below.
  *
  * ⛔ **What is still refused** is the raw entry's other refusal: a construct
  * the core would leave out (a block the oracle's core dump names absent) is a