@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -1,21 +1,19 @@
 import { assert } from "../../../core/assert.js";
 import { FrameGraph } from "../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
+import { GPU_DATABASE_NULL } from "../buffer/table/GPU_DATABASE_NULL.js";
+import { generate_record_writer } from "../buffer/table/serde/generate_record_writer.js";
 import {
     graph_scene_update_transform_hierarchy
 } from "../scene/hierarchy/graph_scene_update_transform_hierarchy.js";
 import { graph_import_buffer } from "../shader/graph/graph_import_buffer.js";
-import {
-    ANIMATION_BOUND_TRACK_GROUP_NULL,
-    TRACKS_PER_GROUP_NODE,
-} from "./ANIMATION_BOUND_TRACK_GROUP_STRUCT.js";
+import { ANIMATION_CLIP_STATE_STRUCT } from "./ANIMATION_CLIP_STATE_STRUCT.js";
+import { ANIMATION_CURVE_KEYFRAME_STRUCT } from "./ANIMATION_CURVE_KEYFRAME_STRUCT.js";
 import { ANIMATION_DATABASE_SPEC } from "./ANIMATION_DATABASE_SPEC.js";
+import { ANIMATION_SKIN_JOINT_STRUCT } from "./ANIMATION_SKIN_JOINT_STRUCT.js";
+import { ANIMATION_SKIN_STRUCT } from "./ANIMATION_SKIN_STRUCT.js";
+import { ANIMATION_TRACK_BINDING_STRUCT } from "./ANIMATION_TRACK_BINDING_STRUCT.js";
 import { AnimationClipFlags } from "./AnimationClipFlags.js";
-import { KEYFRAMES_PER_BLOCK } from "./ANIMATION_KEYFRAME_BLOCK_STRUCT.js";
-import {
-    ANIMATION_SKIN_JOINT_BLOCK_NULL,
-    JOINTS_PER_SKIN_BLOCK,
-} from "./ANIMATION_SKIN_JOINT_BLOCK_STRUCT.js";
 import { POSE_ACCUMULATOR_SLOT_BYTES } from "./POSE_ACCUMULATOR_LAYOUT.js";
 import { GPUStateAuthorityFlags } from "../../../engine/ecs/gpu/GPUStateAuthorityFlags.js";
 import { gpu_authority_grant } from "../../../engine/ecs/gpu/gpu_authority_grant.js";
@@ -45,23 +43,13 @@ import {
 
 /**
  * @typedef {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} AnimationCurve
+ * @typedef {import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter} GPURecordWriter
  * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
  * @typedef {import("../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("./ShadeAnimationClip.js").ShadeAnimationClip} ShadeAnimationClip
  * @typedef {import("./Skin.js").Skin} Skin
  */
 
-/**
- * Tail-slot placeholders for the fixed-size inline arrays in chain
- * nodes. The shader's `count` guard means these bytes are never read,
- * but the upload buffer doesn't zero unwritten ranges and
- * `write_struct_value` skips undefined fields — so explicit zeros are
- * the only way to keep tail bytes deterministic. Frozen so a stray
- * mutation can't bleed into multiple slots that share the reference.
- */
-const ZERO_KEYFRAME = Object.freeze({ time: 0, value: 0, inTangent: 0, outTangent: 0 });
-const ZERO_BINDING = Object.freeze({ track: 0, instance: 0, property: 0 });
-
 /**
  * Scratch for seeding a released joint's offset — see {@link GPUAnimationManager#release_targets}.
  *
@@ -78,17 +66,50 @@ const SEED = new Transform64();
 const SEED_PLAYBACK = { clip: null, time: 0, weight: 1 };
 
 const SEED_PLAYBACKS = [SEED_PLAYBACK];
-// Object.freeze on a typed array with elements throws under V8
-// ("Cannot freeze array buffer views with elements"), so we leave the
-// Float32Array unfrozen — the surrounding placeholder object is still
-// frozen to keep accidental field-level mutation out of bounds.
-const ZERO_INVERSE_BIND = new Float32Array(16);
-const ZERO_SKIN_JOINT = Object.freeze({ node: 0, inverse_bind: ZERO_INVERSE_BIND });
+
+/*
+ Generated writers for the rows a registration adds as a run. Through `add_run` every row is a
+ reflective walk of its type, and a run is one row per keyframe, binding or joint where a chain
+ block used to hold eight: a 60-joint skin measured 1.7x the cost of the chain it replaced until
+ its joints went through a writer.
+*/
+
+const KEYFRAME_WRITER = generate_record_writer(ANIMATION_CURVE_KEYFRAME_STRUCT);
+const BINDING_WRITER = generate_record_writer(ANIMATION_TRACK_BINDING_STRUCT);
+const SKIN_JOINT_WRITER = generate_record_writer(ANIMATION_SKIN_JOINT_STRUCT);
+
+/*
+ Writers for the fields of a clip that change after registration, each owning only its own words.
+ A playing clip's time is the GPU's — the tick advances it in the database buffer, and the CPU's
+ copy of the record never hears of it — so a mutator uploads the words it changes and nothing
+ else: a whole record would put the CPU's stale time back over the GPU's.
+*/
+
+const CLIP_TIME_WRITER = generate_record_writer(ANIMATION_CLIP_STATE_STRUCT, ['time']);
+const CLIP_PLAYBACK_RATE_WRITER = generate_record_writer(ANIMATION_CLIP_STATE_STRUCT, ['playback_rate']);
+const CLIP_PLAYBACK_WEIGHT_WRITER = generate_record_writer(ANIMATION_CLIP_STATE_STRUCT, ['playback_weight']);
+const CLIP_FLAGS_WRITER = generate_record_writer(ANIMATION_CLIP_STATE_STRUCT, ['flags']);
+const CLIP_BINDINGS_WRITER = generate_record_writer(ANIMATION_CLIP_STATE_STRUCT, ['bindings_first', 'bindings_count']);
+
+/**
+ * Word of a clip record holding its flags — read back to set or clear a bit of them.
+ */
+const CLIP_FLAGS_WORD = ANIMATION_CLIP_STATE_STRUCT.get('flags').offset / 4;
+
+/**
+ * Word of a skin record holding its first joint row — where its matrices start.
+ */
+const SKIN_JOINTS_FIRST_WORD = ANIMATION_SKIN_STRUCT.get('joints_first').offset / 4;
+
+/**
+ * A joint's `node` alone — what naming a pending skin's nodes writes, and all it uploads.
+ */
+const SKIN_JOINT_NODE_WRITER = generate_record_writer(ANIMATION_SKIN_JOINT_STRUCT, ['node']);
 
 /**
  * One skinning matrix is a `mat4x4f` — 16 f32s, 64 bytes. The
- * `skin_matrices` scratch buffer holds one entry per (skin, joint) pair
- * across every registered skin.
+ * `skin_matrices` scratch buffer holds one entry per row of
+ * `animation_skin_joints`, at the joint's row.
  */
 const SKIN_MATRIX_BYTES = 64;
 
@@ -120,57 +141,21 @@ const POSE_ACCUMULATOR_INITIAL_CAPACITY = 256;
  */
 const MAX_DT_SECONDS = 1 / 15;
 
-/**
- * Allocate a singly-linked chain of fixed-capacity nodes into `table`,
- * one node per `items_per_chunk`-sized window of `items`. Builds
- * tail-first so each node's successor id is known at `add()` time —
- * the alternative (forward + back-patch) would mean a second `set()`
- * per node.
- *
- * `build_node(start, count, next_id)` constructs the record to add: it
- * populates the inline array from `items[start..start+count]`, pads
- * tail slots, and assembles any extra payload the table expects
- * (including embedding `next_id` as the node's `next` field).
- *
- * Returns the head id (the last `add()`'s slot id), or `0xFFFFFFFF` if
- * `items` is empty.
- *
- * @template T
- * @template R
- * @param {{ add: (record: R) => number }} table
- * @param {T[]} items
- * @param {number} items_per_chunk
- * @param {(start: number, count: number, next_id: number) => R} build_node
- * @returns {number}
- */
-function add_linked_chain(table, items, items_per_chunk, build_node) {
-    const node_count = Math.ceil(items.length / items_per_chunk);
-    let next_id = 0xFFFFFFFF;
-
-    for (let n = node_count - 1; n >= 0; n--) {
-        const start = n * items_per_chunk;
-        const this_count = Math.min(items_per_chunk, items.length - start);
-        next_id = table.add(build_node(start, this_count, next_id));
-    }
-
-    return next_id;
-}
-
 /**
  * Top-level coordinator for GPU-resident animation.
  *
  * Owns a single {@link GPUDatabase} keyed by {@link ANIMATION_DATABASE_SPEC}
- * with five tables: `animation_curves`, `animation_keyframe_blocks`,
- * `animation_tracks`, `animation_clips`, `animation_bound_track_groups`.
- * Every record — including individual keyframes (inlined inside block
- * nodes) and individual bindings (inlined inside group nodes) — lives in
+ * with its tables: `animation_curves`, `animation_keyframes`,
+ * `animation_tracks`, `animation_clips`, `animation_bindings`,
+ * `animation_skins` and `animation_skin_joints`.
+ * Every record — including individual keyframes (a run of rows per
+ * curve) and individual bindings (a run of rows per clip) — lives in
  * the database, so the dispatch shader needs only one storage binding.
  *
  * Animation *data* (curves, keyframes, tracks) is independent from
- * *bound clips* (each carrying a `time` and a head pointer to its
- * bound-track group chain). Bindings are no longer their own table:
- * each chain node inlines up to {@link TRACKS_PER_GROUP_NODE} bindings
- * and back-references its owning clip.
+ * *bound clips* (each carrying a `time` and the run of its bindings).
+ * Each binding row names its clip, so the apply pass, one thread per
+ * binding, finds the clip's time from the binding alone.
  *
  * Usage:
  *  1. (Once at setup) Either low-level (`add_curve`, `add_track`,
@@ -215,8 +200,8 @@ export class GPUAnimationManager {
      *
      * Lazily allocated on first {@link add_skin}; both grow together
      * by doubling. After a grow both buffers are zero-initialised and
-     * {@link #first_frame_skin_matrices} is set so the next prep
-     * dispatch seeds the "previous" buffer with a copy of the freshly
+     * {@link #skin_matrix_seed_all} is set so the next prep dispatch
+     * seeds all of the "previous" buffer with a copy of the freshly
      * written "current" — without this, the first velocity readback
      * after a grow would interpolate against zero matrices.
      *
@@ -232,14 +217,31 @@ export class GPUAnimationManager {
     #skin_matrices_current_index = 0;
 
     /**
-     * When true, the next prep dispatch will copy the freshly-written
-     * "current" buffer into the "previous" buffer at the end of the
-     * pass — used on first allocation and after every grow so the
-     * very first velocity computation has matching prev/current
-     * matrices (zero velocity).
+     * The runs of matrix rows the next prep dispatch seeds "previous" from "current" over, each
+     * `[first_row, count]`: a run handed out, and a pending skin's run whose joints were just
+     * named. The frame before either is not a pose — "previous" over those rows holds zeros, or
+     * the last pose of a skin that had them — so the first velocity read over them has to see
+     * matching matrices, which is zero velocity.
+     *
+     * Only those rows: a settled skin's rows of "previous" hold its pose last frame, which is what
+     * its motion is measured from.
+     *
+     * A skin given back takes its queued runs with it ({@link unregister_skin}), so every run here
+     * belongs to a skin still registered and not yet seeded — however long no prep runs, as while
+     * a loading screen draws nothing and the game goes on spawning.
+     *
+     * @type {Array<[number, number]>}
+     */
+    #skin_matrix_seed_runs = [];
+
+    /**
+     * When true, the next prep dispatch seeds all of "previous" from "current", whatever
+     * {@link #skin_matrix_seed_runs} holds. Set when the buffers grow: both are made again,
+     * zeroed, so no row has a last frame left to keep.
+     *
      * @type {boolean}
      */
-    #first_frame_skin_matrices = true;
+    #skin_matrix_seed_all = false;
 
     /**
      * Capacity of each of {@link #skin_matrices_buffers} in matrices
@@ -249,56 +251,13 @@ export class GPUAnimationManager {
     #skin_matrices_capacity = 0;
 
     /**
-     * High-water mark of the matrix range: the first index no skin has ever been given.
-     * A skin that cannot be served from {@link #free_skin_matrix_ranges} takes
-     * `joint_count` consecutive entries starting here, and this advances past them.
-     *
-     * Monotonic, but no longer the whole allocator — a range given back is reused before
-     * this advances again, so it tracks peak concurrent joints rather than total
-     * registrations.
+     * One past the highest joint row any skin has been given — how many matrices the buffers have
+     * to address, since a joint's matrix sits at its row. Only grows: first fit hands the rows a
+     * skin gave back to any skin they fit before it reaches past the end.
      *
      * @type {number}
      */
-    #next_skin_matrix_offset = 0;
-
-    /**
-     * CPU-side `skin_id → skin_matrix_offset` map. Each registered
-     * skin's base address in the shared `skin_matrices` scratch
-     * buffer; the per-block absolute offset (the prep shader's hot
-     * path) is derived as `base + chain_position *
-     * JOINTS_PER_SKIN_BLOCK` at registration. Storing the base on
-     * GPU would duplicate it — the block records already carry the
-     * per-block absolute address, and only the CPU (the skinning-
-     * binding upload path) needs the skin's base value.
-     *
-     * @type {Map<number, number>}
-     */
-    #skin_matrix_offsets = new Map();
-
-    /**
-     * Matrix ranges handed back by {@link unregister_skin}, bucketed by their length in
-     * matrices. Each bucket is a stack of base indices free to give out again.
-     *
-     * A range's base is baked into its skin's joint-block rows on the GPU, so a range can
-     * never be *moved* once handed out — which is what made compaction hard enough to skip,
-     * and left the offset a bump pointer with no way back. Reuse needs no movement: the hole
-     * a despawned character leaves is exactly the size of the next character wearing that
-     * rig, so matching a request to a hole of the same length hands the range straight back
-     * with nothing relocated and nothing to patch.
-     *
-     * Bucketed by length because the match has to be **exact**. The prep pass writes
-     * `base + joint` for `joint` in `[0, joint_count)`, so a skin placed in a shorter hole
-     * would write over whatever lives after it. Splitting a longer hole would fit, but every
-     * split leaves a fragment only an exactly-as-small skin can ever use; a game's rigs come
-     * in a handful of joint counts, so exact buckets stay few and nearly always hit.
-     *
-     * What this does not reclaim is bounded by the number of distinct joint counts ever
-     * registered rather than by the number of registrations: a rig retired for good leaves
-     * its ranges behind, a rig still in use passes the same ranges around forever.
-     *
-     * @type {Map<number, number[]>}
-     */
-    #free_skin_matrix_ranges = new Map();
+    #skin_matrix_count = 0;
 
     /**
      * How many bound clips drive each entity, by entity. An entity's local TRS is the GPU's for
@@ -371,9 +330,9 @@ export class GPUAnimationManager {
      * {@link register_clip}. Lets multiple clips whose channels share
      * the same curve instance (e.g. one base clip retargeted across
      * many character instances) reuse the same GPU rows for the
-     * curve header + keyframe blocks rather than uploading
+     * curve header + keyframes rather than uploading
      * duplicates. At grid-of-dancers scale duplication would balloon
-     * the keyframe-blocks table past its page-table limits.
+     * the keyframes table past its page-table limits.
      *
      * Low-level `add_curve` deliberately stays uncached — every call
      * uploads — so existing callers that pre-build curves with
@@ -390,7 +349,7 @@ export class GPUAnimationManager {
      *
      * An instance cache alone shares nothing between two parses of one file, and a character
      * instanced a few hundred times is a few hundred parses — each with its own instances of the
-     * same keys, filling the keyframe-block table with copies of one dance until its page limit
+     * same keys, filling the keyframes table with copies of one dance until its page limit
      * refuses the next dancer. Curves are read-only once uploaded and nothing here releases them,
      * so equal content can safely mean one upload.
      *
@@ -418,35 +377,32 @@ export class GPUAnimationManager {
     #track_id_cache = new Map();
 
     /**
-     * Skins registered via {@link register_skin} whose joint-block
-     * chain hasn't been built yet because one or more joint entities
-     * has not taken its row yet. The skin's GPU table row exists
-     * (placeholder `joint_block_head = NULL`, no joints driving the
-     * prep pass yet), and state mutators / unregister already work
-     * — but the deformation only kicks in once {@link update}
-     * successfully drains the entry.
-     *
-     * Each entry: `skin_id`, the CPU {@link Skin} (whose `joints`
-     * array drives the chain build), the `skin_matrix_offset`
-     * reserved at register time, and the `inverse_bind_matrices`
-     * typed array.
+     * Skins registered via {@link register_skin} whose joints name no node yet, because at least
+     * one joint entity has not taken its row. The skin's record and its run of joints exist — each
+     * joint with its inverse bind and a NULL node, which the prep pass skips — so the id, the
+     * matrix offset and {@link unregister_skin} work from the start. The skin's meshes are bound
+     * to it only when {@link update} names the nodes: until then its matrices are not written,
+     * and a mesh deformed by them would read zeros or another skin's last pose.
+     *
+     * Each entry: `skin_id`; the CPU {@link Skin}, whose `joints` are the entities whose rows
+     * become the nodes and whose `meshes` are bound then; `joints_first`, the first row of the
+     * skin's joints; and `joint_count`, how many rows the run has.
      *
      * @type {Array<{
      *     skin_id: number,
      *     skin: Skin,
-     *     skin_matrix_offset: number,
-     *     inverse_bind_matrices: Float32Array,
+     *     joints_first: number,
+     *     joint_count: number,
      * }>}
      */
     #pending_skins = [];
 
     /**
      * Clips registered via {@link register_clip} whose bindings
-     * chain hasn't been built yet because one or more channel
+     * haven't been added yet because one or more channel
      * targets has not taken its row yet. The clip's GPU table row
-     * exists (placeholder `bound_track_group_head = NULL`, no
-     * tracks driving the apply pass yet); time/state mutators and
-     * unregister already work.
+     * exists (an empty range, no bindings driving the apply pass
+     * yet); time/state mutators and unregister already work.
      *
      * Each entry: `clip_id` plus the per-channel `(track_id,
      * target, property)` triples — the curves and tracks were
@@ -491,8 +447,8 @@ export class GPUAnimationManager {
      * Per-frame skinning-matrix scratch buffer for the *current*
      * frame. `null` until the first skin is registered. The
      * skin-matrix-prep pass writes to it; the skinning compute pass
-     * reads from it to deform current-frame positions. Address `j`
-     * of skin `s` is at matrix index `s.skin_matrix_offset + j`.
+     * reads from it to deform current-frame positions. Joint `j` of
+     * skin `s` is at matrix index `s.joints_first + j` — the joint's row.
      *
      * The buffer reference is invalidated on grow AND flips role
      * every frame as part of the ping-pong with
@@ -520,17 +476,16 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Matrices the buffer has to address: the high-water mark, which covers every registered
-     * skin plus any range sitting on the free list between the ones still in use. Independent
-     * of buffer capacity, which is at least this big.
+     * Matrices the buffer has to address: one past the highest joint row any skin has been
+     * given. Independent of buffer capacity, which is at least this big.
      *
-     * Not a count of live joints — a skin that unregisters leaves its range addressable for
-     * the next skin of its size, so this falls only when nothing has been registered yet.
+     * Not a count of live joints — rows a skin gives back stay addressable for the next skin
+     * that fits in them, so this never falls.
      *
      * @returns {number}
      */
     get skin_matrix_count() {
-        return this.#next_skin_matrix_offset;
+        return this.#skin_matrix_count;
     }
 
     /**
@@ -594,7 +549,7 @@ export class GPUAnimationManager {
      * Read back a skin's record from the database's CPU shadow.
      *
      * @param {number} skin_id
-     * @returns {{joint_block_head: number, joint_count: number}}
+     * @returns {{joints_first: number, joint_count: number}}
      */
     get_skin(skin_id) {
         assert.isNonNegativeInteger(skin_id, 'skin_id');
@@ -602,30 +557,32 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Base address of the skin's matrix range in the shared
+     * Base address of the skin's matrices in the shared
      * `skin_matrices` scratch buffer — matrix `j` of the skin lives
-     * at `skin_matrices[get_skin_matrix_offset(skin_id) + j]`.
+     * at `skin_matrices[get_skin_matrix_offset(skin_id) + j]`. A joint's
+     * matrix sits at the joint's row, so this is the skin's first joint
+     * row, read from its record — one word of it, not the record.
      *
-     * Tracked CPU-side rather than on the skin record because the
-     * value is only ever consumed by the skinning-binding upload
-     * path; the prep shader uses the per-block absolute offset
-     * (cheaper than a per-thread skin lookup for that hot path).
+     * A run never moves once handed out, so the offset holds for as long
+     * as the skin is registered; the skinning context reads it only when
+     * its bindings change.
      *
      * @param {number} skin_id
      * @returns {number}
      */
     get_skin_matrix_offset(skin_id) {
         assert.isNonNegativeInteger(skin_id, 'skin_id');
-        const offset = this.#skin_matrix_offsets.get(skin_id);
-        assert.defined(offset, `unknown skin_id ${skin_id}`);
-        return offset;
+
+        const joints_first = this.#database.get('animation_skins').get_word(skin_id, SKIN_JOINTS_FIRST_WORD);
+
+        assert.defined(joints_first, `unknown skin_id ${skin_id}`);
+
+        return joints_first;
     }
 
     /**
-     * Add an animation curve. Keyframes are split into linked-list blocks
-     * of up to {@link KEYFRAMES_PER_BLOCK} entries each; the curve header
-     * points at the head block, and each block's `next` field chains
-     * forward.
+     * Add an animation curve. Its keyframes go into `animation_keyframes` as one run of rows, in
+     * order, and the curve's header names the run.
      *
      * The curve is a cubic Hermite spline — step, linear, and arbitrary
      * cubic shapes are all expressible by choosing tangents on each keyframe.
@@ -639,25 +596,13 @@ export class GPUAnimationManager {
         assert.greaterThanOrEqual(curve.length, 1, 'curve must have at least one keyframe');
 
         const keys = curve.keys;
-        const blocks_table = this.#database.get('animation_keyframe_blocks');
-
-        const head_block_id = add_linked_chain(
-            blocks_table,
-            keys,
-            KEYFRAMES_PER_BLOCK,
-            (start, count, next) => {
-                const keyframes = new Array(KEYFRAMES_PER_BLOCK);
-                for (let j = 0; j < KEYFRAMES_PER_BLOCK; j++) {
-                    keyframes[j] = j < count ? keys[start + j] : ZERO_KEYFRAME;
-                }
-                return { keyframes, count, next };
-            }
-        );
+
+        const keyframes_first = this.#database.get('animation_keyframes').add_run_records(keys, KEYFRAME_WRITER);
 
         const curves_table = this.#database.get('animation_curves');
         return curves_table.add({
             kind: 0,
-            keyframe_block_head: head_block_id,
+            keyframes_first,
             keyframe_count: keys.length,
             time_min: curve.start_time,
             time_max: curve.end_time,
@@ -695,11 +640,12 @@ export class GPUAnimationManager {
 
         assert.notEqual(mask, 0, 'track must have at least one channel');
 
+        // a lane with its mask bit clear names no curve
         const curves = [
-            cx ?? 0,
-            cy ?? 0,
-            cz ?? 0,
-            cw ?? 0,
+            cx ?? GPU_DATABASE_NULL,
+            cy ?? GPU_DATABASE_NULL,
+            cz ?? GPU_DATABASE_NULL,
+            cw ?? GPU_DATABASE_NULL,
         ];
 
         const table = this.#database.get('animation_tracks');
@@ -708,11 +654,9 @@ export class GPUAnimationManager {
 
     /**
      * Create a bound clip — a group of bound tracks that share a single
-     * `time`. Bindings are split into linked-list group nodes of up to
-     * {@link TRACKS_PER_GROUP_NODE} each; the clip points at the head
-     * node and each node back-references the clip so the apply shader
-     * (one thread per group node) can fetch the clip without walking the
-     * chain from the clip end.
+     * `time`. The bindings go into `animation_bindings` as one run of
+     * rows, each naming the clip, so the apply shader (one thread per
+     * binding) fetches the clip's time from the binding alone.
      *
      * Tracks may be authored on a clock that doesn't align with
      * `[time_start, time_end]` — their curves are clamped to their own
@@ -741,90 +685,62 @@ export class GPUAnimationManager {
         const time_end = clip.time_end ?? 0;
         const bindings = clip.bindings;
 
-        const clips_table = this.#database.get('animation_clips');
-        const groups_table = this.#database.get('animation_bound_track_groups');
-
-        // Reserve the clip slot up front so group nodes can back-reference
-        // it via `clip`. The head pointer is patched in once the chain is
-        // built (we don't know its first id until we've allocated every
-        // group node).
-        const clip_id = clips_table.add({
+        // Reserve the clip row first, so every binding can name it. The range is filled in once
+        // the run exists.
+        const clip_id = this.#database.get('animation_clips').add({
             time,
             time_start,
             time_end,
-            bound_track_group_head: ANIMATION_BOUND_TRACK_GROUP_NULL,
+            bindings_first: GPU_DATABASE_NULL,
+            bindings_count: 0,
             playback_rate: 1,
             flags: 0,
             playback_weight: 1,
         });
 
-        const head_group_id = add_linked_chain(
-            groups_table,
-            bindings,
-            TRACKS_PER_GROUP_NODE,
-            (start, count, next) => {
-                const inline_bindings = new Array(TRACKS_PER_GROUP_NODE);
-                for (let j = 0; j < TRACKS_PER_GROUP_NODE; j++) {
-                    if (j < count) {
-                        const b = bindings[start + j];
-
-                        assert.isNonNegativeInteger(b.track, `clip.bindings[${start + j}].track`);
-                        assert.isNonNegativeInteger(b.instance, `clip.bindings[${start + j}].instance`);
-                        assert.isNonNegativeInteger(b.property, `clip.bindings[${start + j}].property`);
-
-                        inline_bindings[j] = b;
-                    } else {
-                        inline_bindings[j] = ZERO_BINDING;
-                    }
-                }
-                return { bindings: inline_bindings, count, next, clip: clip_id };
-            }
-        );
+        const rows = new Array(bindings.length);
 
-        // Patch the head pointer now that the chain exists. Re-`set` the
-        // whole record because the table API doesn't expose per-field
-        // updates.
-        clips_table.set(clip_id, {
-            time,
-            time_start,
-            time_end,
-            bound_track_group_head: head_group_id,
-            playback_rate: 1,
-            flags: 0,
-            playback_weight: 1,
-        });
+        for (let i = 0; i < bindings.length; i++) {
+            const b = bindings[i];
+
+            assert.isNonNegativeInteger(b.track, `clip.bindings[${i}].track`);
+            assert.isNonNegativeInteger(b.instance, `clip.bindings[${i}].instance`);
+            assert.isNonNegativeInteger(b.property, `clip.bindings[${i}].property`);
+
+            rows[i] = { track: b.track, instance: b.instance, property: b.property, clip: clip_id };
+        }
+
+        const bindings_first = this.#database.get('animation_bindings').add_run_records(rows, BINDING_WRITER);
+
+        this.#write_clip(clip_id, { bindings_first, bindings_count: rows.length }, CLIP_BINDINGS_WRITER);
 
         return clip_id;
     }
 
     /**
-     * Overwrite a single field of a clip's record by reading the current
-     * record back from the CPU shadow and re-`set`ting with one field
-     * changed. The table API doesn't expose per-field updates, so we
-     * round-trip through a full record; the upload-buffer dedupe
-     * collapses the resulting per-frame write into a single GPU touch
-     * when nothing else changed.
+     * Write the fields of a clip's record that `writer` owns, on the CPU shadow and on the GPU, and
+     * nothing else: the rest of the record — a playing clip's `time` above all, which the GPU tick
+     * advances where the shadow never sees it — stays as the GPU has it.
      *
      * @param {number} clip_id
-     * @param {string} field
-     * @param {number} value
+     * @param {Object<string, number>} value the fields the writer owns
+     * @param {GPURecordWriter} writer one of the clip field writers above
      */
-    #patch_clip_field(clip_id, field, value) {
+    #write_clip(clip_id, value, writer) {
         assert.isNonNegativeInteger(clip_id, 'clip_id');
 
-        const clips_table = this.#database.get('animation_clips');
-        const current = clips_table.get(clip_id);
-
-        clips_table.set(clip_id, {
-            time: current.time,
-            time_start: current.time_start,
-            time_end: current.time_end,
-            bound_track_group_head: current.bound_track_group_head,
-            playback_rate: current.playback_rate,
-            flags: current.flags,
-            playback_weight: current.playback_weight,
-            [field]: value,
-        });
+        this.#database.get('animation_clips').set_fields(clip_id, value, writer);
+    }
+
+    /**
+     * A clip's flags as the CPU last wrote them. Only the host changes them, so the shadow's are the
+     * GPU's.
+     *
+     * @param {number} clip_id
+     * @returns {number}
+     */
+    #clip_flags(clip_id) {
+        return this.#database.get('animation_clips').get_word(clip_id, CLIP_FLAGS_WORD);
     }
 
     /**
@@ -847,7 +763,7 @@ export class GPUAnimationManager {
      */
     set_time(clip_id, time) {
         assert.isNumber(time, 'time');
-        this.#patch_clip_field(clip_id, 'time', time);
+        this.#write_clip(clip_id, { time }, CLIP_TIME_WRITER);
 
         const shadow = this.#playback_by_clip.get(clip_id);
 
@@ -867,7 +783,7 @@ export class GPUAnimationManager {
      */
     set_playback_rate(clip_id, rate) {
         assert.isNumber(rate, 'rate');
-        this.#patch_clip_field(clip_id, 'playback_rate', rate);
+        this.#write_clip(clip_id, { playback_rate: rate }, CLIP_PLAYBACK_RATE_WRITER);
     }
 
     /**
@@ -887,7 +803,7 @@ export class GPUAnimationManager {
      */
     set_playback_weight(clip_id, weight) {
         assert.isNumber(weight, 'weight');
-        this.#patch_clip_field(clip_id, 'playback_weight', weight);
+        this.#write_clip(clip_id, { playback_weight: weight }, CLIP_PLAYBACK_WEIGHT_WRITER);
 
         const shadow = this.#playback_by_clip.get(clip_id);
 
@@ -916,10 +832,7 @@ export class GPUAnimationManager {
     set_flags(clip_id, flags) {
         assert.isNonNegativeInteger(flags, 'flags');
 
-        const clips_table = this.#database.get('animation_clips');
-        const current = clips_table.get(clip_id);
-
-        this.#patch_clip_field(clip_id, 'flags', current.flags | flags);
+        this.#write_clip(clip_id, { flags: this.#clip_flags(clip_id) | flags }, CLIP_FLAGS_WRITER);
     }
 
     /**
@@ -933,10 +846,7 @@ export class GPUAnimationManager {
     clear_flags(clip_id, flags) {
         assert.isNonNegativeInteger(flags, 'flags');
 
-        const clips_table = this.#database.get('animation_clips');
-        const current = clips_table.get(clip_id);
-
-        this.#patch_clip_field(clip_id, 'flags', current.flags & ~flags);
+        this.#write_clip(clip_id, { flags: this.#clip_flags(clip_id) & ~flags }, CLIP_FLAGS_WRITER);
     }
 
     /**
@@ -954,10 +864,7 @@ export class GPUAnimationManager {
     start(clip_id) {
         assert.isNonNegativeInteger(clip_id, 'clip_id');
 
-        const clips_table = this.#database.get('animation_clips');
-        const current = clips_table.get(clip_id);
-
-        this.#patch_clip_field(clip_id, 'flags', current.flags | AnimationClipFlags.Playing);
+        this.#write_clip(clip_id, { flags: this.#clip_flags(clip_id) | AnimationClipFlags.Playing }, CLIP_FLAGS_WRITER);
     }
 
     /**
@@ -973,20 +880,18 @@ export class GPUAnimationManager {
     stop(clip_id) {
         assert.isNonNegativeInteger(clip_id, 'clip_id');
 
-        const clips_table = this.#database.get('animation_clips');
-        const current = clips_table.get(clip_id);
-
-        this.#patch_clip_field(clip_id, 'flags', current.flags & ~AnimationClipFlags.Playing);
+        this.#write_clip(clip_id, { flags: this.#clip_flags(clip_id) & ~AnimationClipFlags.Playing }, CLIP_FLAGS_WRITER);
     }
 
     /**
      * Register a skin: an ordered list of joints, each pinning a
      * Node3D row that drives the joint plus the inverse-bind matrix
      * that takes vertex positions from mesh space into the joint's
-     * bind-pose local space. The skin reserves a contiguous range of
-     * `joints.length` matrices in the {@link #skin_matrices_buffer}
-     * scratch buffer; the prep pass populates that range each frame
-     * with `node.global × inverse_bind` for every joint.
+     * bind-pose local space. The joints go into `animation_skin_joints`
+     * as one run of rows, and a joint's matrix in the
+     * {@link #skin_matrices_buffer} scratch buffer sits at its row — so the
+     * skin's matrices are the same run of the buffer, which the prep pass
+     * fills each frame with `node.global × inverse_bind` for every joint.
      *
      * The skin record carries no mesh-world factor. The rasterizer
      * applies `mesh.transform_global` to the skinned clone vertex
@@ -996,13 +901,6 @@ export class GPUAnimationManager {
      * double-cancel against that re-application and shrink the rig
      * back to mesh-local coordinates rendered as world.
      *
-     * Joints are split into linked-list blocks of up to
-     * {@link JOINTS_PER_SKIN_BLOCK} each — same chain pattern used for
-     * bound-track groups and keyframe blocks. Each block records the
-     * absolute write offset for its slots, so the prep shader's
-     * per-thread work is one block load + a bounded inner loop with no
-     * indirection back through the skin record.
-     *
      * @param {{
      *     joints: Array<{ node: number, inverse_bind: Float32Array | number[] }>,
      * }} skin
@@ -1014,64 +912,21 @@ export class GPUAnimationManager {
         assert.greaterThanOrEqual(skin.joints.length, 1, 'skin must have at least one joint');
 
         const joints = skin.joints;
-        const joint_count = joints.length;
 
-        // Reserve the matrix range. Each block bakes in its absolute
-        // slot offset (skin_base + chain_position * JOINTS_PER_SKIN_BLOCK)
-        // so the prep shader writes directly without dereferencing
-        // the skin row for the offset; the base is also stashed on
-        // the CPU map so the skinning-binding upload can look it up
-        // without reading the GPU back.
-        const skin_matrix_offset = this.#allocate_skin_matrix_range(joint_count);
+        for (let i = 0; i < joints.length; i++) {
+            // named now: a joint whose node comes later is register_skin's, which binds no mesh
+            // until it has come
+            assert.isNonNegativeInteger(joints[i].node, `skin.joints[${i}].node`);
+            assert.notEqual(joints[i].node, GPU_DATABASE_NULL, `skin.joints[${i}].node`);
+            assert.defined(joints[i].inverse_bind, `skin.joints[${i}].inverse_bind`);
+        }
 
-        const skins_table = this.#database.get('animation_skins');
-        const blocks_table = this.#database.get('animation_skin_joint_blocks');
-
-        // Reserve the skin row up front. The head pointer is patched
-        // in once the chain exists. NULL placeholder — 0 is a valid
-        // block row id (the first allocation in an empty table).
-        const skin_id = skins_table.add({
-            joint_block_head: ANIMATION_SKIN_JOINT_BLOCK_NULL,
-            joint_count,
-        });
-        this.#skin_matrix_offsets.set(skin_id, skin_matrix_offset);
-
-        const head_block_id = add_linked_chain(
-            blocks_table,
-            joints,
-            JOINTS_PER_SKIN_BLOCK,
-            (start, count, next) => {
-                const inline_joints = new Array(JOINTS_PER_SKIN_BLOCK);
-                for (let j = 0; j < JOINTS_PER_SKIN_BLOCK; j++) {
-                    if (j < count) {
-                        const joint = joints[start + j];
-
-                        assert.isNonNegativeInteger(joint.node, `skin.joints[${start + j}].node`);
-                        assert.defined(joint.inverse_bind, `skin.joints[${start + j}].inverse_bind`);
-
-                        inline_joints[j] = joint;
-                    } else {
-                        inline_joints[j] = ZERO_SKIN_JOINT;
-                    }
-                }
-                return {
-                    joints: inline_joints,
-                    count,
-                    next,
-                    skin_matrix_offset: skin_matrix_offset + start,
-                };
-            }
-        );
+        const joints_first = this.#add_joints(joints);
 
-        // Patch the head pointer now that the chain exists. Re-`set`
-        // the whole record because the table API doesn't expose
-        // per-field updates.
-        skins_table.set(skin_id, {
-            joint_block_head: head_block_id,
-            joint_count,
+        return this.#database.get('animation_skins').add({
+            joints_first,
+            joint_count: joints.length,
         });
-
-        return skin_id;
     }
 
     /**
@@ -1079,12 +934,12 @@ export class GPUAnimationManager {
      * **entities**, allocates a GPU skin record, and binds every mesh entity through the
      * skinning context.
      *
-     * **Eventual consistency.** The `skin_id` is allocated and returned synchronously — callers
-     * can immediately pass it to state mutators or {@link unregister_skin}. If any joint has not
-     * taken its row yet (see `GPUSceneRows.acquire`), the joint-block chain that drives the
-     * deformation is queued and built on the next {@link update} that sees every joint there.
-     * The skin's table row uses a placeholder `joint_block_head` until then — observationally
-     * indistinguishable from "skin with no joints driving it" (no deformation runs).
+     * **Eventual consistency.** The `skin_id` is allocated and returned synchronously, and the
+     * skin's joints take their rows at once, so {@link get_skin_matrix_offset} and
+     * {@link unregister_skin} work from here on. If any joint's entity has not taken its
+     * transforms row yet (see `GPUSceneRows.acquire`), the joints name no node, and the meshes
+     * are not bound, until the next {@link update} that sees every joint there. Until then the
+     * skin's matrices are not written, and its meshes draw undeformed, as they were modelled.
      *
      * The frame a skin's meshes are deformed in is the prefab's business, fixed once at compile
      * (`prefab_normalize_skin_frames`); nothing about it is decided here.
@@ -1095,128 +950,129 @@ export class GPUAnimationManager {
     register_skin(skin) {
         assert.defined(skin, 'skin');
         assert.equal(skin.isSkin, true, 'skin.isSkin !== true');
+        assert.greaterThanOrEqual(skin.joints.length, 1, 'skin must have at least one joint');
         assert.greaterThanOrEqual(skin.meshes.length, 1, 'skin.meshes must contain at least one mesh');
 
+        for (let i = 0; i < skin.meshes.length; i++) {
+            assert.isNonNegativeInteger(skin.meshes[i], `skin.meshes[${i}]`);
+        }
+
+        const complete = this.#joint_rows_ready(skin);
+
+        // The joints take their rows now, named nodes and all if every joint is there already.
+        const joints_first = this.#add_joints(this.#skin_joints(skin, complete));
         const joint_count = skin.joints.length;
-        const inverse_bind_matrices = skin.inverse_bind_matrices;
 
-        // Reserve the matrix range up front — block records carry
-        // their absolute slot offset, so the prep shader writes
-        // directly. The base also lands on #skin_matrix_offsets so
-        // skinning-binding upload can look it up.
-        const skin_matrix_offset = this.#allocate_skin_matrix_range(joint_count);
-
-        // Reserve the skin row immediately with a placeholder head
-        // pointer. State mutators and the public id are usable from
-        // this point on; the joint chain gets patched in once
-        // every joint has its row (possibly synchronously below,
-        // possibly deferred via the pending queue).
-        const skins_table = this.#database.get('animation_skins');
-        const skin_id = skins_table.add({
-            // NULL placeholder — 0 is a valid block row id
-            joint_block_head: ANIMATION_SKIN_JOINT_BLOCK_NULL,
-            joint_count,
-        });
-        this.#skin_matrix_offsets.set(skin_id, skin_matrix_offset);
+        const skin_id = this.#database.get('animation_skins').add({ joints_first, joint_count });
+
+        if (complete) {
+            this.#bind_meshes(skin, skin_id);
+        } else {
+            // the next update() that sees every joint's row names the nodes and binds the meshes
+            this.#pending_skins.push({ skin_id, skin, joints_first, joint_count });
+        }
 
-        // Bind every mesh entity into the skinning context. The clone a binding deforms is made
-        // when the entity's mesh row is written — before or after this — and the binding follows.
+        return skin_id;
+    }
+
+    /**
+     * Bind every mesh entity of `skin` into the skinning context. The clone a binding deforms is
+     * made when the entity's mesh row is written — before or after this — and the binding
+     * follows.
+     *
+     * @param {Skin} skin
+     * @param {number} skin_id
+     */
+    #bind_meshes(skin, skin_id) {
         const skinning = this.#scene_context.skinning;
         const meshes = skin.meshes;
-        for (let i = 0; i < meshes.length; i++) {
-            assert.isNonNegativeInteger(meshes[i], `skin.meshes[${i}]`);
 
+        for (let i = 0; i < meshes.length; i++) {
             skinning.bind(meshes[i], skin_id);
         }
-
-        // Try to complete now. If every joint has its row, the chain gets built and patched in.
-        // Otherwise the skin lands on #pending_skins and the next update() drain retries.
-        const pending = {
-            skin_id,
-            skin,
-            skin_matrix_offset,
-            inverse_bind_matrices,
-        };
-        if (!this.#try_complete_skin(pending)) {
-            this.#pending_skins.push(pending);
-        }
-
-        return skin_id;
     }
 
     /**
-     * Attempt to build the joint-block chain for a pending skin and
-     * patch its head pointer onto the skin row. Returns `true` when
-     * every joint entity holds its transforms row (and the chain was
-     * built); `false` when at least one joint has not taken it yet.
+     * Whether every joint entity of `skin` holds its transforms row. All or nothing: a skin
+     * whose joints were only partly named would deform with some of its matrices missing.
      *
-     * @param {{
-     *     skin_id: number,
-     *     skin: Skin,
-     *     skin_matrix_offset: number,
-     *     inverse_bind_matrices: Float32Array,
-     * }} pending
+     * @param {Skin} skin
      * @returns {boolean}
      */
-    #try_complete_skin(pending) {
+    #joint_rows_ready(skin) {
         const rows = this.#scene_context.rows;
-        const joint_nodes = pending.skin.joints;
-        const joint_count = joint_nodes.length;
-        const inverse_bind_matrices = pending.inverse_bind_matrices;
-        const skin_matrix_offset = pending.skin_matrix_offset;
-        const skin_id = pending.skin_id;
+        const joints = skin.joints;
 
-        // All-or-nothing: a single missing row leaves the chain
-        // unbuilt — partial chains aren't valid (the prep shader
-        // walks every block).
-        const joints = new Array(joint_count);
-        for (let i = 0; i < joint_count; i++) {
-            const joint = joint_nodes[i];
+        for (let i = 0; i < joints.length; i++) {
+            assert.isNonNegativeInteger(joints[i], `skin.joints[${i}]`);
 
-            assert.isNonNegativeInteger(joint, `skin.joints[${i}]`);
+            if (!rows.has(joints[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 
-            if (!rows.has(joint)) return false;
+    /**
+     * The joint records of `skin`: each joint's inverse bind, and its node — the joint entity's
+     * transforms row when `with_nodes`, {@link GPU_DATABASE_NULL} otherwise.
+     *
+     * @param {Skin} skin
+     * @param {boolean} with_nodes
+     * @returns {Array<{node: number, inverse_bind: Float32Array}>}
+     */
+    #skin_joints(skin, with_nodes) {
+        const entities = skin.joints;
+        const inverse_bind_matrices = skin.inverse_bind_matrices;
+        const joints = new Array(entities.length);
 
+        for (let i = 0; i < entities.length; i++) {
             joints[i] = {
-                node: row_of_entity(joint),
-                // Per-joint slice of the flat matrix array. The
-                // marshaller copies these bytes into the skin-joint
-                // block record; sub-array views are fine — they
-                // share the underlying buffer but write_struct_value
-                // reads by length, not by offset.
+                node: with_nodes ? row_of_entity(entities[i]) : GPU_DATABASE_NULL,
+                // Per-joint slice of the flat matrix array. Sub-array views are fine — they share
+                // the underlying buffer, but the marshaller reads by length, not by offset.
                 inverse_bind: inverse_bind_matrices.subarray(i * 16, (i + 1) * 16),
             };
         }
 
-        const blocks_table = this.#database.get('animation_skin_joint_blocks');
-        const head_block_id = add_linked_chain(
-            blocks_table,
-            joints,
-            JOINTS_PER_SKIN_BLOCK,
-            (start, count, next) => {
-                const inline_joints = new Array(JOINTS_PER_SKIN_BLOCK);
-                for (let j = 0; j < JOINTS_PER_SKIN_BLOCK; j++) {
-                    inline_joints[j] = j < count ? joints[start + j] : ZERO_SKIN_JOINT;
-                }
-                return {
-                    joints: inline_joints,
-                    count,
-                    next,
-                    skin_matrix_offset: skin_matrix_offset + start,
-                };
-            }
-        );
+        return joints;
+    }
 
-        // Patch the head pointer onto the already-allocated skin
-        // row. Read-modify-write so any other fields the user might
-        // have changed via mutators (none today, but future-proof)
-        // are preserved.
-        const skins_table = this.#database.get('animation_skins');
-        const current = skins_table.get(skin_id);
-        skins_table.set(skin_id, {
-            joint_block_head: head_block_id,
-            joint_count: current.joint_count,
-        });
+    /**
+     * Name the nodes of a pending skin's joints, once every joint entity holds its transforms row,
+     * and bind its meshes. Returns `true` when it did; `false` when at least one joint has not
+     * taken its row yet.
+     *
+     * Only each joint's `node` is written, and only that word is uploaded: the inverse bind went
+     * in at registration.
+     *
+     * @param {{skin_id: number, skin: Skin, joints_first: number, joint_count: number}} pending
+     * @returns {boolean}
+     */
+    #try_complete_skin(pending) {
+        const skin = pending.skin;
+
+        if (!this.#joint_rows_ready(skin)) {
+            return false;
+        }
+
+        const joints_table = this.#database.get('animation_skin_joints');
+        const entities = skin.joints;
+
+        // the run was cut to the skin as it registered; a joint added since has no row in it
+        assert.equal(entities.length, pending.joint_count, 'skin.joints changed after register_skin');
+
+        for (let i = 0; i < entities.length; i++) {
+            joints_table.set_fields(pending.joints_first + i, { node: row_of_entity(entities[i]) }, SKIN_JOINT_NODE_WRITER);
+        }
+
+        this.#bind_meshes(skin, pending.skin_id);
+
+        // The joints' matrices are written from the next prep on, and "previous" over their rows
+        // holds whatever was there before — zeros, or the last pose of a skin that had them — so
+        // it is seeded, as it is for a run just handed out.
+        this.#skin_matrix_seed_runs.push([pending.joints_first, pending.joint_count]);
 
         return true;
     }
@@ -1228,14 +1084,14 @@ export class GPUAnimationManager {
      * **Eventual consistency.** The `clip_id` is allocated and returned synchronously — callers
      * can immediately call {@link start} / {@link stop} / {@link set_time} / {@link set_playback_rate}
      * / {@link set_flags} / {@link clear_flags} / {@link set_playback_weight} /
-     * {@link unregister_clip}. If any target has not taken its row yet, the bindings chain that
-     * drives the apply pass is queued and built on the next {@link update} that sees every target
-     * there. The clip's table row uses a placeholder `bound_track_group_head` until then — apply
-     * produces no contributions, so the clip is observationally inert (still subject to time
-     * advancement via the tick shader if `Playing` is set).
-     *
-     * **Binding is what hands a target to the GPU.** When the chain is built, every entity it
-     * drives has its `GPUStateAuthority` TransformAttachment bit granted, so the CPU stops
+     * {@link unregister_clip}. If any target has not taken its row yet, the bindings that drive
+     * the apply pass are queued and added on the next {@link update} that sees every target there.
+     * The clip's table row holds an empty range until then — apply produces no contributions, so
+     * the clip is observationally inert (still subject to time advancement via the tick shader if
+     * `Playing` is set).
+     *
+     * **Binding is what hands a target to the GPU.** When the bindings are added, every entity
+     * they drive has its `GPUStateAuthority` TransformAttachment bit granted, so the CPU stops
      * writing its local TRS; the last clip to leave revokes it. The entity has to have declared
      * the component — a prefab does, on every node a clip reaches — because a grant that could
      * silently do nothing would be a claim nobody could see.
@@ -1277,18 +1133,18 @@ export class GPUAnimationManager {
             };
         }
 
-        // Reserve the clip row immediately with a placeholder head
-        // pointer. State mutators and the public id are usable from
-        // this point on; the bindings chain gets patched in once
-        // every target has its row. `time` defaults to 0 (the
-        // playback offset relative to `time_start`; the apply
-        // shader does `effective_time = clip.time + clip.time_start`).
+        // Reserve the clip row immediately with an empty range. State
+        // mutators and the public id are usable from this point on; the
+        // bindings get added once every target has its row. `time`
+        // defaults to 0 (the playback offset relative to `time_start`;
+        // the apply shader does `effective_time = clip.time + clip.time_start`).
         const clips_table = this.#database.get('animation_clips');
         const clip_id = clips_table.add({
             time: 0,
             time_start: clip.start_time,
             time_end: clip.end_time,
-            bound_track_group_head: ANIMATION_BOUND_TRACK_GROUP_NULL,
+            bindings_first: GPU_DATABASE_NULL,
+            bindings_count: 0,
             playback_rate: 1,
             flags: 0,
             playback_weight: 1,
@@ -1305,10 +1161,10 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Attempt to build the bindings chain for a pending clip and
-     * patch its head pointer onto the clip row. Returns `true` when
-     * every channel target holds its transforms row (and the chain
-     * was built); `false` when at least one has not taken it yet.
+     * Attempt to add the bindings of a pending clip and name them in
+     * the clip's range. Returns `true` when every channel target holds
+     * its transforms row (and the bindings were added); `false` when at
+     * least one has not taken it yet.
      *
      * Completing is also when the targets are handed to the GPU — see {@link register_clip}.
      *
@@ -1336,28 +1192,15 @@ export class GPUAnimationManager {
                 track: ch.track,
                 instance: row_of_entity(target),
                 property: ch.property,
+                clip: clip_id,
             };
         }
 
-        const groups_table = this.#database.get('animation_bound_track_groups');
-        const head_group_id = add_linked_chain(
-            groups_table,
-            bindings,
-            TRACKS_PER_GROUP_NODE,
-            (start, count, next) => {
-                const inline_bindings = new Array(TRACKS_PER_GROUP_NODE);
-                for (let j = 0; j < TRACKS_PER_GROUP_NODE; j++) {
-                    inline_bindings[j] = j < count ? bindings[start + j] : ZERO_BINDING;
-                }
-                return { bindings: inline_bindings, count, next, clip: clip_id };
-            }
-        );
+        const bindings_first = this.#database.get('animation_bindings').add_run_records(bindings, BINDING_WRITER);
 
-        // Patch the head pointer onto the already-allocated clip
-        // row. Read-modify-write preserves any user-driven state
-        // changes (set_time, set_flags, etc.) made between
-        // register_clip and the drain.
-        this.#patch_clip_field(clip_id, 'bound_track_group_head', head_group_id);
+        // Name the run in the already-allocated clip row — the range's words alone, so neither
+        // the host's changes since register_clip nor the time the GPU has advanced are touched.
+        this.#write_clip(clip_id, { bindings_first, bindings_count: bindings.length }, CLIP_BINDINGS_WRITER);
 
         this.#take_targets(clip_id, channels);
 
@@ -1528,10 +1371,9 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Drop a clip from the manager. Walks the bindings chain and
-     * removes every group-node + the clip row. Tolerates the clip
-     * still being pending (drains it from the queue without GPU
-     * touches besides the original row removal).
+     * Drop a clip from the manager: its row, and with it the run of its bindings — the clip's range
+     * owns the run, so the table removes it. Tolerates the clip still being pending (drains it from
+     * the queue without GPU touches besides the original row removal).
      *
      * Curves and tracks the clip referenced stay alive — they're
      * shared via {@link #intern_curve} / {@link #intern_track} and
@@ -1539,7 +1381,7 @@ export class GPUAnimationManager {
      * reference-counting the manager doesn't carry.
      *
      * Safe to call repeatedly on the same id: the second call finds the row unoccupied and
-     * returns without walking anything.
+     * returns without touching anything.
      *
      * @param {number} clip_id
      */
@@ -1557,27 +1399,13 @@ export class GPUAnimationManager {
         }
 
         const clips_table = this.#database.get('animation_clips');
-        const groups_table = this.#database.get('animation_bound_track_groups');
 
-        // Occupancy rather than `get` — see {@link unregister_skin}. A removed row reads back as
-        // zeros, and a zeroed `bound_track_group_head` is group 0, which the walk below would
-        // chase into itself forever.
+        // Occupancy is what says the row is still this clip's; a second call finds it free and has
+        // nothing to hand back twice.
         if (!clips_table.occupancy.get(clip_id)) return;
 
-        const clip_record = clips_table.get(clip_id);
-
-        // Walk the bindings chain and remove every node. The chain
-        // may be empty (placeholder head NULL) if the clip is still
-        // pending or has been registered then drained but never
-        // completed; both cases skip the loop.
-        let block_id = clip_record.bound_track_group_head;
-        while (block_id !== ANIMATION_BOUND_TRACK_GROUP_NULL) {
-            const block = groups_table.get(block_id);
-            const next_id = block !== undefined ? block.next : ANIMATION_BOUND_TRACK_GROUP_NULL;
-            groups_table.remove(block_id);
-            block_id = next_id;
-        }
-
+        // The bindings go with the clip. A clip still pending holds an empty range and takes
+        // nothing.
         clips_table.remove(clip_id);
 
         this.#release_targets(clip_id);
@@ -1586,18 +1414,18 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Drop a skin from the manager. Walks the joint-block chain and
-     * removes every block + the skin row, and tears down every
-     * skinning binding pointing at this skin (so the skinning
-     * context doesn't try to read the now-freed skin's matrix
-     * offset on its next upload).
+     * Drop a skin from the manager: its row, and with it the run of its joints — the skin's range
+     * owns the run, so the table removes it — and every skinning binding pointing at this skin (so
+     * the skinning context doesn't try to read the now-freed skin's matrix offset on its next
+     * upload).
      *
-     * The skin's matrix range goes back on the free list, for the next skin with the same
-     * joint count to take as-is. A spawn/despawn loop over a fixed cast therefore costs
-     * what the cast costs, not what the loop has run.
+     * The joints' rows, and the matrices at them, are free for the next skin that fits. A
+     * respawn of the same rig fits the rows it left, and first fit takes them unless an earlier
+     * hole fits too — so a spawn/despawn loop over a fixed cast costs what the cast costs, not
+     * what the loop has run.
      *
      * Tolerates the skin still being pending. Safe to call repeatedly on the same id: the
-     * second call finds the row unoccupied and gives no range back twice.
+     * second call finds the row unoccupied and removes nothing.
      *
      * @param {number} skin_id
      */
@@ -1617,47 +1445,39 @@ export class GPUAnimationManager {
         this.#scene_context.skinning.unbind_all_by_skin(skin_id);
 
         const skins_table = this.#database.get('animation_skins');
-        const blocks_table = this.#database.get('animation_skin_joint_blocks');
 
-        // Occupancy, not `get`, is what says the row is still this skin's. `remove` zero-fills a
-        // slot rather than dropping it and `get` reads those bytes back, so a second call would
-        // find a record whose `joint_block_head` is 0 — a valid block id, not the NULL sentinel —
-        // and the walk below would follow block 0 to block 0 for as long as the process lives.
+        // Occupancy is what says the row is still this skin's; a second call finds it free and
+        // removes nothing.
         if (!skins_table.occupancy.get(skin_id)) {
-            this.#skin_matrix_offsets.delete(skin_id);
             return;
         }
 
-        const skin_record = skins_table.get(skin_id);
-
-        // Walk the joint-block chain, terminating on the NULL
-        // sentinel (also the placeholder for a not-yet-patched head).
-        // Note: 0 is a VALID block row id — the first single-block
-        // skin registered into an empty table gets head 0, and
-        // treating it as a placeholder would leak its block, leaving
-        // the prep shader processing it against a recycled
-        // transforms-table row every frame.
-        let block_id = skin_record.joint_block_head;
-        while (block_id !== ANIMATION_SKIN_JOINT_BLOCK_NULL) {
-            const block = blocks_table.get(block_id);
-            const next_id = block !== undefined ? block.next : ANIMATION_SKIN_JOINT_BLOCK_NULL;
-            blocks_table.remove(block_id);
-            block_id = next_id;
-        }
+        // Its rows go back owed no seed. Left queued, a run outlives its skin until the next prep,
+        // and while nothing draws that is every spawn since drawing stopped.
+        this.#drop_seed_runs(skins_table.get_word(skin_id, SKIN_JOINTS_FIRST_WORD));
 
+        // The joints go with the skin — a pending skin's too, nodes or not.
         skins_table.remove(skin_id);
+    }
 
-        // Give the matrix range back while the record that says how long it is still exists.
-        // Reaching here means the row was occupied, and a row is occupied only between the
-        // registration that set this offset and the delete below — the occupancy check at the
-        // top is what keeps a second call from handing the same base out twice.
-        const skin_matrix_offset = this.#skin_matrix_offsets.get(skin_id);
-
-        assert.defined(skin_matrix_offset, `skin ${skin_id} holds a live row but no matrix offset`);
-
-        this.#free_skin_matrix_range(skin_matrix_offset, skin_record.joint_count);
-
-        this.#skin_matrix_offsets.delete(skin_id);
+    /**
+     * Drop every queued seed run starting at `first_row`: the run of a skin being given back,
+     * queued when it was handed out, and again if its joints have been named since.
+     *
+     * No other skin's run can start there, since a skin's rows are its own until it is given back.
+     *
+     * @param {number} first_row
+     */
+    #drop_seed_runs(first_row) {
+        const runs = this.#skin_matrix_seed_runs;
+
+        // the prep sorts what it finds, so a dropped run's place goes to the last one
+        for (let i = runs.length - 1; i >= 0; i--) {
+            if (runs[i][0] === first_row) {
+                runs[i] = runs[runs.length - 1];
+                runs.pop();
+            }
+        }
     }
 
     /**
@@ -1736,60 +1556,56 @@ export class GPUAnimationManager {
     }
 
     /**
-     * Reserve `joint_count` consecutive matrices and answer with the base index.
+     * Put a skin's joints into `animation_skin_joints` as one run, and make sure the matrix
+     * buffers reach its end — a joint's matrix sits at the joint's row.
      *
-     * A range of exactly that length that some skin has given back is preferred over fresh
-     * space, which is what keeps a spawn/despawn loop from growing the buffer — see
-     * {@link #free_skin_matrix_ranges} for why the match is exact and never split.
-     *
-     * @param {number} joint_count length of the range, in matrices
-     * @returns {number} base matrix index of the reserved range
+     * @param {Array<{node: number, inverse_bind: Float32Array | number[]}>} joints
+     * @returns {number} the run's first row
      */
-    #allocate_skin_matrix_range(joint_count) {
-        const reusable = this.#free_skin_matrix_ranges.get(joint_count);
+    #add_joints(joints) {
+        const joints_first = this.#database.get('animation_skin_joints').add_run_records(joints, SKIN_JOINT_WRITER);
 
-        if (reusable !== undefined && reusable.length > 0) {
-            // Already inside the buffer — it was sized for this range when it was first
-            // handed out, and the buffer only ever grows.
-            return reusable.pop();
+        if (joints_first === GPU_DATABASE_NULL) {
+            // no joints: the empty range, and no rows for the buffers to reach
+            return joints_first;
         }
 
-        const skin_matrix_offset = this.#next_skin_matrix_offset;
-
-        this.#next_skin_matrix_offset += joint_count;
-        this.#ensure_skin_matrices_capacity(this.#next_skin_matrix_offset);
-
-        return skin_matrix_offset;
-    }
+        const end = joints_first + joints.length;
 
-    /**
-     * Put a matrix range back on the free list.
-     *
-     * The bytes are left as they are: the prep pass rewrites every matrix of a live skin each
-     * frame, so what a dead skin left behind is only ever read by a pass that no longer has a
-     * block pointing at it.
-     *
-     * @param {number} skin_matrix_offset base matrix index of the range
-     * @param {number} joint_count length of the range, in matrices
-     */
-    #free_skin_matrix_range(skin_matrix_offset, joint_count) {
-        let bucket = this.#free_skin_matrix_ranges.get(joint_count);
-
-        if (bucket === undefined) {
-            bucket = [];
-
-            this.#free_skin_matrix_ranges.set(joint_count, bucket);
+        if (end > this.#skin_matrix_count) {
+            this.#skin_matrix_count = end;
+            this.#ensure_skin_matrices_capacity(end);
         }
 
-        bucket.push(skin_matrix_offset);
+        // A run that is being handed out has no meaningful history in the matrix buffers, whether
+        // its rows are fresh or some despawned skin's, so the next prep dispatch has to seed
+        // "previous" from "current" for it.
+        //
+        // Whether or not the buffers grew: rows given back by another skin never grow them, and
+        // neither do fresh rows below the capacity, so "previous" over the run holds all-zero
+        // matrices or the last pose of the skin that had those rows before. The skinning pass
+        // reads `prev_skin_matrices[skin_base + j]` unconditionally, so unseeded, the new
+        // character's first frame would take its motion vectors from someone else's pose — a
+        // screen-crossing smear through TAA and motion blur — on exactly the spawn/despawn loop
+        // that reuses rows.
+        this.#skin_matrix_seed_runs.push([joints_first, joints.length]);
+
+        return joints_first;
     }
 
     /**
-     * Grow the skinning-matrix scratch buffer if `required_count`
-     * exceeds current capacity. Doubles on grow until the requirement
-     * fits. The buffer's contents are scratch (rewritten every frame by
-     * the prep pass), so growth doesn't need to copy old data — but it
-     * does invalidate the previous {@link #skin_matrices_buffer}
+     * Grow the skinning-matrix buffers if `required_count` exceeds
+     * current capacity. Doubles on grow until the requirement fits.
+     *
+     * Nothing is copied across. "Current" would be rewritten by the
+     * next prep anyway, but "previous" held every skin's pose last
+     * frame, which its motion is measured from: the grow loses that,
+     * and the next prep seeds all of "previous" from "current" instead
+     * ({@link #skin_matrix_seed_all}), so every skinned character has
+     * zero motion vectors for that one frame. Capacity doubles, so
+     * that is a handful of frames over a session.
+     *
+     * The grow also invalidates the {@link #skin_matrices_buffer}
      * reference, which is why callers re-fetch through the getter.
      *
      * @param {number} required_count number of matrices that must fit
@@ -1808,8 +1624,9 @@ export class GPUAnimationManager {
         // capacity. After grow both are zero-initialised, so the next
         // prep dispatch needs to seed "previous" from "current"
         // (otherwise velocity would interpolate against zero
-        // matrices). The flag below tells dispatch_skin_matrix_prep
-        // to issue that copy.
+        // matrices), and all of it: no row has a last frame left to
+        // keep. The flag below tells dispatch_skin_matrix_prep to
+        // issue that copy.
         for (let i = 0; i < 2; i++) {
             if (this.#skin_matrices_buffers[i] !== null) {
                 this.#skin_matrices_buffers[i].destroy();
@@ -1821,22 +1638,20 @@ export class GPUAnimationManager {
             });
         }
         this.#skin_matrices_capacity = new_capacity;
-        this.#first_frame_skin_matrices = true;
+        this.#skin_matrix_seed_all = true;
     }
 
     /**
-     * Flush all pending uploads (curves, keyframe blocks, tracks, clips,
-     * bound-track groups, skins, skin joint blocks) into the GPU
+     * Flush all pending uploads (curves, keyframes, tracks, clips,
+     * bindings, skins, skin joints) into the GPU
      * database. Call once per frame, before any shader that reads from
      * `database.buffer`.
      *
-     * Also drains the pending-registration queues: skins and clips
-     * whose dependencies (joint rows, channel-target rows)
-     * weren't ready at register time get one shot per `update` to
-     * complete. Once every entity has taken its row, the
-     * deferred chain build runs and the registration becomes
-     * observationally complete — the next-frame `database.update`
-     * picks up the patched head pointer.
+     * Drains the pending-registration queues first: skins and clips
+     * whose dependencies (joint rows, channel-target rows) weren't
+     * ready at register time get one shot per `update` to complete.
+     * Once every entity has taken its row, the deferred build runs,
+     * and this same call's `database.update` uploads what it wrote.
      *
      * Does not touch the skin-matrices ping-pong buffers — those
      * are scratch populated each frame by
@@ -1875,31 +1690,34 @@ export class GPUAnimationManager {
      * correct ping-pong behaviour across frames without leaking the
      * buffer-role bookkeeping into every caller.
      *
-     * No-op when no skins are registered (`group_count_x === 0`).
+     * No-op when the joints table has no page for it to walk
+     * (`group_count_x === 0`), which is never while a skin is
+     * registered: a page emptied of joints goes at the next database
+     * update.
      *
      * Per-frame ordering:
-     *  1. Flip {@link #skin_matrices_current_index} — the buffer that
-     *     was last frame's "current" is about to be overwritten with
-     *     this frame's matrices; the other buffer (last frame's prev)
-     *     becomes this frame's "previous" implicit data source for
-     *     {@link prev_skin_matrices_buffer}.
-     *  2. Wait — clarify: we want last frame's "current" to BECOME
-     *     this frame's "previous". So flipping current_index moves
-     *     the role tag the correct way: what was current[i] becomes
-     *     previous (= buffers[1 - i]), and current[1 - i] is the
-     *     write target.
-     *  3. Dispatch the prep shader into the new current.
-     *  4. On the very first frame (or after a grow), copy current →
-     *     previous so the first velocity reads see matching matrices
-     *     and produce zero velocity.
+     *  1. Flip {@link #skin_matrices_current_index}: last frame's
+     *     "current" becomes this frame's "previous"
+     *     ({@link prev_skin_matrices_buffer}), and the buffer that
+     *     held the frame before it becomes the write target.
+     *  2. Dispatch the prep shader into the new "current".
+     *  3. Copy "current" over "previous" on the rows that have no last
+     *     frame — every run handed out and every pending skin's run
+     *     named since the last dispatch, or all of it after a grow —
+     *     so the first velocity read over those rows sees matching
+     *     matrices and produces zero velocity. Every other row of
+     *     "previous" keeps last frame's matrices.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx
      */
     dispatch_skin_matrix_prep(cmd_ctx) {
         const groups = this.#database
-            .get('animation_skin_joint_blocks')
+            .get('animation_skin_joints')
             .dispatch_group_count(SKIN_MATRIX_PREP_WORKGROUP_SIZE);
         if (groups === 0) {
+            // no page to walk means no skin registered, and a skin given back takes its runs
+            assert.equal(this.#skin_matrix_seed_runs.length, 0, 'seed runs queued for skins no longer registered');
+
             return;
         }
 
@@ -1924,20 +1742,69 @@ export class GPUAnimationManager {
             },
         });
 
-        // First-frame init (or post-grow): "previous" buffer is
-        // zero-initialised, which would have the velocity pass
-        // interpolate against the origin and produce huge nonsense
-        // on the first frame the skin appears. Seed prev from
-        // current — first velocity reads then yield zero, which is
-        // the right answer (no motion has happened yet).
-        if (this.#first_frame_skin_matrices) {
+        this.#seed_previous_skin_matrices(cmd_ctx, current, previous);
+    }
+
+    /**
+     * Copy "current" over "previous" on the rows where "previous" holds no pose of the frame
+     * before: all of it after a grow, otherwise the runs queued since the last prep. Zeros there,
+     * or the last pose of a skin that had the rows, would have the velocity pass produce huge
+     * nonsense on the first frame the skin appears; seeded, the first velocity read yields zero,
+     * which is the right answer — no motion has happened yet.
+     *
+     * Every other row is left alone: a settled skin's rows hold its pose last frame, which its
+     * motion is measured from, and the rest are read by no one. Seeded too, every skinned
+     * character on screen would lose its motion vectors for the frame whenever one spawned.
+     *
+     * Runs are coalesced by sorting — a frame's worth of spawns is a handful of runs — and adjacent
+     * or overlapping ones go as one copy.
+     *
+     * @param {ShadeGPUCommandContext} cmd_ctx
+     * @param {GPUBuffer} current
+     * @param {GPUBuffer} previous
+     */
+    #seed_previous_skin_matrices(cmd_ctx, current, previous) {
+        const runs = this.#skin_matrix_seed_runs;
+
+        if (this.#skin_matrix_seed_all) {
+            cmd_ctx.copyBufferToBuffer(current, 0, previous, 0, current.size);
+
+            this.#skin_matrix_seed_all = false;
+            runs.length = 0;
+
+            return;
+        }
+
+        if (runs.length === 0) {
+            // a settled frame: every row of "previous" is last frame's
+            return;
+        }
+
+        runs.sort((a, b) => a[0] - b[0]);
+
+        let i = 0;
+
+        while (i < runs.length) {
+            const first = runs[i][0];
+            let end = first + runs[i][1];
+
+            i++;
+
+            // a run starting at or before this copy's end is part of it
+            while (i < runs.length && runs[i][0] <= end) {
+                end = Math.max(end, runs[i][0] + runs[i][1]);
+
+                i++;
+            }
+
             cmd_ctx.copyBufferToBuffer(
-                current, 0,
-                previous, 0,
-                current.size,
+                current, first * SKIN_MATRIX_BYTES,
+                previous, first * SKIN_MATRIX_BYTES,
+                (end - first) * SKIN_MATRIX_BYTES,
             );
-            this.#first_frame_skin_matrices = false;
         }
+
+        runs.length = 0;
     }
 
     /**
@@ -1982,7 +1849,7 @@ export class GPUAnimationManager {
 
         // Only clip evaluation is conditional. Every scene needs current globals.
         const apply_groups = this.#database
-            .get('animation_bound_track_groups')
+            .get('animation_bindings')
             .dispatch_group_count(ANIMATION_APPLY_WORKGROUP_SIZE);
 
         if (apply_groups > 0) {