From 5f622e6fe875bd67f591543233e3ef7709cc4802 Mon Sep 17 00:00:00 2001
From: Sam <samuv.eth@gmail.com>
Date: Thu, 17 Sep 2026 16:42:33 +0700
Subject: [PATCH] air elementals, Ragnaros and the forge lava animate

- every unit, GameObject and held item runs its texture animation: air elementals, Ragnaros, the Ash'ari Crystal, Ironforge's forge lava, the Scourge rune circles and the Zul'Gurub forcefields were static (2295)
- a GameObject whose animation slots disagree gets a material of its own: the Blood of Heroes pools bubble and the Freezing Trap's glow pulses (2295)
- three sound kits with a doubled separator in their path were silent, the flight-path-discovered chime among them; the Ashbringer's lines stay silent, as they are in 1.12 (2294)

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 crates/benilla-app/src/entities.rs            |   20 +
 .../benilla-app/src/entities/attach/dress.rs  |  236 ++-
 .../benilla-app/src/entities/attach/merge.rs  |    1 +
 crates/benilla-app/src/entities/attach/mod.rs |   24 +-
 .../src/entities/attach/redress.rs            |   30 +-
 crates/benilla-app/src/entities/display.rs    |   36 +-
 .../src/entities/equipment/spawn.rs           |   12 +
 .../benilla-app/src/entities/spell_fx/mod.rs  |   14 +-
 crates/benilla-app/src/game_plugins.rs        |   12 +-
 crates/benilla-app/tests/world_api_wall.rs    |   33 +-
 .../src/bin/benilla-extract/main.rs           |   84 +-
 .../src/bin/benilla-extract/scan/material.rs  | 1867 +++++++++++++++--
 .../src/bin/benilla-extract/scan/mod.rs       |    5 +-
 crates/benilla-formats/src/item_sounds.rs     |    2 +-
 crates/benilla-formats/src/item_visuals.rs    |    2 +-
 crates/benilla-formats/src/items.rs           |    9 +-
 crates/benilla-formats/src/models/mat_anim.rs |    9 +
 crates/benilla-formats/src/sound_entries.rs   |  126 +-
 .../tests/helm_vis_wants_a_helm.rs            |   12 +-
 .../tests/m2_entity_mat_anim.rs               |  165 ++
 .../benilla-world/src/doodad_anim/mat_anim.rs |  314 ++-
 crates/benilla-world/src/doodad_anim/mod.rs   |    4 +-
 crates/benilla-world/src/model_render.rs      |    2 +-
 .../benilla-world/src/model_render/batch.rs   |   64 +-
 .../src/terrain_stream/spawn/assemble.rs      |    2 +-
 25 files changed, 2765 insertions(+), 320 deletions(-)
 create mode 100644 crates/benilla-formats/tests/m2_entity_mat_anim.rs

diff --git a/crates/benilla-app/src/entities.rs b/crates/benilla-app/src/entities.rs
index 387129a9..a47894d7 100644
--- a/crates/benilla-app/src/entities.rs
+++ b/crates/benilla-app/src/entities.rs
@@ -1203,6 +1203,10 @@ fn update_display_models(
     mut forms: ResMut<benilla_world::model_forms::ModelForms>,
     asset_server: Res<AssetServer>,
     mut mats: benilla_world::model_render::M2BatchMaterials,
+    // The UV lane a batch's texture transform is delivered on (decision 2295): an entity batch is
+    // seeded AND registered in one call, so a display built here can never be marked-but-frozen.
+    mut uv_reg: ResMut<benilla_world::doodad_anim::UvAnimMaterials>,
+    mut anim_table: ResMut<benilla_world::mat_anim_table::MatAnimTable>,
     // The bone-pile display cache + the ChrRaces fileStrings its paths are built from (1706).
     mut bones: ResMut<corpse::BonesModels>,
     // The glue-preview want (decisions 0423 + 0465): the glue screens' look's body displayId, so
@@ -1218,6 +1222,15 @@ fn update_display_models(
         return; // no lighting yet → no materials to build
     }
     let (m2s, wmos) = (&model_assets.0, &model_assets.1);
+    // `instance: None` — every display cache here is keyed by display id and shared by every unit
+    // wearing it, so these materials belong to the batch. The one population that needs its own
+    // (a GameObject whose file-sequence slots bake different loops) takes its clone at spawn,
+    // where the host entity exists (`attach::dress`).
+    let mut uv = benilla_world::model_render::EntityUvLane {
+        reg: &mut uv_reg,
+        table: &mut anim_table,
+        instance: None,
+    };
 
     // The (kind, display) pairs live in the world this frame — cheap to collect.
     let mut actives: Vec<(EntityKind, u32)> = entities
@@ -1310,6 +1323,7 @@ fn update_display_models(
                             &mut forms,
                             &asset_server,
                             &mut mats,
+                            &mut uv,
                             false, // gameobject: creatures — no hull collider, no bake variant
                         );
                     }
@@ -1340,6 +1354,7 @@ fn update_display_models(
                             &mut forms,
                             &asset_server,
                             &mut mats,
+                            &mut uv,
                             true, // gameobject: hull collider + the interior BAKE material variant
                         );
                     }
@@ -1365,6 +1380,7 @@ fn update_display_models(
                         &mut forms,
                         &asset_server,
                         &mut mats,
+                        &mut uv,
                         false, // gameobject: a prop body — unit lighting, no hull collider
                     );
                 }
@@ -1391,6 +1407,7 @@ fn update_display_models(
                         &mut forms,
                         &asset_server,
                         &mut mats,
+                        &mut uv,
                         false, // gameobject: held items — unit lighting, no collider
                     );
                 }
@@ -1411,6 +1428,7 @@ fn update_display_models(
                         &mut forms,
                         &asset_server,
                         &mut mats,
+                        &mut uv,
                         false, // gameobject: effects — unit lighting, no collider
                     );
                 }
@@ -1431,6 +1449,7 @@ fn update_display_models(
                         &mut forms,
                         &asset_server,
                         &mut mats,
+                        &mut uv,
                         false, // gameobject: effects — unit lighting, no collider
                     );
                 }
@@ -1631,6 +1650,7 @@ mod display_mirror_tests {
             }),
             alpha_anim: None,
             rgb_anim: None,
+            rgb_seq: None,
             uv_anim: None,
             uv_seq: None,
             uv_rot_seq: None,
diff --git a/crates/benilla-app/src/entities/attach/dress.rs b/crates/benilla-app/src/entities/attach/dress.rs
index 21bb040a..93a7399f 100644
--- a/crates/benilla-app/src/entities/attach/dress.rs
+++ b/crates/benilla-app/src/entities/attach/dress.rs
@@ -103,6 +103,161 @@ pub(super) fn part_materials<'a>(
     }
 }
 
+/// The material store and the two animated-material registries, for the one entity population
+/// that needs a material of its **own** rather than the batch's (decision 2295).
+///
+/// Taken as one bundle, and taken by the dressing path itself rather than by a system that fixes
+/// parts up afterwards, because the cloned handles have to be in hand *before* the part's
+/// [`InteriorLit`](benilla_world::interior) and [`FadeMaterials`] are built from them — a later
+/// pass would have to reach into both and rewrite what the classifier already wrote.
+pub(super) struct OwnMats<'a> {
+    pub(super) store: &'a mut Assets<WowModelMaterial>,
+    pub(super) uv: &'a mut benilla_world::doodad_anim::UvAnimMaterials,
+    pub(super) tint: &'a mut benilla_world::doodad_anim::TintAnimMaterials,
+    pub(super) table: &'a mut benilla_world::mat_anim_table::MatAnimTable,
+}
+
+/// One part's **own** variant set — [`PartMaterials`]' owning twin, held by the spawn for as long
+/// as it takes to dress the part.
+struct OwnedMaterials {
+    steady: Handle<WowModelMaterial>,
+    interior: Option<Handle<WowModelMaterial>>,
+    fade_blend: Option<Handle<WowModelMaterial>>,
+    bake: Option<Handle<WowModelMaterial>>,
+    bake_blend: Option<Handle<WowModelMaterial>>,
+    zfill: Option<Handle<WowModelMaterial>>,
+}
+
+impl OwnedMaterials {
+    fn borrow(&self) -> PartMaterials<'_> {
+        PartMaterials {
+            steady: &self.steady,
+            interior: self.interior.as_ref(),
+            fade_blend: self.fade_blend.as_ref(),
+            bake: self.bake.as_ref(),
+            bake_blend: self.bake_blend.as_ref(),
+            zfill: self.zfill.as_ref(),
+        }
+    }
+}
+
+/// Give this part a material set of its **own**, registered against its own instance's anim host —
+/// or `None`, which is every part but a measured thirteen batches (decision 2295).
+///
+/// **Who needs one.** A batch whose file-sequence slots bake *different* UV or tint loops cannot be
+/// served by a material every instance of the model shares: the registries are keyed by material,
+/// so one row would have to answer for placements that are playing different slots. That is
+/// 1408's finding, and the entity side of it is six GameObject models — `BloodOfHeroes`'s five
+/// bubble sheets (slot 0 holds them still, slot 1 sweeps them, at freq 16384/16383, so the pools
+/// bubble independently), `Valentines_Blanket`, `G_GnomeTerminal`'s screen, and on the tint
+/// channel `G_FreezingTrap`'s glow card, `OrgrimmarPentagram` and `ScholomanceCrystalBall01`.
+/// **Four of the five tint batches bake nothing in slot 0**, so their shared material can only
+/// ever seed white however faithfully it is ticked — the hunter's trap glows flat instead of
+/// pulsing blue-white as it arms.
+///
+/// **Why it is gated on `GameObject`.** Not as a safety valve: the census is the reason. No unit,
+/// no player body, no corpse and no held item in the shipped corpus authors a per-sequence set on
+/// either channel (`benilla-extract entityuvscan`), so widening this past GameObjects would add a
+/// clone-and-register branch to the hottest spawn path in the client for an empty population. If
+/// a future model joins it, the gate is the line to move and this paragraph is why.
+fn own_per_sequence_materials(
+    part: &EntityPart,
+    dress: &PartDress<'_>,
+    own: &mut OwnMats<'_>,
+) -> Option<OwnedMaterials> {
+    let loops = part.uv_loops();
+    let (uv_seq, tint_seq) = (loops.seqs.is_some(), part.rgb_seq.is_some());
+    if dress.kind != ModelKind::GameObject || !(uv_seq || tint_seq) {
+        return None;
+    }
+    let src = part_materials(part, dress.char_mats);
+    // The shared variants may still be PARKED (`model_render::lazy` reserves a handle and holds
+    // the value until something view-visible binds it), so each is realized before it is read —
+    // the same order `spell_fx`'s clone takes, and the reason 2038's registrations all returned
+    // `None` when they skipped it.
+    let mut clone = |h: &Handle<WowModelMaterial>| -> Option<Handle<WowModelMaterial>> {
+        benilla_world::model_render::lazy::realize(own.store, h.id());
+        let mut mat = own.store.get(h.id()).cloned()?;
+        // A clone leaves the shared table (decision 1381): its rows are its own, and a carried
+        // slot would add the shared delta on top of them.
+        mat.extension.anim_slots = Vec4::ZERO;
+        Some(own.store.add(mat))
+    };
+    let owned = OwnedMaterials {
+        steady: clone(src.steady)?,
+        interior: src.interior.and_then(&mut clone),
+        fade_blend: src.fade_blend.and_then(&mut clone),
+        bake: src.bake.and_then(&mut clone),
+        bake_blend: src.bake_blend.and_then(&mut clone),
+        // The depth-prime twin is NOT cloned and NOT registered, exactly as on the placed-doodad
+        // lane: it draws only while the part feathers, and its alpha test reading unscrolled UVs
+        // for those frames is the behaviour the streamer has always had.
+        zfill: src.zfill.cloned(),
+    };
+    // Every variant the part can swap to over its life — indoors, feathering, both — takes a row,
+    // or a GameObject that walks under a roof would stop mid-scroll.
+    for id in [
+        Some(&owned.steady),
+        owned.interior.as_ref(),
+        owned.fade_blend.as_ref(),
+        owned.bake.as_ref(),
+        owned.bake_blend.as_ref(),
+    ]
+    .into_iter()
+    .flatten()
+    .map(Handle::id)
+    {
+        if uv_seq {
+            benilla_world::doodad_anim::register_entity_uv(
+                own.uv,
+                own.table,
+                own.store,
+                id,
+                &loops,
+                Some(dress.unit),
+            );
+        }
+        if let Some(seqs) = &part.rgb_seq {
+            benilla_world::doodad_anim::register_tint(
+                own.tint,
+                own.table,
+                own.store,
+                id,
+                benilla_world::doodad_anim::TintLoop::PerSeq {
+                    seqs: seqs.clone(),
+                    host: dress.unit,
+                },
+            );
+        }
+    }
+    Some(owned)
+}
+
+/// Put this part in `tick_anim_materials`' draw scan — **iff something registered a row for it**.
+///
+/// The marker and the registration have to ask ONE question, because 2038's whole bug class is the
+/// two disagreeing: a marked part with no registry entry trips the lane's own tripwire, and a
+/// registered material that no marked part accounts for freezes silently, which is how every
+/// waterfall in the game stood still for three days. So this is not a predicate over the part's
+/// channels — it is a statement about what actually happened a few lines up.
+///
+/// Two registrations can have happened. The **shared** UV lane's, made inside
+/// `entity_variants` when the batch's transform moves at all (`UvLoops::animates`, which is not
+/// `uv_anim.is_some()`: a rotate-only batch answers `None` there). And this instance's **own**
+/// clone, when it has one — which is the only way the TINT channel is ever registered on an
+/// entity, and why `owned` has to be consulted rather than the part's `rgb_seq` re-tested: the
+/// clone can decline (a full table, a dead handle), and a marker for a registration that did not
+/// happen is the first half of the bug above.
+fn mark_mat_anim(
+    child: &mut bevy::ecs::system::EntityCommands<'_>,
+    part: &EntityPart,
+    owned: &Option<OwnedMaterials>,
+) {
+    if part.uv_loops().animates() || owned.is_some() {
+        child.insert(benilla_world::doodad_anim::AnimMatPart);
+    }
+}
+
 /// Stamp a pickable part (or card) with the pick population its kind belongs to: the mouseover
 /// pickers filter by these markers instead of kind-comparing every `WorldObject` row per frame.
 /// One site for both the mesh-part and the billboard-card spawn, so the two can't drift.
@@ -183,10 +338,11 @@ pub(super) fn spawn_group(
     part: &EntityPart,
     group: &super::merge::BodyGroup,
     dress: &PartDress,
+    own: &mut OwnMats<'_>,
 ) -> bool {
     let members =
         (group.members.len() > 1).then(|| super::merge::DressedGroup(group.members.clone().into()));
-    spawn_part(commands, part, group.first() as usize, members, dress)
+    spawn_part(commands, part, group.first() as usize, members, dress, own)
 }
 
 /// Spawn one mesh part (or billboard card) of a body under `dress.unit`; `group` is the merged
@@ -197,11 +353,18 @@ pub(super) fn spawn_part(
     index: usize,
     group: Option<super::merge::DressedGroup>,
     dress: &PartDress,
+    own: &mut OwnMats<'_>,
 ) -> bool {
     if let Some(info) = &part.billboard {
-        return spawn_billboard_part(commands, part, index, info, dress);
+        return spawn_billboard_part(commands, part, index, info, dress, own);
     }
-    let mats = part_materials(part, dress.char_mats);
+    // A material of this instance's OWN, for the measured thirteen batches whose slots disagree
+    // (2295) — resolved first, because everything below dresses from whatever this returns.
+    let owned = own_per_sequence_materials(part, dress, own);
+    let mats = match &owned {
+        Some(o) => o.borrow(),
+        None => part_materials(part, dress.char_mats),
+    };
     let set = mats.fade_set();
     // A freshly-streamed CGObject appear-fades in (decision 0032): spawn already on the blend twin
     // with a ≈0 `MeshTag`, so it doesn't flash opaque for a frame before `apply_render_fade` ramps
@@ -314,6 +477,7 @@ pub(super) fn spawn_part(
             dress.unit,
         ));
     }
+    mark_mat_anim(&mut child, part, &owned);
     effective.dress(&mut child, &set)
 }
 
@@ -328,6 +492,7 @@ fn spawn_billboard_part(
     index: usize,
     info: &benilla_assets::BillboardInfo,
     dress: &PartDress,
+    own: &mut OwnMats<'_>,
 ) -> bool {
     let anchor = commands
         .spawn((
@@ -363,12 +528,15 @@ fn spawn_billboard_part(
     // (decision 0836). Splitting the batch into a world-root entity is benilla's parenting detail;
     // it is not a reason for the glow on a weapon's gems to blaze at full strength over a body that
     // has not appeared yet.
-    let set = FadeSet {
-        steady: &part.material,
-        blend: part.fade_blend.as_ref(),
-        bake_blend: part.material_interior_bake_blend.as_ref(),
-        zfill: part.zfill.as_ref(),
+    // A card may need a material of its own for exactly the same reason a mesh part does — and
+    // on this population it is the card that needs it: `World\Goober\G_FreezingTrap`'s animated
+    // batch IS the additive glow card, whose blue-white pulse is keyed in file slot 2 alone.
+    let owned = own_per_sequence_materials(part, dress, own);
+    let mats = match &owned {
+        Some(o) => o.borrow(),
+        None => part_materials(part, dress.char_mats),
     };
+    let set = mats.fade_set();
     let effective = PartFade::resolve(dress.fade, &set);
     let (init_mat, tag_alpha) = effective.seed(&set, dress.now);
     let mut card = commands.spawn((
@@ -401,9 +569,9 @@ fn spawn_billboard_part(
         card.insert(aabb);
     }
     if let Some(lit) = part_interior_lit(
-        &part.material,
-        part.material_interior.as_ref(),
-        part.material_interior_bake.as_ref(),
+        mats.steady,
+        mats.interior,
+        mats.bake,
         dress.bake_center,
         dress.unit,
     ) {
@@ -417,6 +585,11 @@ fn spawn_billboard_part(
             dress.unit,
         ));
     }
+    // …and its batch's material animation, on the same rule as a mesh part (2295). A card is a
+    // batch of the unit's own model; the split into a world-root entity is benilla's parenting
+    // detail, never a reason for one batch of a model to animate and its sibling not to — and on
+    // this population it is the card that carries it.
+    mark_mat_anim(&mut card, part, &owned);
     let armed = effective.dress(&mut card, &set);
     let card = card.id();
     // The card follows the JOINT when the unit is rigged, so it does not cascade with the anchor's
@@ -431,6 +604,28 @@ fn spawn_billboard_part(
 #[cfg(test)]
 mod tests {
     use super::*;
+
+    /// A standalone [`OwnMats`] for the spawn tests — none of them dresses a GameObject, so the
+    /// lane is never taken; it exists so the spawn's signature can stay non-optional, which is
+    /// what stops a production caller passing `None` and silently losing the clone.
+    #[derive(Default)]
+    struct TestOwn {
+        store: Assets<WowModelMaterial>,
+        uv: benilla_world::doodad_anim::UvAnimMaterials,
+        tint: benilla_world::doodad_anim::TintAnimMaterials,
+        table: benilla_world::mat_anim_table::MatAnimTable,
+    }
+
+    impl TestOwn {
+        fn lane(&mut self) -> OwnMats<'_> {
+            OwnMats {
+                store: &mut self.store,
+                uv: &mut self.uv,
+                tint: &mut self.tint,
+                table: &mut self.table,
+            }
+        }
+    }
     use benilla_world::model_fade::{FadeMaterials, PendingAppearFade};
 
     /// One synthetic batch at `char_slot`/`two_sided`, carrying its own (distinguishable) built
@@ -456,6 +651,7 @@ mod tests {
             billboard: None,
             alpha_anim: None,
             rgb_anim: None,
+            rgb_seq: None,
             uv_anim: None,
             uv_seq: None,
             uv_rot_seq: None,
@@ -550,11 +746,12 @@ mod tests {
             now: 0.0,
             fade: JoinedFade::Steady,
         };
+        let mut own = TestOwn::default();
         let mut queue = bevy::ecs::world::CommandQueue::default();
         let armed = {
             let world = app.world();
             let mut commands = Commands::new(&mut queue, world);
-            spawn_part(&mut commands, &fadeable, 0, None, &dress)
+            spawn_part(&mut commands, &fadeable, 0, None, &dress, &mut own.lane())
         };
         queue.apply(app.world_mut());
         assert!(!armed, "steady: no ramp armed");
@@ -614,11 +811,12 @@ mod tests {
             now: 0.0,
             fade: JoinedFade::Pending { since: SINCE },
         };
+        let mut own = TestOwn::default();
         let mut queue = bevy::ecs::world::CommandQueue::default();
         let armed = {
             let world = app.world();
             let mut commands = Commands::new(&mut queue, world);
-            spawn_part(&mut commands, &card, 0, None, &dress)
+            spawn_part(&mut commands, &card, 0, None, &dress, &mut own.lane())
         };
         queue.apply(app.world_mut());
         assert!(
@@ -690,12 +888,20 @@ mod tests {
                 now: 0.0,
                 fade: JoinedFade::Steady,
             };
+            let mut own = TestOwn::default();
             let mut queue = bevy::ecs::world::CommandQueue::default();
             {
                 let world = app.world();
                 let mut commands = Commands::new(&mut queue, world);
-                spawn_part(&mut commands, &part(None, false), 0, None, &dress);
-                spawn_part(&mut commands, &billboard, 1, None, &dress);
+                spawn_part(
+                    &mut commands,
+                    &part(None, false),
+                    0,
+                    None,
+                    &dress,
+                    &mut own.lane(),
+                );
+                spawn_part(&mut commands, &billboard, 1, None, &dress, &mut own.lane());
             }
             queue.apply(app.world_mut());
             let world = app.world_mut();
diff --git a/crates/benilla-app/src/entities/attach/merge.rs b/crates/benilla-app/src/entities/attach/merge.rs
index d32ebb61..9f9a3649 100644
--- a/crates/benilla-app/src/entities/attach/merge.rs
+++ b/crates/benilla-app/src/entities/attach/merge.rs
@@ -364,6 +364,7 @@ mod tests {
             welded_billboard: false,
             alpha_anim: None,
             rgb_anim: None,
+            rgb_seq: None,
             uv_anim: None,
             uv_seq: None,
             uv_rot_seq: None,
diff --git a/crates/benilla-app/src/entities/attach/mod.rs b/crates/benilla-app/src/entities/attach/mod.rs
index 8b7bcda6..4ed7cac5 100644
--- a/crates/benilla-app/src/entities/attach/mod.rs
+++ b/crates/benilla-app/src/entities/attach/mod.rs
@@ -348,6 +348,14 @@ pub(super) fn attach_entity_visuals(
         // The merged-group forms (`merge`): built on a body's first silhouette, shared after.
         ResMut<Assets<Mesh>>,
         ResMut<merge::MergedFormsCache>,
+        // …and the animated-material lane a spawned part may need a material of its OWN on
+        // (decision 2295) — a GameObject whose file-sequence slots bake different UV or tint
+        // loops. Taken by the dressing path itself, because the clone has to exist before the
+        // part's interior and fade records are built from it; nested here for this tuple's own
+        // stated reason, the 16-param limit.
+        ResMut<benilla_world::doodad_anim::UvAnimMaterials>,
+        ResMut<benilla_world::doodad_anim::TintAnimMaterials>,
+        ResMut<benilla_world::mat_anim_table::MatAnimTable>,
     ),
     // The owned skin-palette table (decision 0720): every skinned instance claims a rig slot.
     mut palettes: ResMut<benilla_world::rig_palette::RigPalettes>,
@@ -365,6 +373,9 @@ pub(super) fn attach_entity_visuals(
         mut mats,
         mut meshes,
         mut merged,
+        mut uv_reg,
+        mut tint_reg,
+        mut anim_table,
     ) = skin_build;
     // Arm each entity's appear-fade at the moment its visual attaches (≈ its first-visible moment).
     let now = time.elapsed_secs();
@@ -870,7 +881,18 @@ pub(super) fn attach_entity_visuals(
             for group in &groups {
                 let forms = merged.forms(parts, group, &mut meshes);
                 let part = merge::group_part(parts, group, forms);
-                unit_will_fade |= spawn_group(&mut commands, &part, group, &dress);
+                unit_will_fade |= spawn_group(
+                    &mut commands,
+                    &part,
+                    group,
+                    &dress,
+                    &mut dress::OwnMats {
+                        store: mats.materials(),
+                        uv: &mut uv_reg,
+                        tint: &mut tint_reg,
+                        table: &mut anim_table,
+                    },
+                );
             }
             // Mirror the appear-fade clock onto the unit root (see `unit_will_fade` above): a held item
             // / helm / shoulder attaching later reads this to join the same ramp
diff --git a/crates/benilla-app/src/entities/attach/redress.rs b/crates/benilla-app/src/entities/attach/redress.rs
index 77331deb..664127df 100644
--- a/crates/benilla-app/src/entities/attach/redress.rs
+++ b/crates/benilla-app/src/entities/attach/redress.rs
@@ -115,6 +115,15 @@ pub(in crate::entities) fn redress_player_looks(
         ResMut<Assets<Mesh>>,
         ResMut<MergedFormsCache>,
     ),
+    // The animated-material lane a re-dressed part may need a material of its own on (2295).
+    // Plumbing here rather than a live case: a re-dress is a PLAYER's gear change, and no
+    // character batch in the corpus carries a per-sequence loop — but the dressing law is one law,
+    // and a path that could not express it would be a place for the two to drift.
+    mut own_lane: (
+        ResMut<benilla_world::doodad_anim::UvAnimMaterials>,
+        ResMut<benilla_world::doodad_anim::TintAnimMaterials>,
+        ResMut<benilla_world::mat_anim_table::MatAnimTable>,
+    ),
     time: Res<Time>,
 ) {
     let (
@@ -288,7 +297,18 @@ pub(in crate::entities) fn redress_player_looks(
             }
             let forms = merged.forms(parts, group, &mut meshes);
             let part = merge::group_part(parts, group, forms);
-            spawn_group(&mut commands, &part, group, &dress);
+            spawn_group(
+                &mut commands,
+                &part,
+                group,
+                &dress,
+                &mut super::dress::OwnMats {
+                    store: mats.materials(),
+                    uv: &mut own_lane.0,
+                    tint: &mut own_lane.1,
+                    table: &mut own_lane.2,
+                },
+            );
             shown += 1;
         }
         // One line per re-dress — a handful per session, and the only readout of a mechanism whose
@@ -398,6 +418,7 @@ mod tests {
             billboard: None,
             alpha_anim: None,
             rgb_anim: None,
+            rgb_seq: None,
             uv_anim: None,
             uv_seq: None,
             uv_rot_seq: None,
@@ -429,7 +450,12 @@ mod tests {
             .init_resource::<MergedFormsCache>()
             // The engine's material cache — normally `model_render::plugin`'s, which this bare
             // harness does not install.
-            .init_resource::<benilla_world::model_render::ModelMaterials>();
+            .init_resource::<benilla_world::model_render::ModelMaterials>()
+            // The animated-material lane the dressing path now takes (2295) — never exercised by
+            // a re-dress, which is a player's gear change, but the system asks for it.
+            .init_resource::<benilla_world::doodad_anim::UvAnimMaterials>()
+            .init_resource::<benilla_world::doodad_anim::TintAnimMaterials>()
+            .init_resource::<benilla_world::mat_anim_table::MatAnimTable>();
 
         let mut dm = empty_display();
         dm.parts = Some(geosets.iter().map(|g| part(*g)).collect());
diff --git a/crates/benilla-app/src/entities/display.rs b/crates/benilla-app/src/entities/display.rs
index f1535139..dd39efca 100644
--- a/crates/benilla-app/src/entities/display.rs
+++ b/crates/benilla-app/src/entities/display.rs
@@ -127,11 +127,18 @@ pub(super) struct EntityPart {
     /// the **first key** seeded as the material tint (pixel-identical to the old static bake);
     /// the effect lane clones + ticks the tint per instance. `None` for constant tints.
     pub(super) rgb_anim: Option<std::sync::Arc<benilla_formats::RgbAnim>>,
+    /// The per-file-sequence-slot form of [`Self::rgb_anim`], carried only where the slots
+    /// disagree (decision 1408) — [`Self::uv_seq`]'s twin, and the reason a GameObject may need a
+    /// material of its own. Five batches on three GameObject models author one, and **four of
+    /// them bake nothing in slot 0**, so `rgb_anim` is `None` for them and a shared material can
+    /// only ever seed white: the hunter's Freezing Trap glow card is the class (decision 2295).
+    pub(super) rgb_seq: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 3]>>>,
     /// The part's **texture-transform (UV) loop** — the translation track that scrolls this
     /// batch's stage UVs (decision 0130 phase 3, wow-re `m2-texanim-uv`). The **effect lane**
     /// ([`super::spell_fx`]) samples it per instance on its own clip clock, through a material
-    /// clone (decision 2282); the unit/GameObject lane does not consume it yet. `None` for the
-    /// ~98.6% of batches with no texture transform, and for all WMO parts.
+    /// clone (decision 2282); the unit/GameObject lane runs it on the shared, deduped material
+    /// (decision 2295). `None` for the ~98.6% of batches with no texture transform, and for all
+    /// WMO parts.
     pub(super) uv_anim: Option<std::sync::Arc<benilla_formats::UvAnim>>,
     /// The per-file-sequence-slot form of [`Self::uv_anim`], carried only where the slots
     /// disagree (decision 1408) — an effect that advances `Stand` → `Hold` → `Decay` reads the
@@ -151,6 +158,23 @@ pub(super) struct EntityPart {
     pub(super) ground_quad: Option<benilla_formats::GroundQuad>,
 }
 
+impl EntityPart {
+    /// This part's four baked texture-transform channels, in the shape the engine's lanes take
+    /// them — **the one place a spawner reads them**, so "does this batch animate its transform"
+    /// has a single answer wherever it is asked (the effect attach's clone test, the entity
+    /// spawn's [`benilla_world::doodad_anim::AnimMatPart`] marker). `UvLoops::animates` is that
+    /// question: a scale-only transform and a dead-slot-0 translation each answer `None` to the
+    /// channel you would check first.
+    pub(super) fn uv_loops(&self) -> benilla_world::doodad_anim::UvLoops {
+        benilla_world::doodad_anim::UvLoops {
+            seqs: self.uv_seq.clone(),
+            single: self.uv_anim.clone(),
+            rot: self.uv_rot_seq.clone(),
+            scale: self.uv_scale_seq.clone(),
+        }
+    }
+}
+
 /// Everything needed to render one display id, cached so a model is loaded + built once and shared by
 /// every entity of that display. `parts` is `None` while the asset loads, then `Some` — empty if the
 /// model failed / has no geometry (→ cube/none fallback), else the spawn parts.
@@ -402,6 +426,10 @@ pub(super) fn build_parts(
     forms: &mut benilla_world::model_forms::ModelForms,
     asset_server: &AssetServer,
     mats: &mut benilla_world::model_render::M2BatchMaterials,
+    // Where this display's animated texture transforms are delivered (decision 2295) — taken
+    // rather than reached for, because building an entity batch's material and putting it on the
+    // lane are one act.
+    uv: &mut benilla_world::model_render::EntityUvLane<'_>,
     // Whether this display is a GAMEOBJECT: gates the hull-collider build (chests/veins/doors;
     // creatures use unit collision).
     gameobject: bool,
@@ -527,7 +555,7 @@ pub(super) fn build_parts(
                     // the law that decides which of them collapse onto each other (decisions 0842
                     // / 0865 / 0831 / 0355). `None` cannot happen here: the caller gated on the
                     // light buffer before the first build.
-                    let v = mats.entity_variants(sub, texture, order);
+                    let v = mats.entity_variants(sub, texture, order, uv);
                     let v = v.expect("light buffer checked at entry");
                     EntityPart {
                         // Index-parallel with the submeshes by the forms contract; a miss is a
@@ -554,6 +582,7 @@ pub(super) fn build_parts(
                         welded_billboard: sub.geometry.welded_billboard,
                         alpha_anim: sub.alpha_anim.clone(),
                         rgb_anim: sub.rgb_anim.clone(),
+                        rgb_seq: sub.rgb_seq.clone(),
                         uv_anim: sub.uv_anim.clone(),
                         uv_seq: sub.uv_seq.clone(),
                         uv_rot_seq: sub.uv_rot_seq.clone(),
@@ -608,6 +637,7 @@ pub(super) fn build_parts(
                     welded_billboard: false, // …so nothing can be welded to one
                     alpha_anim: None,        // …nor colour/weight loops
                     rgb_anim: None,
+                    rgb_seq: None,
                     uv_anim: None, // …nor texture transforms (WMO has none)
                     uv_seq: None,
                     uv_rot_seq: None,
diff --git a/crates/benilla-app/src/entities/equipment/spawn.rs b/crates/benilla-app/src/entities/equipment/spawn.rs
index 73498314..d69b8123 100644
--- a/crates/benilla-app/src/entities/equipment/spawn.rs
+++ b/crates/benilla-app/src/entities/equipment/spawn.rs
@@ -645,6 +645,14 @@ fn spawn_slot(
                     benilla_world::doodad_anim::MatAnim::resting(anim.clone())
                 });
             }
+            // …and the batch's texture transform (decision 2295), on the same one predicate every
+            // other entity spawn asks. One held-item batch in the whole 1.12 corpus animates one —
+            // `Item\ObjectComponents\Shield\shield_epic_a_01`, the Drillborer Disk, whose
+            // Ragnaros-skinned lava is a 6.7 s global-sequence scroll — which is exactly why the
+            // marker is a property of the batch here and not of a list somebody maintains.
+            if part.uv_loops().animates() {
+                child.insert(benilla_world::doodad_anim::AnimMatPart);
+            }
             effective.dress(&mut child, &set);
         }
     });
@@ -716,6 +724,9 @@ fn spawn_slot(
         if let Some(anim) = &part.alpha_anim {
             card.insert(benilla_world::doodad_anim::MatAnim::resting(anim.clone()));
         }
+        if part.uv_loops().animates() {
+            card.insert(benilla_world::doodad_anim::AnimMatPart);
+        }
         effective.dress(&mut card, &set);
     }
     // The item's own particle emitters — the held torch's flame (0130 phase 4: the same
@@ -911,6 +922,7 @@ mod tests {
             billboard: None,
             alpha_anim: None,
             rgb_anim: None,
+            rgb_seq: None,
             uv_anim: None,
             uv_seq: None,
             uv_rot_seq: None,
diff --git a/crates/benilla-app/src/entities/spell_fx/mod.rs b/crates/benilla-app/src/entities/spell_fx/mod.rs
index 925f2617..bb3ecceb 100644
--- a/crates/benilla-app/src/entities/spell_fx/mod.rs
+++ b/crates/benilla-app/src/entities/spell_fx/mod.rs
@@ -178,18 +178,6 @@ pub(crate) struct FxMaterials<'a> {
     pub(crate) table: &'a mut benilla_world::mat_anim_table::MatAnimTable,
 }
 
-/// This part's four baked texture-transform channels, in the shape the engine's effect lane takes
-/// them (`FxUvLoops::any` is the "does it animate at all" test — a scale-only transform and a
-/// dead-slot-0 translation each answer `None` to the obvious channel).
-fn part_uv_loops(part: &EntityPart) -> benilla_world::doodad_anim::FxUvLoops {
-    benilla_world::doodad_anim::FxUvLoops {
-        seqs: part.uv_seq.clone(),
-        single: part.uv_anim.clone(),
-        rot: part.uv_rot_seq.clone(),
-        scale: part.uv_scale_seq.clone(),
-    }
-}
-
 /// Resolve one part's material for a NEW effect instance. The shared handle, unless a channel has
 /// to run **per instance** — an animated M2Color RGB (decision 0271) or a texture transform
 /// (decision 2282) — and then a clone of it, seeded at each live loop's first key and registered
@@ -201,7 +189,7 @@ fn fx_part_material(
     host: Entity,
     mats: &mut FxMaterials,
 ) -> Handle<WowModelMaterial> {
-    let loops = part_uv_loops(part);
+    let loops = part.uv_loops();
     if part.rgb_anim.is_none() && !loops.any() {
         return part.material.clone();
     }
diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs
index fa86c6ea..eb7252fa 100644
--- a/crates/benilla-app/src/game_plugins.rs
+++ b/crates/benilla-app/src/game_plugins.rs
@@ -834,6 +834,16 @@ pub(crate) mod schedule_tests {
     /// - **2282:** the three fx attaches against the mat-anim tick and its probe, over
     ///   `MatAnimTable`/`UvAnimMaterials` — immaterial by construction, because attach writes
     ///   the rows a tick would, off the same clock.
+    /// - **2295:** the same two readers against `entities::update_display_models` and
+    ///   `entities::attach::attach_entity_visuals`, over the same two resources, now that the
+    ///   entity lane registers its own texture transform. **+4**, measured pair by pair on the
+    ///   rebased tree rather than assumed additive — both writers already held
+    ///   `Assets<WowModelMaterial>`, so most of the systems they newly meet were already
+    ///   ambiguous against them for another reason, and `redress_player_looks` takes the
+    ///   identical three resources and adds no pair at all. Immaterial for 2282's reason plus
+    ///   one: a display is built ONCE, the frame its asset lands, and a row left unwritten for
+    ///   a frame reads as the material's own built seed — the batch's authored `t = 0`, not a
+    ///   wrong value — because the same call seeds `sun_scale.zw` at the loop's opening.
     ///
     /// **3,280 (decision 2288)** — the one query cache: a read that asks marks its miss through
     /// `&self`, so a feed that only resolves a name or a template holds the owner shared, and
@@ -844,7 +854,7 @@ pub(crate) mod schedule_tests {
     /// Raising this ceiling is a claim that a new undeclared order is acceptable; make it with
     /// the reason, or declare the order instead (`.after`, a set, a `chain`). If the pair is
     /// about a resource that commutes by construction, the claim belongs in [`Classes`].
-    const UPDATE_ACTIONABLE_CEILING: usize = 3_280;
+    const UPDATE_ACTIONABLE_CEILING: usize = 3_284;
     const UPDATE_ACTIONABLE_SLACK: usize = 40;
 
     fn ratchet(what: &str, n: usize, ceiling: usize, slack: usize) {
diff --git a/crates/benilla-app/tests/world_api_wall.rs b/crates/benilla-app/tests/world_api_wall.rs
index deaa912b..a41c5369 100644
--- a/crates/benilla-app/tests/world_api_wall.rs
+++ b/crates/benilla-app/tests/world_api_wall.rs
@@ -449,7 +449,7 @@ fn is_instrument_consumer(rel: &str) -> bool {
 /// registration without a row, or a row without a registration, is that same shape. One verb
 /// cannot be half-taken. It is also why the three pieces went back to `pub(crate)` in the same
 /// commit, which is the rare crossing that *lowers* the surface it replaces.
-/// And 183 → 184: `doodad_anim::FxUvLoops`, the argument of the verb above. A texture transform is
+/// And 183 → 184: `doodad_anim::UvLoops`, the argument of the verb above. A texture transform is
 /// ONE authored record with four baked channels — 1408's two translation spellings plus 2019's
 /// per-slot rotation and scaling — and which of them a batch fills is not a thing the caller gets
 /// to reason about: a scale-only transform (`Spells\GroundingTotem_Impact.mdx`) and a
@@ -459,7 +459,36 @@ fn is_instrument_consumer(rel: &str) -> bool {
 /// in the engine, where the bake's rules live, instead of copied into the effect attach where they
 /// would drift. Four positional `Option`s would have been the alternative, and swapping two of
 /// them is a silent wrong-channel bug the compiler cannot see.
-const CEILING: usize = 184;
+/// And 184 → 186, both for the ENTITY lane (decision 2295), which is the same crossing 2282 made
+/// for the effect lane and made for the same reason.
+/// `doodad_anim::register_entity_uv` is the second PUBLISH verb on this lane: put a unit /
+/// GameObject / held-item batch material on the UV lane, picking the shared clock or the
+/// instance's play head from the authored record rather than making the caller reason about it.
+/// It is a separate verb from `register_fx_uv` and not a flag on it because the two lanes differ
+/// in the one thing a caller cannot get right by accident — an effect's clocks are measured from
+/// its own attach (0856/0858) and a resident entity's are the scene's — and a boolean spelling of
+/// that would read as a preference.
+/// `model_render::EntityUvLane` is the argument `entity_variants` grew, and the crossing it buys
+/// is the point of the decision: building an entity batch's material and putting it on the lane
+/// are ONE act, so the engine takes the registry and the delta table *in the same call* instead of
+/// handing back six handles and trusting the game to register them. That is 2038's law spelled in
+/// the signature — a `play_uv` flip without a registration freezes every entity batch at its first
+/// key instead of its identity, which is a different wrong frame and not a fix — and it is why the
+/// lane is a bundle rather than three arguments a caller can pass two of.
+/// And 186 → 189, the second half of 2295 — the ONE entity population that needs a material of
+/// its own rather than the batch's, which the dressing path clones and registers because the
+/// clone has to exist before the part's interior and fade records are built from it.
+/// `doodad_anim::AnimMatPart` is the draw-scan marker, and it crosses for the reason 1375 put it
+/// at the spawn site in the first place: the marker and the registration are one predicate, and
+/// the game is where an entity part is spawned. The engine cannot insert it — it does not know
+/// an entity part exists — and a lane that let the two drift is 2038's three frozen days.
+/// `doodad_anim::register_tint` and `doodad_anim::TintLoop` are the tint channel's twins of the
+/// UV verbs above, for the same five batches on three GameObject models: `G_FreezingTrap`'s glow
+/// card, `OrgrimmarPentagram`, `ScholomanceCrystalBall01` — four of whose five batches bake
+/// **nothing** in file slot 0, so a shared material can only ever seed white however faithfully it
+/// is ticked. They were already `pub` for the world streamer; what crosses here is the game naming
+/// them, and it is the same crossing the UV half makes one line up.
+const CEILING: usize = 189;
 
 /// How far under [`CEILING`] the real count may sit before this test asks for the ceiling to be
 /// lowered. Slack, not tolerance: it keeps a single closure from failing the gate, while making it
diff --git a/crates/benilla-formats/src/bin/benilla-extract/main.rs b/crates/benilla-formats/src/bin/benilla-extract/main.rs
index f34c83d0..537cf192 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/main.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/main.rs
@@ -493,9 +493,9 @@ enum Command {
     ///
     /// Decision 0271 deferred this channel on the claim that "no effect model in the current
     /// corpus needs it"; this is that claim, made countable — it is what 2282 read to size the
-    /// missing scroll, and it is how the same question is re-asked of the lanes that still run
-    /// none of it (the unit and GameObject batches, which `entity_variants` still builds with
-    /// `play_uv = false`). It asks the **bake**, not a transcription of it: a batch is in scope
+    /// missing scroll, and it is how the same question was re-asked of the unit / GameObject /
+    /// held-item corpus that 2295 then fixed (`entityuvscan`, its twin). It asks the **bake**,
+    /// not a transcription of it: a batch is in scope
     /// exactly when `tex_anim` emitted a loop on any of the three channels, the same test the
     /// lanes that DO run them use (`ui_models` 2019, `spell_fx` 2282).
     ///
@@ -523,6 +523,83 @@ enum Command {
         /// models if omitted.
         prefix: Option<String>,
     },
+    /// Sweep every model the **ENTITY lane** can render — every `CreatureDisplayInfo` →
+    /// `CreatureModelData` body (NPCs, critters, mounts, and every PLAYER, which resolves through
+    /// the same chain, decision 0041), every `GameObjectDisplayInfo` model, every
+    /// `ItemDisplayInfo` left/right model joined to the `Item\ObjectComponents\` folder the
+    /// archives actually hold it in, and the corpse lane's `<Race><Sex>DeathSkeleton` bone piles —
+    /// and census the batches whose **texture transform animates**, then classify each by what a
+    /// consumer that runs NONE of it renders.
+    ///
+    /// The twin of `Fxuvscan`, asked of the corpus that record's fix did NOT reach. Decision 2282
+    /// gave the spell-effect lane its texture transform and named this as its first deferral:
+    /// `model_render::batch::Materials::entity_variants` passed `play_uv = false`, and `build`
+    /// does `play_uv.then_some(sub.uv_anim.as_ref()).flatten()` — so every unit, player,
+    /// GameObject and held-item batch was handed no loop and drew its authored UVs, untransformed,
+    /// for ever. Nobody had measured how much content that is; this is that measurement, it is
+    /// what sized **decision 2295**, which closed it, and it shares `fxuvscan`'s whole per-batch
+    /// reader (`uv_batch`) so the two corpora cannot be judged by two different rules. It stays
+    /// because the census is how the claim "this lane needs no channel" is kept checkable — which
+    /// is the one thing 0271's deferral was missing.
+    ///
+    /// **Read the corpus from the tables, never from a path prefix.** "The path looks broken" and
+    /// "the path is reachable" are different questions and only the second one is worth a session
+    /// (2282's own closing note). A held item's directory is not even a column — the equipment lane
+    /// picks `Weapon`/`Shield`/`Shoulder`/`Head`/`Ammo`/`Quiver` from the slot the item is worn in
+    /// — so the sweep asks the archives which folder holds each display's basename, and expands a
+    /// helm stem into its sixteen per-race/sex files the way the attach does.
+    ///
+    /// The classes are `fxuvscan`'s, judged the same way — from the texture's own alpha through the
+    /// batch's authored address mode (INVISIBLE / NEVER / FROZEN / HELD / UNKNOWN; that command's
+    /// doc is where they are explained) — with one thing this corpus adds: a CREATURE batch's
+    /// `Monster1/2/3` sheet is **blank in the M2** and filled per display from
+    /// `CreatureDisplayInfo.textureVariation`, so one batch has as many sheets as the model has
+    /// skins and the verdict is asked once per skin. A character composite (body atlas, hair,
+    /// object skin) has no authored sheet at all and reads UNKNOWN, which is the honest answer
+    /// rather than a silent pass.
+    ///
+    /// **The load-bearing column is the CLOCK**, because it decides the SHAPE of the fix and not
+    /// merely its size:
+    ///
+    /// - **GSEQ** — every live loop rides a global sequence, a free-running per-scene clock the
+    ///   reference anchors once per instance at attach. One shared material uniform is faithful
+    ///   there; that is 0136 choice 1's lane, already built.
+    /// - **BAND** — every live loop rides its sequence band, i.e. the instance's own play head. Two
+    ///   units playing different animations, or the same one at different phases, are at different
+    ///   offsets, and no shared uniform can serve both: that is 2282's per-instance `UvLoop`.
+    /// - **MIXED** / **HOLD** — the batch's channels disagree, or it is keyed to a constant
+    ///   non-identity offset that needs a seed and no clock at all.
+    ///
+    /// Each affected batch prints its three channels (translation / rotation / scaling — a sweep
+    /// that looked only at translation would have missed `GroundingTotem_Impact` entirely, which is
+    /// scale-only), its per-axis texel reasoning, both frozen verdicts, its clock, which file
+    /// sequence slots carry the keys and what those sequences are *called*, and — where the bake
+    /// refused the shared lane — `uvslotscan`'s own `uniform()` verdict for the same set. The
+    /// report closes with every affected model sorted by POPULATION: how many table rows can put it
+    /// on screen, which is the difference between one gnome terminal and every murloc in the game.
+    ///
+    /// **And then the same corpus again for the M2COLOR TINT**, because the UV channel is not the
+    /// only one this lane drops. `build` passes `sub.rgb_anim.as_ref()` *unconditionally* — there
+    /// is no `play_rgb` to flip — so a tint-animating entity batch is seeded at the loop's first
+    /// key and then never re-sampled, because `doodad_anim::register_tint`'s only call sites (like
+    /// `register_uv`'s) are in the world streamer's `assemble.rs`. The hole is the missing
+    /// REGISTRATION, not a missing argument, which is why flipping `play_uv` alone would only
+    /// trade one frozen frame for another.
+    ///
+    /// A tint is a **multiply**, so its failure mode is the wrong colour rather than missing
+    /// geometry, and the classes say how wrong: BLACK (the frozen tint kills the batch), STRONG,
+    /// SLIGHT, NEGLIGIBLE — bands over one printed number, the worst per-channel distance between
+    /// the frozen value and anything the loop reaches. Two qualifications the raw count would
+    /// overstate without: a batch whose slot 0 bakes nothing seeds **white**, so it is the right
+    /// colour until a later slot's animation plays and wrong only *during* it (the `slots` line
+    /// names which); and the **ALPHA** channel is counted beside them precisely because this lane
+    /// DOES serve it — `attach::dress::spawn_part` gives every part a `MatAnim` that
+    /// `sample_mat_anim` ticks per instance. One of the three material-animation channels runs.
+    Entityuvscan {
+        /// Internal-path prefix filter (e.g. `creature`), case-insensitive; all reachable entity
+        /// models if omitted.
+        prefix: Option<String>,
+    },
     /// Sweep every `.m2` (optionally under a path prefix) and census the batches whose texture
     /// coordinates are **GENERATED, not authored** — the sphere-map environment stages
     /// (`texture_unit_lookup[texCoordSet] > 2`, the reference's gate at `0x70b8bd`). Such a batch
@@ -982,6 +1059,7 @@ fn main() -> Result<()> {
         Command::Seqclockscan { prefix } => scan::seqclockscan(&mut chain, prefix.as_deref())?,
         Command::Uvwrapscan { prefix } => scan::uvwrapscan(&mut chain, prefix.as_deref())?,
         Command::Fxuvscan { prefix } => scan::fxuvscan(&mut chain, prefix.as_deref())?,
+        Command::Entityuvscan { prefix } => scan::entityuvscan(&mut chain, prefix.as_deref())?,
         Command::Envmapscan { prefix } => scan::envmapscan(&mut chain, prefix.as_deref())?,
         Command::Texmodescan { prefix } => scan::texmodescan(&mut chain, prefix.as_deref())?,
         Command::Fxordercensus { prefix } => scan::fxordercensus(&mut chain, prefix.as_deref())?,
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan/material.rs b/crates/benilla-formats/src/bin/benilla-extract/scan/material.rs
index a4b541db..9c95a570 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/material.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/material.rs
@@ -10,12 +10,15 @@
 //! `fxuvscan` is the intersection of the first two, asked of one corpus: the spell-effect models,
 //! whose animated texture transform decides — through their CLAMP-authored UVs — whether a
 //! consumer that runs none of it loses the batch's motion or its whole existence. It sized
-//! decision 2282, which built the consumer; it stays the way that question is asked of the lanes
-//! that still run none of it.
+//! decision 2282, which built the consumer; it stays the way that question is asked at all — and
+//! `entityuvscan` is that same question asked of the unit / GameObject / held-item corpus, which
+//! sized decision 2295. Both lanes run their transform today; what the two scans are for is
+//! keeping "this lane needs no channel" a countable claim rather than an assumed one. They share
+//! their whole per-batch reader.
 
 use std::collections::BTreeMap;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use benilla_formats::{Chain, KeyAnim, SeqLoops};
 
 /// Sweep every `.m2` (under `prefix`, if given) and list the models whose MATERIAL table authors
@@ -894,6 +897,12 @@ pub fn uvslotscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
 // ---------------------------------------------------------------------------
 // fxuvscan — what the SPELL-EFFECT corpus's animated texture transforms render
 // for a consumer that runs none of them.
+//
+// Everything down to `uv_batch` is shared with `entityuvscan` below, which asks
+// the identical question of the corpus 2282's fix did NOT reach. The sheet
+// decode, the two frozen states, the per-axis texel reasoning and the five
+// classes live here once on purpose: two sweeps that classified the same batch
+// by two slightly different rules would be worse than one sweep.
 // ---------------------------------------------------------------------------
 
 /// How many spells print per INVISIBLE model before the rest are counted.
@@ -1256,6 +1265,245 @@ fn fx_box(
     out
 }
 
+/// Does this batch's texture transform animate? The UI lane's own test, verbatim: any of the three
+/// channels baked to something ([`benilla_formats::RenderSubmesh::uv_anim`] and the three
+/// per-sequence sets). Shared, so the two sweeps cannot drift into asking it differently.
+fn uv_keyed(sub: &benilla_formats::RenderSubmesh) -> bool {
+    sub.uv_anim.is_some()
+        || sub.uv_seq.is_some()
+        || sub.uv_rot_seq.is_some()
+        || sub.uv_scale_seq.is_some()
+}
+
+/// Does this model author M2 blend mode **3** (`NoAlphaAdd`, `ONE/ONE`) anywhere?
+///
+/// The bake folds modes 3 and 4 into one `Blend` + `additive` pair, and no `RenderSubmesh` carries
+/// the source material back (the billboard split means batches are not even 1:1 with skin batches),
+/// so the question is asked of the model's MATERIAL TABLE — the same raw read `blendscan` does
+/// (count/ofs at `0x84`, 4-byte `{u16 flags, u16 blend}`). A model with no mode-3 material has
+/// alpha-gated additives and the alpha test is exact; one that has any gets the stricter
+/// alpha-or-RGB test on its additive batches, which can only make INVISIBLE harder to claim.
+fn authors_no_alpha_add(bytes: &[u8]) -> bool {
+    let at = |o: usize| -> Option<u32> {
+        Some(u32::from_le_bytes(bytes.get(o..o + 4)?.try_into().ok()?))
+    };
+    match (at(0x84), at(0x88)) {
+        (Some(n), Some(ofs)) => (0..n as usize).any(|i| {
+            let o = ofs as usize + i * 4;
+            bytes
+                .get(o + 2..o + 4)
+                .is_some_and(|b| u16::from_le_bytes([b[0], b[1]]) == 3)
+        }),
+        _ => false,
+    }
+}
+
+/// One animating batch's whole texture-transform read — the per-batch body [`fxuvscan`] and
+/// [`entityuvscan`] share, so the two sweeps cannot answer the same question differently.
+///
+/// The caller supplies the sheet path because the two corpora do not resolve it the same way: an
+/// effect model's batch names its own `.blp`, while a CREATURE batch's `Monster1/2/3` slot is blank
+/// in the M2 and filled per display from `CreatureDisplayInfo.textureVariation` — so the same batch
+/// has as many sheets as the model has skins, and the visibility question has to be asked of each.
+struct UvBatch {
+    /// The verdict under the seed a `play_uv = false` lane renders at (the identity).
+    class: FxClass,
+    /// The verdict under the track's first key — what the same batch becomes on a lane that hands
+    /// `model_material` the loop but never ticks it.
+    key_class: FxClass,
+    /// `uv_anim.sample(0.0)` — the translation seed, `[0, 0]` when the shared loop is absent.
+    seed: [f32; 2],
+    /// The report block, in print order.
+    lines: Vec<String>,
+}
+
+/// Read one batch's texture transform — see [`UvBatch`]. The caller has already established that
+/// the transform is keyed ([`uv_keyed`]) and that the batch has UVs to transform.
+fn uv_batch(
+    sheets: &mut BTreeMap<String, Option<Sheet>>,
+    chain: &mut Chain,
+    sub: &benilla_formats::RenderSubmesh,
+    bi: usize,
+    tex: Option<&str>,
+    no_alpha_add: bool,
+) -> UvBatch {
+    let ext = |axis: usize| {
+        sub.uvs.iter().fold((f32::MAX, f32::MIN), |(lo, hi), t| {
+            (lo.min(t[axis]), hi.max(t[axis]))
+        })
+    };
+    let (au, av) = (ext(0), ext(1));
+    let slots = fx_slots(sub);
+    let moves = (0..slots).any(|s| fx_period(sub, s) > 0.0);
+
+    // THE TWO FROZEN STATES, because our codebase has two seeding conventions and they
+    // are not the same picture:
+    //
+    // - **identity** — the offset an effect part actually renders at. Its material is
+    //   built by `model_render::batch::Materials::entity_variants`, whose `play_uv` is
+    //   `false`, so `model_material` is handed no loop and seeds `sun_scale.zw = (0, 0)`:
+    //   the batch draws its AUTHORED UVs, untransformed. This is the primary verdict.
+    // - **first key** — `uv_anim.sample(0.0)`, what the same builder seeds when a lane
+    //   DOES hand it the loop (the doodad and off-world lanes). Reported beside it,
+    //   because a fix that wires the loop in without ticking it lands the batch here.
+    //
+    // Rotation and scale are at the identity in both: the translation seed is the only
+    // transform channel a shared material carries at all (the affine pair is the UI
+    // lane's per-pane table row, decision 2019).
+    let seed = sub.uv_anim.as_ref().map_or([0.0, 0.0], |a| a.sample(0.0));
+    let (fu, fv) = fx_box(au, av, [0.0, 0.0], [0.0, 0.0, 0.0, 1.0], [1.0, 1.0]);
+    let (ku, kv) = fx_box(au, av, seed, [0.0, 0.0, 0.0, 1.0], [1.0, 1.0]);
+
+    // ANIMATED REACH. The union over every slot and a uniform sweep of its loop — an
+    // over-approximation by construction, so "nothing painted here either" is a claim the
+    // geometry cannot contradict.
+    let mut ru = (f32::MAX, f32::MIN);
+    let mut rv = (f32::MAX, f32::MIN);
+    for slot in 0..slots {
+        let period = fx_period(sub, slot);
+        for i in 0..FX_ANIM_SAMPLES {
+            let t = period * i as f32 / (FX_ANIM_SAMPLES - 1) as f32;
+            let (tr, q, sc) = fx_state(sub, slot, t);
+            let (bu, bv) = fx_box(au, av, tr, q, sc);
+            ru = (ru.0.min(bu.0), ru.1.max(bu.1));
+            rv = (rv.0.min(bv.0), rv.1.max(bv.1));
+        }
+    }
+
+    let sheet = tex.and_then(|p| fx_sheet(sheets, chain, p));
+    let reads_alpha = matches!(
+        sub.blend,
+        benilla_formats::ModelBlend::Blend | benilla_formats::ModelBlend::AlphaTest
+    );
+    let opaque = sub.blend == benilla_formats::ModelBlend::Opaque;
+    let with_rgb = sub.additive && no_alpha_add;
+    let (frozen_a, key_a, anim_a, dims) = match sheet {
+        Some(s) => (
+            s.paint(fu, fv, sub.wrap_x, sub.wrap_y, with_rgb),
+            s.paint(ku, kv, sub.wrap_x, sub.wrap_y, with_rgb),
+            s.paint(ru, rv, sub.wrap_x, sub.wrap_y, with_rgb),
+            format!("{}x{}", s.w, s.h),
+        ),
+        None => (0, 0, 0, "—".to_string()),
+    };
+    // One rule, run twice — once per frozen state, so the two verdicts cannot drift apart.
+    let verdict = |painted: u8| {
+        if !moves {
+            FxClass::Held
+        } else if opaque {
+            FxClass::Frozen
+        } else if !reads_alpha || sheet.is_none() {
+            FxClass::Unknown
+        } else if painted > 0 {
+            FxClass::Frozen
+        } else if anim_a > 0 {
+            FxClass::Invisible
+        } else {
+            FxClass::Never
+        }
+    };
+    let class = verdict(frozen_a);
+    let key_class = verdict(key_a);
+
+    let chans = |sub: &benilla_formats::RenderSubmesh| {
+        let n = |on: bool, s: &'static str| if on { s } else { "—" };
+        format!(
+            "{}{}{}",
+            n(sub.uv_anim.is_some() || sub.uv_seq.is_some(), "T"),
+            n(sub.uv_rot_seq.is_some(), "R"),
+            n(sub.uv_scale_seq.is_some(), "S"),
+        )
+    };
+    // The per-axis reasoning, read off the TEXELS rather than off the span: a CLAMP axis
+    // whose frozen span runs past an edge samples that edge's texel for every bit of it
+    // past the edge, so a span like `[+0.951..+1.950]` over a 16-texel sheet is not
+    // "mostly outside" — it is column 15, alone, for its whole length. That collapse is the
+    // whole mechanism, so the line names it.
+    let axis = |wrap: bool, a: (f32, f32), f: (f32, f32), n: u32| {
+        let (texels, verdict) = match n {
+            0 => ("—".to_string(), "no sheet"),
+            n => {
+                let r = Sheet::axis(f.0, f.1, n, wrap);
+                let edge_only = !wrap
+                    && r.len() == 1
+                    && r[0].0 == r[0].1
+                    && (r[0].0 == 0 || r[0].0 == n - 1)
+                    && (f.0 < 0.0 || f.1 > 1.0);
+                (
+                    r.iter()
+                        .map(|&(x, y)| format!("{x}..{y}"))
+                        .collect::<Vec<_>>()
+                        .join(","),
+                    if wrap {
+                        "wraps"
+                    } else if f.1 <= 0.0 || f.0 >= 1.0 {
+                        "WHOLLY OUTSIDE 0..1 — the border texel, alone"
+                    } else if edge_only {
+                        "CLAMPED TO ONE BORDER TEXEL for its whole length"
+                    } else {
+                        "reaches the sheet"
+                    },
+                )
+            }
+        };
+        format!(
+            "{:<6} authored [{:+.3}..{:+.3}]  frozen [{:+.3}..{:+.3}] -> texels {:<7} {}",
+            if wrap { "REPEAT" } else { "CLAMP" },
+            a.0,
+            a.1,
+            f.0,
+            f.1,
+            texels,
+            verdict,
+        )
+    };
+    let (tw, th) = sheet.map_or((0, 0), |s| (s.w, s.h));
+    let mut lines: Vec<String> = Vec::new();
+    lines.push(format!(
+        "  batch {bi:>3}  {:?}{}  {} verts  chans {}  {} slot(s)  tex {} {dims}{}",
+        sub.blend,
+        if sub.additive { " additive" } else { "" },
+        sub.positions.len(),
+        chans(sub),
+        slots,
+        tex.unwrap_or("NONE"),
+        if with_rgb {
+            "  [model authors NoAlphaAdd — judged on alpha OR rgb]"
+        } else {
+            ""
+        },
+    ));
+    lines.push(format!("      u  {}", axis(sub.wrap_x, au, fu, tw)));
+    lines.push(format!("      v  {}", axis(sub.wrap_y, av, fv, th)));
+    lines.push(format!(
+        "      frozen@identity   alpha max {frozen_a:>3}/255  => {}   \
+         [a lane built with `play_uv = false`: the AUTHORED UVs, untransformed]",
+        class.label(),
+    ));
+    lines.push(format!(
+        "      frozen@first-key  alpha max {key_a:>3}/255  => {}   \
+         seed [{:+.4},{:+.4}] u[{:+.3}..{:+.3}] v[{:+.3}..{:+.3}]",
+        key_class.label(),
+        seed[0],
+        seed[1],
+        ku.0,
+        ku.1,
+        kv.0,
+        kv.1,
+    ));
+    lines.push(format!(
+        "      animated          alpha max {anim_a:>3}/255        \
+         u[{:+.3}..{:+.3}] v[{:+.3}..{:+.3}] over {} sample(s) x {slots} slot(s)",
+        ru.0, ru.1, rv.0, rv.1, FX_ANIM_SAMPLES,
+    ));
+    UvBatch {
+        class,
+        key_class,
+        seed,
+        lines,
+    }
+}
+
 /// One classified batch — the row the class listings and the spell join are both built from.
 struct FxHit {
     /// The corpus key (lowercased `.m2`), so the reach map joins straight onto it.
@@ -1311,227 +1559,39 @@ pub fn fxuvscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
             continue;
         };
         batches += subs.len() as u64;
-        // Does this model author M2 blend mode **3** (`NoAlphaAdd`, `ONE/ONE`) anywhere? The bake
-        // folds modes 3 and 4 into one `Blend` + `additive` pair, and no `RenderSubmesh` carries the
-        // source material back (the billboard split means batches are not even 1:1 with skin
-        // batches), so the question is asked of the model's MATERIAL TABLE — the same raw read
-        // `blendscan` does (count/ofs at `0x84`, 4-byte `{u16 flags, u16 blend}`). A model with no
-        // mode-3 material has alpha-gated additives and the alpha test is exact; one that has any
-        // gets the stricter alpha-or-RGB test on its additive batches, which can only make
-        // INVISIBLE harder to claim.
-        let no_alpha_add = {
-            let at = |o: usize| -> Option<u32> {
-                Some(u32::from_le_bytes(bytes.get(o..o + 4)?.try_into().ok()?))
-            };
-            match (at(0x84), at(0x88)) {
-                (Some(n), Some(ofs)) => (0..n as usize).any(|i| {
-                    let o = ofs as usize + i * 4;
-                    bytes
-                        .get(o + 2..o + 4)
-                        .is_some_and(|b| u16::from_le_bytes([b[0], b[1]]) == 3)
-                }),
-                _ => false,
-            }
-        };
+        let no_alpha_add = authors_no_alpha_add(&bytes);
 
         let mut lines: Vec<String> = Vec::new();
         for (bi, sub) in subs.iter().enumerate() {
-            // The UI lane's own "does this batch's transform animate" test, verbatim: any of the
-            // three channels baked to something.
-            let animated = sub.uv_anim.is_some()
-                || sub.uv_seq.is_some()
-                || sub.uv_rot_seq.is_some()
-                || sub.uv_scale_seq.is_some();
-            if !animated || sub.uvs.is_empty() {
+            if !uv_keyed(sub) || sub.uvs.is_empty() {
                 continue;
             }
             anim_batches += 1;
-
-            let ext = |axis: usize| {
-                sub.uvs.iter().fold((f32::MAX, f32::MIN), |(lo, hi), t| {
-                    (lo.min(t[axis]), hi.max(t[axis]))
-                })
-            };
-            let (au, av) = (ext(0), ext(1));
-            let slots = fx_slots(sub);
-            let moves = (0..slots).any(|s| fx_period(sub, s) > 0.0);
-
-            // THE TWO FROZEN STATES, because our codebase has two seeding conventions and they
-            // are not the same picture:
-            //
-            // - **identity** — the offset an effect part actually renders at. Its material is
-            //   built by `model_render::batch::Materials::entity_variants`, whose `play_uv` is
-            //   `false`, so `model_material` is handed no loop and seeds `sun_scale.zw = (0, 0)`:
-            //   the batch draws its AUTHORED UVs, untransformed. This is the primary verdict.
-            // - **first key** — `uv_anim.sample(0.0)`, what the same builder seeds when a lane
-            //   DOES hand it the loop (the doodad and off-world lanes). Reported beside it,
-            //   because a fix that wires the loop in without ticking it lands the batch here.
-            //
-            // Rotation and scale are at the identity in both: the translation seed is the only
-            // transform channel a shared material carries at all (the affine pair is the UI
-            // lane's per-pane table row, decision 2019).
-            let seed = sub.uv_anim.as_ref().map_or([0.0, 0.0], |a| a.sample(0.0));
-            let (fu, fv) = fx_box(au, av, [0.0, 0.0], [0.0, 0.0, 0.0, 1.0], [1.0, 1.0]);
-            let (ku, kv) = fx_box(au, av, seed, [0.0, 0.0, 0.0, 1.0], [1.0, 1.0]);
-
-            // ANIMATED REACH. The union over every slot and a uniform sweep of its loop — an
-            // over-approximation by construction, so "nothing painted here either" is a claim the
-            // geometry cannot contradict.
-            let mut ru = (f32::MAX, f32::MIN);
-            let mut rv = (f32::MAX, f32::MIN);
-            for slot in 0..slots {
-                let period = fx_period(sub, slot);
-                for i in 0..FX_ANIM_SAMPLES {
-                    let t = period * i as f32 / (FX_ANIM_SAMPLES - 1) as f32;
-                    let (tr, q, sc) = fx_state(sub, slot, t);
-                    let (bu, bv) = fx_box(au, av, tr, q, sc);
-                    ru = (ru.0.min(bu.0), ru.1.max(bu.1));
-                    rv = (rv.0.min(bv.0), rv.1.max(bv.1));
-                }
-            }
-
-            let tex = sub.texture.as_deref();
-            let sheet = tex.and_then(|p| fx_sheet(&mut sheets, chain, p));
-            let reads_alpha = matches!(
-                sub.blend,
-                benilla_formats::ModelBlend::Blend | benilla_formats::ModelBlend::AlphaTest
+            let read = uv_batch(
+                &mut sheets,
+                chain,
+                sub,
+                bi,
+                sub.texture.as_deref(),
+                no_alpha_add,
             );
-            let opaque = sub.blend == benilla_formats::ModelBlend::Opaque;
-            let with_rgb = sub.additive && no_alpha_add;
-            let (frozen_a, key_a, anim_a, dims) = match sheet {
-                Some(s) => (
-                    s.paint(fu, fv, sub.wrap_x, sub.wrap_y, with_rgb),
-                    s.paint(ku, kv, sub.wrap_x, sub.wrap_y, with_rgb),
-                    s.paint(ru, rv, sub.wrap_x, sub.wrap_y, with_rgb),
-                    format!("{}x{}", s.w, s.h),
-                ),
-                None => (0, 0, 0, "—".to_string()),
-            };
-            // One rule, run twice — once per frozen state, so the two verdicts cannot drift apart.
-            let verdict = |painted: u8| {
-                if !moves {
-                    FxClass::Held
-                } else if opaque {
-                    FxClass::Frozen
-                } else if !reads_alpha || sheet.is_none() {
-                    FxClass::Unknown
-                } else if painted > 0 {
-                    FxClass::Frozen
-                } else if anim_a > 0 {
-                    FxClass::Invisible
-                } else {
-                    FxClass::Never
-                }
-            };
-            let class = verdict(frozen_a);
-            let key_class = verdict(key_a);
-            if class != key_class {
+            if read.class != read.key_class {
                 seed_disagrees += 1;
             }
             // A batch that draws today but at a picture the loop never opens at: the identity is
             // not the seed, so what is on screen is neither the animation nor its first frame.
-            if class == FxClass::Frozen && (seed[0] != 0.0 || seed[1] != 0.0) {
+            if read.class == FxClass::Frozen && (read.seed[0] != 0.0 || read.seed[1] != 0.0) {
                 misregistered += 1;
             }
-            *per_class.entry(class).or_default() += 1;
-            *per_key_class.entry(key_class).or_default() += 1;
+            *per_class.entry(read.class).or_default() += 1;
+            *per_key_class.entry(read.key_class).or_default() += 1;
             hits.push(FxHit {
                 key: key.clone(),
                 batch: bi,
-                class,
-                key_class,
+                class: read.class,
+                key_class: read.key_class,
             });
-
-            let chans = |sub: &benilla_formats::RenderSubmesh| {
-                let n = |on: bool, s: &'static str| if on { s } else { "—" };
-                format!(
-                    "{}{}{}",
-                    n(sub.uv_anim.is_some() || sub.uv_seq.is_some(), "T"),
-                    n(sub.uv_rot_seq.is_some(), "R"),
-                    n(sub.uv_scale_seq.is_some(), "S"),
-                )
-            };
-            // The per-axis reasoning, read off the TEXELS rather than off the span: a CLAMP axis
-            // whose frozen span runs past an edge samples that edge's texel for every bit of it
-            // past the edge, so a span like `[+0.951..+1.950]` over a 16-texel sheet is not
-            // "mostly outside" — it is column 15, alone, for its whole length. That collapse is the
-            // whole mechanism, so the line names it.
-            let axis = |wrap: bool, a: (f32, f32), f: (f32, f32), n: u32| {
-                let (texels, verdict) = match n {
-                    0 => ("—".to_string(), "no sheet"),
-                    n => {
-                        let r = Sheet::axis(f.0, f.1, n, wrap);
-                        let edge_only = !wrap
-                            && r.len() == 1
-                            && r[0].0 == r[0].1
-                            && (r[0].0 == 0 || r[0].0 == n - 1)
-                            && (f.0 < 0.0 || f.1 > 1.0);
-                        (
-                            r.iter()
-                                .map(|&(x, y)| format!("{x}..{y}"))
-                                .collect::<Vec<_>>()
-                                .join(","),
-                            if wrap {
-                                "wraps"
-                            } else if f.1 <= 0.0 || f.0 >= 1.0 {
-                                "WHOLLY OUTSIDE 0..1 — the border texel, alone"
-                            } else if edge_only {
-                                "CLAMPED TO ONE BORDER TEXEL for its whole length"
-                            } else {
-                                "reaches the sheet"
-                            },
-                        )
-                    }
-                };
-                format!(
-                    "{:<6} authored [{:+.3}..{:+.3}]  frozen [{:+.3}..{:+.3}] -> texels {:<7} {}",
-                    if wrap { "REPEAT" } else { "CLAMP" },
-                    a.0,
-                    a.1,
-                    f.0,
-                    f.1,
-                    texels,
-                    verdict,
-                )
-            };
-            let (tw, th) = sheet.map_or((0, 0), |s| (s.w, s.h));
-            lines.push(format!(
-                "  batch {bi:>3}  {:?}{}  {} verts  chans {}  {} slot(s)  tex {} {dims}{}",
-                sub.blend,
-                if sub.additive { " additive" } else { "" },
-                sub.positions.len(),
-                chans(sub),
-                slots,
-                tex.unwrap_or("NONE"),
-                if with_rgb {
-                    "  [model authors NoAlphaAdd — judged on alpha OR rgb]"
-                } else {
-                    ""
-                },
-            ));
-            lines.push(format!("      u  {}", axis(sub.wrap_x, au, fu, tw)));
-            lines.push(format!("      v  {}", axis(sub.wrap_y, av, fv, th)));
-            lines.push(format!(
-                "      frozen@identity   alpha max {frozen_a:>3}/255  => {}   \
-                 [a lane built with `play_uv = false`: the AUTHORED UVs, untransformed]",
-                class.label(),
-            ));
-            lines.push(format!(
-                "      frozen@first-key  alpha max {key_a:>3}/255  => {}   \
-                 seed [{:+.4},{:+.4}] u[{:+.3}..{:+.3}] v[{:+.3}..{:+.3}]",
-                key_class.label(),
-                seed[0],
-                seed[1],
-                ku.0,
-                ku.1,
-                kv.0,
-                kv.1,
-            ));
-            lines.push(format!(
-                "      animated          alpha max {anim_a:>3}/255        \
-                 u[{:+.3}..{:+.3}] v[{:+.3}..{:+.3}] over {} sample(s) x {slots} slot(s)",
-                ru.0, ru.1, rv.0, rv.1, FX_ANIM_SAMPLES,
-            ));
+            lines.extend(read.lines);
         }
         if !lines.is_empty() {
             anim_models += 1;
@@ -1560,7 +1620,7 @@ pub fn fxuvscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
     );
     println!(
         "  {anim_models} model(s) / {anim_batches} batch(es) carry a keyed TEXTURE TRANSFORM — \
-         the channel the spell-effect lane runs since 2282 and the unit lane still does not"
+         the channel the spell-effect lane has run since 2282 and the entity lane since 2295"
     );
     println!("    {:<10} {:>8} {:>9}", "", "identity", "first-key");
     for c in FxClass::ALL {
@@ -1581,7 +1641,7 @@ pub fn fxuvscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
     println!(
         "  the two columns are the two frozen states a non-running lane can be in: `identity` \
          is a material built with `play_uv = false` (the AUTHORED UVs — what the spell-effect \
-         lane drew before 2282, and what the unit lane still draws), `first-key` what the same \
+         lane drew before 2282 and the entity lane before 2295), `first-key` what the same \
          batch becomes on a lane that seeds `uv_anim.sample(0.0)` and never ticks it. \
          {seed_disagrees} batch(es) are classified differently by the two — read the per-batch \
          lines for which."
@@ -1728,3 +1788,1392 @@ pub fn fxuvscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
     }
     Ok(())
 }
+
+// ---------------------------------------------------------------------------
+// entityuvscan — what the UNIT / GAMEOBJECT / HELD-ITEM corpus's animated
+// texture transforms render on the lane that runs none of them.
+// ---------------------------------------------------------------------------
+
+/// How many display ids print per model before the rest are counted.
+const ENTITY_ID_ROWS: usize = 12;
+
+/// How many unreadable model paths print before the rest are counted.
+const ENTITY_UNREAD_ROWS: usize = 20;
+
+/// The `Item\ObjectComponents\<dir>\` folders an `ItemDisplayInfo` **left** model column can land
+/// in, and the kind label each one carries. The directory is NOT a column of the table: it is
+/// chosen by the slot the item is worn in (`entities::equipment::ensure_item_model`), which is a
+/// property of the *item*, not of the display — so a census asks the archives which of them
+/// actually holds the file.
+const ITEM_DIRS_L: [&str; 4] = ["Weapon", "Shield", "Shoulder", "Quiver"];
+
+/// …and of a **right** model column: the right pauldron, or an arrow/bullet.
+const ITEM_DIRS_R: [&str; 2] = ["Shoulder", "Ammo"];
+
+/// Helm files are per race and sex — `<stem>_<Ra><S>.m2`, prefix by race id, `M`/`F` by sex
+/// (`ensure_item_model`'s own table, pinned against the MPQ listing in decision 0074).
+const HELM_RACE_PREFIX: [&str; 8] = ["Hu", "Or", "Dw", "Ni", "Sc", "Ta", "Gn", "Tr"];
+
+/// One entity-lane model's place in the DBCs: every table row that can put it on screen, so a
+/// broken batch joins back to something a director can go and look at.
+#[derive(Default)]
+struct EntityReach {
+    /// The table's own spelling of the path (`.mdx`), for display.
+    path: String,
+    /// The `CreatureModelData` row ids naming it (normally one).
+    creature_models: std::collections::BTreeSet<u32>,
+    /// The `CreatureDisplayInfo` rows that reach it — the POPULATION number: one model reached by
+    /// 300 display rows is a different fix from one reached by 1.
+    creature_displays: Vec<u32>,
+    /// The playable `(race, sex)` bodies among those displays (`ChrRaces` cols 4/5 → the same
+    /// CreatureDisplayInfo chain a streamed unit takes, decision 0041), spelled as the glue does.
+    player_bodies: Vec<String>,
+    /// `GameObjectDisplayInfo` rows naming it.
+    go_displays: Vec<u32>,
+    /// `ItemDisplayInfo` rows naming it, and through which `Item\ObjectComponents\` join.
+    item_displays: BTreeMap<u32, std::collections::BTreeSet<&'static str>>,
+    /// The bone-pile skeletons (`<Race><Sex>DeathSkeleton`) — the corpse lane's own models, which
+    /// no display table names.
+    bones: Vec<String>,
+    /// Also named by the SPELL-VISUAL chain, i.e. already swept by `fxuvscan` and already running
+    /// its transform on the effect lane since 2282. Marked, never dropped: a model can be held in
+    /// a hand (this lane, frozen) and thrown as a missile (that lane, animated) on the same tick.
+    also_fx: bool,
+}
+
+impl EntityReach {
+    /// How many table rows can put this model on screen — the rough instance-population proxy.
+    fn rows(&self) -> usize {
+        self.creature_displays.len()
+            + self.go_displays.len()
+            + self.item_displays.len()
+            + self.bones.len()
+    }
+
+    /// The one-line join-back cell printed beside the model path.
+    fn cell(&self) -> String {
+        let ids = |v: &[u32]| {
+            let head: Vec<String> = v.iter().take(ENTITY_ID_ROWS).map(u32::to_string).collect();
+            match v.len().checked_sub(ENTITY_ID_ROWS).filter(|n| *n > 0) {
+                Some(rest) => format!("{} … +{rest}", head.join(",")),
+                None => head.join(","),
+            }
+        };
+        let mut parts: Vec<String> = Vec::new();
+        if !self.creature_displays.is_empty() {
+            parts.push(format!(
+                "creature model {} · {} display(s) {}",
+                self.creature_models
+                    .iter()
+                    .map(u32::to_string)
+                    .collect::<Vec<_>>()
+                    .join("·"),
+                self.creature_displays.len(),
+                ids(&self.creature_displays),
+            ));
+        }
+        if !self.player_bodies.is_empty() {
+            parts.push(format!("PLAYER body {}", self.player_bodies.join(",")));
+        }
+        if !self.go_displays.is_empty() {
+            parts.push(format!(
+                "gameobject {} display(s) {}",
+                self.go_displays.len(),
+                ids(&self.go_displays),
+            ));
+        }
+        if !self.item_displays.is_empty() {
+            let kinds: std::collections::BTreeSet<&str> = self
+                .item_displays
+                .values()
+                .flat_map(|k| k.iter().copied())
+                .collect();
+            parts.push(format!(
+                "item {} display(s) [{}] {}",
+                self.item_displays.len(),
+                kinds.into_iter().collect::<Vec<_>>().join("/"),
+                ids(&self.item_displays.keys().copied().collect::<Vec<_>>()),
+            ));
+        }
+        if !self.bones.is_empty() {
+            parts.push(format!("bone pile {}", self.bones.join(",")));
+        }
+        if self.also_fx {
+            parts.push("ALSO a spell-visual model (2282's lane runs its transform)".to_string());
+        }
+        parts.join("  ·  ")
+    }
+}
+
+/// The corpus, plus the counters that say what the sweep could not see.
+#[derive(Default)]
+struct EntityCorpus {
+    models: BTreeMap<String, EntityReach>,
+    /// `CreatureDisplayInfo` rows walked, and the `CreatureModelData` rows no display reaches
+    /// (unreachable content — counted, never swept).
+    creature_rows: usize,
+    creature_orphan_models: usize,
+    /// `GameObjectDisplayInfo` rows walked, and those naming a `.wmo` (no M2 batches to animate).
+    go_rows: usize,
+    go_wmo: usize,
+    /// `ItemDisplayInfo` model columns walked, and the two ways one can fail to reach a file: the
+    /// basename ships under an `Item\ObjectComponents\` folder this column is never joined to
+    /// (`item_other_dir` — every one of these is a thrown weapon named in BOTH columns, so the
+    /// model is already in the corpus through its left column and only the extra display-id join
+    /// is dropped), or nothing ships it at all (`item_absent` — a dead row, the shape `fxuvscan`
+    /// found in `SpellVisualEffectName`).
+    item_rows: usize,
+    item_other_dir: usize,
+    item_absent: usize,
+}
+
+/// Fold one model path into the corpus under [`crate::model_key`], keeping the table's own
+/// spelling for display.
+fn entity_record<'a>(
+    out: &'a mut BTreeMap<String, EntityReach>,
+    path: &str,
+) -> &'a mut EntityReach {
+    let e = out
+        .entry(crate::model_key(path.trim_start_matches(['\\', '/'])))
+        .or_default();
+    if e.path.is_empty() {
+        e.path = path.to_string();
+    }
+    e
+}
+
+/// Every model the ENTITY lane can render, walked from the tables that name one — never from a
+/// path prefix, because reachability is the whole question ("the path looks broken" and "the path
+/// is reachable" are different questions, 2282's own closing note).
+///
+/// Four sources, one per `build_parts` caller that is not the spell-effect lane:
+/// `CreatureDisplayInfo` → `CreatureModelData` (every NPC, critter, mount — and every PLAYER body,
+/// which resolves through the same chain, decision 0041), `GameObjectDisplayInfo`,
+/// `ItemDisplayInfo`'s two model columns joined to the `Item\ObjectComponents\` folder the archives
+/// actually hold them in, and the corpse lane's `<Race><Sex>DeathSkeleton` bone piles.
+fn entity_corpus(chain: &mut Chain) -> Result<EntityCorpus> {
+    let mut out = EntityCorpus::default();
+
+    // --- creatures, players, mounts, critters ---------------------------------------------
+    let creatures = benilla_formats::load_creature_catalog(chain).context("CreatureDisplayInfo")?;
+    let model_paths: BTreeMap<u32, String> = creatures
+        .sized_models()
+        .map(|(id, path, _)| (id, path.to_string()))
+        .collect();
+    let mut reached_models: std::collections::BTreeSet<u32> = std::collections::BTreeSet::new();
+    let mut display_model: BTreeMap<u32, u32> = BTreeMap::new();
+    for (display, model) in creatures.display_models() {
+        display_model.insert(display, model);
+        let Some(path) = model_paths.get(&model) else {
+            continue;
+        };
+        out.creature_rows += 1;
+        reached_models.insert(model);
+        let e = entity_record(&mut out.models, path);
+        e.creature_models.insert(model);
+        e.creature_displays.push(display);
+    }
+    out.creature_orphan_models = model_paths.len() - reached_models.len();
+
+    // --- the playable bodies, named as such, and the bone piles they leave ------------------
+    if let Ok(cc) = benilla_formats::CharCreateCatalog::load(chain) {
+        for race in 1..=u8::try_from(HELM_RACE_PREFIX.len()).unwrap_or(8) {
+            let Some(file) = cc.race_file(race).map(str::to_string) else {
+                continue;
+            };
+            for (sex, sex_name) in [(0u8, "Male"), (1, "Female")] {
+                if let Some(path) = cc
+                    .body_display(race, sex)
+                    .and_then(|d| display_model.get(&d))
+                    .and_then(|m| model_paths.get(m))
+                {
+                    entity_record(&mut out.models, &path.clone())
+                        .player_bodies
+                        .push(format!("{file}{sex_name}"));
+                }
+                // `0x5d673c`'s format string: the corpse lane's own model, named by no table.
+                let bones = format!(
+                    "World\\Generic\\PassiveDoodads\\DeathSkeletons\\{file}{sex_name}DeathSkeleton.mdx"
+                );
+                if chain.read_file(&crate::model_key(&bones)).is_ok() {
+                    entity_record(&mut out.models, &bones)
+                        .bones
+                        .push(format!("{file}{sex_name}"));
+                }
+            }
+        }
+    }
+
+    // --- GameObjects -----------------------------------------------------------------------
+    let gos = benilla_formats::load_gameobject_catalog(chain).context("GameObjectDisplayInfo")?;
+    let go_rows: Vec<(u32, String)> = gos.iter().map(|(id, p)| (id, p.to_string())).collect();
+    for (id, path) in go_rows {
+        out.go_rows += 1;
+        if !crate::model_key(&path).ends_with(".m2") {
+            out.go_wmo += 1;
+            continue;
+        }
+        entity_record(&mut out.models, &path).go_displays.push(id);
+    }
+
+    // --- held / worn item geometry ----------------------------------------------------------
+    // The archives decide which folder a display's basename lives in, because the table does not
+    // carry one: the equipment lane picks the directory from the slot the item is worn in.
+    let item_files: Vec<String> = super::m2_names(chain, Some("item\\objectcomponents"))?
+        .into_iter()
+        .map(|n| n.to_ascii_lowercase())
+        .collect();
+    let files: std::collections::HashSet<&str> = item_files.iter().map(String::as_str).collect();
+    // …and the same listing keyed by BASENAME, so an unjoinable column can say which of the two
+    // failures it is rather than being counted as one lump.
+    let by_base: std::collections::HashSet<&str> = item_files
+        .iter()
+        .filter_map(|f| f.rsplit_once('\\').map(|(_, b)| b))
+        .collect();
+    let items = benilla_formats::load_item_display_catalog(chain).context("ItemDisplayInfo")?;
+    let item_rows: Vec<(u32, [Option<String>; 2])> =
+        items.iter().map(|(id, d)| (id, d.model.clone())).collect();
+    for (id, model) in item_rows {
+        for (col, dirs) in [(0usize, &ITEM_DIRS_L[..]), (1, &ITEM_DIRS_R[..])] {
+            let Some(name) = model[col].as_deref() else {
+                continue;
+            };
+            out.item_rows += 1;
+            let mut placed = false;
+            let put = |out: &mut EntityCorpus, path: String, kind: &'static str| {
+                entity_record(&mut out.models, &path)
+                    .item_displays
+                    .entry(id)
+                    .or_default()
+                    .insert(kind);
+            };
+            for dir in dirs {
+                let path = format!("Item\\ObjectComponents\\{dir}\\{name}");
+                if files.contains(path.to_ascii_lowercase().as_str()) {
+                    put(&mut out, path, dir);
+                    placed = true;
+                }
+            }
+            // A HELM ships as sixteen per-race/sex files under one stem, and the display row names
+            // the stem alone — so the census expands it the way the attach does.
+            if col == 0 {
+                let stem = name.strip_suffix(".m2").unwrap_or(name);
+                for prefix in HELM_RACE_PREFIX {
+                    for letter in ['M', 'F'] {
+                        let path =
+                            format!("Item\\ObjectComponents\\Head\\{stem}_{prefix}{letter}.m2");
+                        if files.contains(path.to_ascii_lowercase().as_str()) {
+                            put(&mut out, path, "Head");
+                            placed = true;
+                        }
+                    }
+                }
+            }
+            if !placed {
+                if by_base.contains(name.to_ascii_lowercase().as_str()) {
+                    out.item_other_dir += 1;
+                } else {
+                    out.item_absent += 1;
+                }
+            }
+        }
+    }
+
+    // Every id list above is built by walking a HashMap, so it comes out in a different order
+    // every run. Sorted here, once, because an instrument whose report reshuffles cannot be
+    // diffed against its own previous output.
+    for e in out.models.values_mut() {
+        e.creature_displays.sort_unstable();
+        e.go_displays.sort_unstable();
+        e.player_bodies.sort();
+        e.bones.sort();
+    }
+
+    // --- the mark: which of these the spell-effect lane already runs -------------------------
+    if let (Ok(visuals), Ok(spells)) = (
+        benilla_formats::load_spell_visual_catalog(chain),
+        benilla_formats::load_spell_catalog(chain),
+    ) {
+        for key in fx_corpus(&visuals, &spells).keys() {
+            if let Some(e) = out.models.get_mut(key) {
+                e.also_fx = true;
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// Which clock one batch's keyed transform runs on — the question that decides the SHAPE of the
+/// fix, not just its size (0136 choice 1 versus 2282's per-instance lane).
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum UvClock {
+    /// Every live loop is clocked on a **global sequence**: a free-running per-scene ms clock the
+    /// reference anchors once per instance at attach (`gseq-anchor.md`, `CM2Model+0x68`). One
+    /// shared uniform on a free-running clock is faithful here — 0136's lane, unchanged.
+    Gseq,
+    /// Every live loop is clocked on its **sequence band**: the host's own playing-clip time, so
+    /// two instances playing different animations — or the same one at different phases — are at
+    /// different offsets. A shared uniform cannot be right for both.
+    Band,
+    /// The batch's three channels disagree: some global, some band.
+    Mixed,
+    /// Keyed but never moving — a constant non-identity hold (`period == 0`), which needs a seed
+    /// and no clock at all.
+    Hold,
+}
+
+impl UvClock {
+    const ALL: [Self; 4] = [Self::Gseq, Self::Band, Self::Mixed, Self::Hold];
+
+    fn label(self) -> &'static str {
+        match self {
+            Self::Gseq => "GSEQ",
+            Self::Band => "BAND",
+            Self::Mixed => "MIXED",
+            Self::Hold => "HOLD",
+        }
+    }
+
+    fn blurb(self) -> &'static str {
+        match self {
+            Self::Gseq => {
+                "every live loop rides a GLOBAL SEQUENCE — a free-running clock, so one shared \
+                 material uniform is faithful (0136 choice 1)"
+            }
+            Self::Band => {
+                "every live loop rides its SEQUENCE BAND — the instance's own play head, which a \
+                 shared uniform cannot serve (2282's per-instance lane)"
+            }
+            Self::Mixed => "the batch's channels disagree: some global-sequence, some band",
+            Self::Hold => {
+                "keyed but never moving — a constant offset that needs a seed, not a clock"
+            }
+        }
+    }
+}
+
+/// One transform channel's read of the clock question.
+#[derive(Default)]
+struct ChannelClock {
+    /// `[L.L]` per file sequence slot — `None` when the channel carries no per-slot set.
+    cell: Option<String>,
+    /// File slots whose loop is LIVE (`period > 0`).
+    live: Vec<usize>,
+    /// `true` for each live loop clocked on a global sequence.
+    gseq: Vec<bool>,
+    /// The leading live loop as the report prints it: `(period, wrap, gseq)`.
+    lead: Option<(f32, bool, bool)>,
+    /// The channel's one loop is the SHARED slot-0 bake — every sequence plays the same one.
+    uniform: bool,
+}
+
+impl ChannelClock {
+    /// `gseq 2.000s wrap` / `band 1.500s clamp` / `—`.
+    fn cell_text(&self) -> String {
+        match self.lead {
+            None if self.cell.is_none() => "—".to_string(),
+            None => "held".to_string(),
+            Some((period, wrap, gseq)) => format!(
+                "{} {period:.3}s {}",
+                if gseq { "gseq" } else { "band" },
+                if wrap { "wrap" } else { "clamp" },
+            ),
+        }
+    }
+}
+
+/// Read one channel's per-slot set (or its shared slot-0 twin, for the translation channel which is
+/// the only one that has one) the way the runtime reads it.
+fn channel_clock<V: AsRef<[f32]> + PartialEq>(
+    set: Option<&SeqLoops<V>>,
+    shared: Option<&KeyAnim<V>>,
+) -> ChannelClock {
+    let mut out = ChannelClock::default();
+    match set {
+        Some(s) => {
+            out.cell = Some(slot_cell(s.slots()));
+            for (i, l) in s.slots().iter().enumerate() {
+                let Some(l) = l.as_ref().filter(|l| l.period > 0.0) else {
+                    continue;
+                };
+                out.live.push(i);
+                out.gseq.push(l.gseq);
+                out.lead.get_or_insert((l.period, l.wrap, l.gseq));
+            }
+        }
+        None => {
+            if let Some(l) = shared {
+                out.uniform = true;
+                if l.period > 0.0 {
+                    out.gseq.push(l.gseq);
+                    out.lead = Some((l.period, l.wrap, l.gseq));
+                }
+            }
+        }
+    }
+    out
+}
+
+/// One classified entity batch — the row every listing and the population tail are built from.
+struct EntityHit {
+    key: String,
+    batch: usize,
+    class: FxClass,
+    key_class: FxClass,
+    clock: UvClock,
+    /// `T`/`R`/`S`, in that order, for the channels the bake keyed.
+    chans: [bool; 3],
+    /// The batch's translation lane: `true` when it carries a per-sequence set (`uv_seq`), which is
+    /// `uvslotscan`'s PER-PLACEMENT population; `false` when it keeps the shared slot-0 loop.
+    per_seq_trans: bool,
+    /// …and whether that shared loop is LIVE — `uvslotscan`'s "carry a LIVE loop there" count, the
+    /// number this sweep's corpus must be a subset of.
+    live_shared_trans: bool,
+}
+
+/// Sweep every model the UNIT / GAMEOBJECT / HELD-ITEM tables reach and census the batches whose
+/// texture transform animates — see the `Entityuvscan` command doc for the why.
+pub fn entityuvscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
+    let corpus = entity_corpus(chain)?;
+    let pfx = prefix.map(|p| p.to_ascii_lowercase().replace('/', "\\"));
+    let anim_names = benilla_formats::load_anim_data_catalog(chain).ok();
+    // Loaded once, beside the corpus, because the per-batch sheet question asks it per MODEL: a
+    // creature batch's `Monster1/2/3` slot is filled from the display's own texture variations.
+    let creatures = benilla_formats::load_creature_catalog(chain).unwrap_or_default();
+
+    let mut sheets: BTreeMap<String, Option<Sheet>> = BTreeMap::new();
+    let (mut listed, mut read, mut missing, mut batches) = (0u32, 0u32, 0u32, 0u64);
+    let (mut anim_models, mut anim_batches) = (0u32, 0u32);
+    let mut no_uvs = 0u32;
+    let mut per_class: BTreeMap<FxClass, u32> = BTreeMap::new();
+    let mut per_key_class: BTreeMap<FxClass, u32> = BTreeMap::new();
+    let mut per_clock: BTreeMap<UvClock, u32> = BTreeMap::new();
+    let mut per_chans: BTreeMap<String, u32> = BTreeMap::new();
+    let mut hits: Vec<EntityHit> = Vec::new();
+    let mut unread: Vec<String> = Vec::new();
+    let mut seed_disagrees = 0u32;
+    let mut misregistered = 0u32;
+    // The `uvslotscan` cross-check: this corpus's share of the two whole-corpus translation counts.
+    let (mut live_shared, mut per_seq) = (0u32, 0u32);
+    // Batches whose sheet is filled at RUNTIME (a creature skin variation, a character composite),
+    // and those where two of a model's skins disagree about what a frozen batch paints.
+    let (mut skin_filled, mut skin_disagrees) = (0u32, 0u32);
+
+    // --- the TINT half of the same sweep (the second dead channel on this lane) ---
+    let (mut tint_models, mut tint_batches) = (0u32, 0u32);
+    let mut tint_class: BTreeMap<TintClass, u32> = BTreeMap::new();
+    let mut tint_clock: BTreeMap<UvClock, u32> = BTreeMap::new();
+    let mut tint_hits: Vec<TintHit> = Vec::new();
+    let mut tint_blocks: Vec<(String, Vec<String>)> = Vec::new();
+    let (mut tint_live_shared, mut tint_per_seq) = (0u32, 0u32);
+    // …and the ALPHA channel beside them, which this lane DOES serve — counted so the report can
+    // say which of the three material-animation channels is a hole and which is not, rather than
+    // leaving the reader to assume all three are the same.
+    let (mut alpha_models, mut alpha_batches, mut alpha_live) = (0u32, 0u32, 0u32);
+
+    let keys: Vec<String> = corpus.models.keys().cloned().collect();
+    for key in keys {
+        if pfx.as_deref().is_some_and(|p| !key.starts_with(p)) {
+            continue;
+        }
+        let path = corpus.models[&key].path.clone();
+        listed += 1;
+        let Ok(bytes) = chain.read_file(&key) else {
+            missing += 1;
+            unread.push(format!("{path} (not in the chain)"));
+            continue;
+        };
+        read += 1;
+        let dir = key
+            .rsplit_once('\\')
+            .map(|(d, _)| d)
+            .unwrap_or("")
+            .to_string();
+        let Ok(subs) = benilla_formats::parse_m2_render_submeshes(&bytes, &dir, &[]) else {
+            missing += 1;
+            unread.push(format!("{path} (will not parse)"));
+            continue;
+        };
+        batches += subs.len() as u64;
+        // Any of the three channels keeps the model: a batch can animate its tint and not its UVs
+        // (four do), and gating on `uv_keyed` alone is exactly the shape of predicate this sweep
+        // exists to catch.
+        if !subs
+            .iter()
+            .any(|sub| uv_keyed(sub) || tint_keyed(sub) || sub.alpha_anim.is_some())
+        {
+            continue;
+        }
+        let no_alpha_add = authors_no_alpha_add(&bytes);
+        // File sequence slot -> its `AnimationData.dbc` id, so a BAND loop can be named by the
+        // animations that carry it rather than by an opaque slot number. A slot with no entry is a
+        // zero-duration sequence (`parse_m2_animations` drops those; the bake does not).
+        let slot_anim: BTreeMap<usize, u16> = benilla_formats::parse_m2_animations(&bytes)
+            .iter()
+            .map(|a| (a.seq_index, a.anim_id))
+            .collect();
+        // The creature skins this model is rendered with — `Monster1/2/3` is blank in the M2 and
+        // filled per display from `CreatureDisplayInfo.textureVariation`, so a batch on one of
+        // those slots has as many sheets as the model has skins.
+        let mut skins: [std::collections::BTreeSet<String>; 3] = Default::default();
+        for d in &corpus.models[&key].creature_displays {
+            let Some(m) = creatures.model(*d) else {
+                continue;
+            };
+            for (i, t) in m.textures.iter().enumerate() {
+                if let Some(name) = t {
+                    skins[i].insert(format!("{dir}\\{name}.blp"));
+                }
+            }
+        }
+
+        // WHICH BANDS carry the keys — the load-bearing half for a band loop, because it says
+        // whether the loop is one animation's or every animation's. Shared by both channels.
+        let slot_line = |c: &ChannelClock| -> String {
+            match (&c.cell, c.uniform) {
+                (Some(cell), _) => {
+                    let ids: Vec<String> = c
+                        .live
+                        .iter()
+                        .take(ENTITY_ID_ROWS)
+                        .map(|s| match slot_anim.get(s) {
+                            Some(id) => match anim_names.as_ref().and_then(|a| a.name(*id)) {
+                                Some(n) => format!("{s}:{id} {n}"),
+                                None => format!("{s}:{id}"),
+                            },
+                            None => format!("{s}:—"),
+                        })
+                        .collect();
+                    format!("{cell} live {}", ids.join(" "))
+                }
+                (None, true) => "SHARED (one loop, every sequence)".to_string(),
+                (None, false) => "—".to_string(),
+            }
+        };
+
+        // --- the TINT + ALPHA pass over the same batches -----------------------------------
+        let mut tlines: Vec<String> = Vec::new();
+        let mut model_has_alpha = false;
+        for (bi, sub) in subs.iter().enumerate() {
+            if let Some(a) = sub.alpha_anim.as_ref() {
+                alpha_batches += 1;
+                model_has_alpha = true;
+                if a.slots().iter().any(|q| {
+                    [q.color.as_ref(), q.weight.as_ref()]
+                        .into_iter()
+                        .flatten()
+                        .any(|l| l.period > 0.0)
+                }) {
+                    alpha_live += 1;
+                }
+            }
+            if !tint_keyed(sub) {
+                continue;
+            }
+            tint_batches += 1;
+            let read = tint_batch(sub, bi);
+            let c = channel_clock(sub.rgb_seq.as_ref(), sub.rgb_anim.as_ref());
+            let clock = if c.gseq.is_empty() {
+                UvClock::Hold
+            } else if c.gseq.iter().all(|g| *g) {
+                UvClock::Gseq
+            } else if c.gseq.iter().all(|g| !*g) {
+                UvClock::Band
+            } else {
+                UvClock::Mixed
+            };
+            tint_live_shared += u32::from(read.live_shared);
+            tint_per_seq += u32::from(read.per_seq);
+            *tint_class.entry(read.class).or_default() += 1;
+            *tint_clock.entry(clock).or_default() += 1;
+            tint_hits.push(TintHit {
+                key: key.clone(),
+                batch: bi,
+                class: read.class,
+                clock,
+                seed: read.seed,
+                rest_wrong: c.live.contains(&0) || (c.uniform && c.lead.is_some()),
+                seed_is_white: read.seed_is_white,
+                delta: read.delta,
+                per_seq: read.per_seq,
+                live_shared: read.live_shared,
+            });
+            tlines.extend(read.lines);
+            tlines.push(format!(
+                "      clock  {:<5}      {}",
+                clock.label(),
+                c.cell_text(),
+            ));
+            tlines.push(format!("      slots  {}", slot_line(&c)));
+            if let Some(set) = sub.rgb_seq.as_ref() {
+                let v = classify(set, Channel::Rgb);
+                tlines.push(format!("      rgb_seq {:<12} {}", v.why.label(), v.detail));
+            }
+        }
+        if model_has_alpha {
+            alpha_models += 1;
+        }
+        if !tlines.is_empty() {
+            tint_models += 1;
+            tint_blocks.push((path.clone(), tlines));
+        }
+
+        let mut lines: Vec<String> = Vec::new();
+        for (bi, sub) in subs.iter().enumerate() {
+            if !uv_keyed(sub) {
+                continue;
+            }
+            if sub.uvs.is_empty() {
+                no_uvs += 1;
+                continue;
+            }
+            anim_batches += 1;
+
+            // WHICH SHEET. An authored path where the batch carries one; otherwise the display's
+            // own skin variations, each asked separately — the frozen verdict is a property of the
+            // texture, and two skins of one model can answer differently.
+            let candidates: Vec<String> = match (&sub.texture, sub.skin_slot, sub.char_slot) {
+                (Some(t), _, _) => vec![t.clone()],
+                (None, Some(slot), _) => {
+                    skin_filled += 1;
+                    skins
+                        .get(slot as usize)
+                        .map(|s| s.iter().cloned().collect())
+                        .unwrap_or_default()
+                }
+                (None, None, Some(_)) => {
+                    // A runtime character composite (body atlas, object skin, hair): there is no
+                    // authored sheet to judge, and UNKNOWN is what that has to read as.
+                    skin_filled += 1;
+                    Vec::new()
+                }
+                (None, None, None) => Vec::new(),
+            };
+            let mut reads: Vec<(Option<String>, UvBatch)> = Vec::new();
+            if candidates.is_empty() {
+                let r = uv_batch(&mut sheets, chain, sub, bi, None, no_alpha_add);
+                reads.push((None, r));
+            } else {
+                for c in &candidates {
+                    let r = uv_batch(&mut sheets, chain, sub, bi, Some(c), no_alpha_add);
+                    reads.push((Some(c.clone()), r));
+                }
+            }
+            if reads.iter().any(|(_, r)| r.class != reads[0].1.class) {
+                skin_disagrees += 1;
+            }
+            let read = &reads[0].1;
+
+            // THE CLOCK, per channel, exactly as the runtime resolves it.
+            let t = channel_clock(sub.uv_seq.as_ref(), sub.uv_anim.as_ref());
+            let r = channel_clock::<[f32; 4]>(sub.uv_rot_seq.as_ref(), None);
+            let s = channel_clock::<[f32; 2]>(sub.uv_scale_seq.as_ref(), None);
+            let flags: Vec<bool> = [&t, &r, &s].iter().flat_map(|c| c.gseq.clone()).collect();
+            let clock = if flags.is_empty() {
+                UvClock::Hold
+            } else if flags.iter().all(|g| *g) {
+                UvClock::Gseq
+            } else if flags.iter().all(|g| !*g) {
+                UvClock::Band
+            } else {
+                UvClock::Mixed
+            };
+            let chans = [
+                sub.uv_anim.is_some() || sub.uv_seq.is_some(),
+                sub.uv_rot_seq.is_some(),
+                sub.uv_scale_seq.is_some(),
+            ];
+            let per_seq_trans = sub.uv_seq.is_some();
+            let live_shared_trans =
+                !per_seq_trans && sub.uv_anim.as_ref().is_some_and(|a| a.period > 0.0);
+            live_shared += u32::from(live_shared_trans);
+            per_seq += u32::from(per_seq_trans);
+
+            if read.class != read.key_class {
+                seed_disagrees += 1;
+            }
+            if read.class == FxClass::Frozen && (read.seed[0] != 0.0 || read.seed[1] != 0.0) {
+                misregistered += 1;
+            }
+            *per_class.entry(read.class).or_default() += 1;
+            *per_key_class.entry(read.key_class).or_default() += 1;
+            *per_clock.entry(clock).or_default() += 1;
+            let chan_key: String = ["T", "R", "S"]
+                .iter()
+                .zip(chans)
+                .filter_map(|(n, on)| on.then_some(*n))
+                .collect();
+            *per_chans.entry(chan_key).or_default() += 1;
+            hits.push(EntityHit {
+                key: key.clone(),
+                batch: bi,
+                class: read.class,
+                key_class: read.key_class,
+                clock,
+                chans,
+                per_seq_trans,
+                live_shared_trans,
+            });
+
+            lines.extend(reads[0].1.lines.clone());
+            for (sheet, r) in reads.iter().skip(1) {
+                lines.push(format!(
+                    "      skin variant      {} => {} / {}",
+                    sheet.as_deref().unwrap_or("NONE"),
+                    r.class.label(),
+                    r.key_class.label(),
+                ));
+            }
+            lines.push(format!(
+                "      clock  {:<5}      T {:<22} R {:<22} S {}",
+                clock.label(),
+                t.cell_text(),
+                r.cell_text(),
+                s.cell_text(),
+            ));
+            lines.push(format!("      slots  T {}", slot_line(&t)));
+            if r.cell.is_some() {
+                lines.push(format!("      slots  R {}", slot_line(&r)));
+            }
+            if s.cell.is_some() {
+                lines.push(format!("      slots  S {}", slot_line(&s)));
+            }
+            // …and, when the translation set exists, WHY the bake refused the shared lane — the
+            // `uniform()` question `uvslotscan` asks, asked here of the same set.
+            if let Some(set) = sub.uv_seq.as_ref() {
+                let v = classify(set, Channel::Uv);
+                lines.push(format!("      uv_seq {:<12} {}", v.why.label(), v.detail));
+            }
+        }
+        if !lines.is_empty() {
+            anim_models += 1;
+            println!("{path}  [{}]", corpus.models[&key].cell());
+            for l in &lines {
+                println!("{l}");
+            }
+        }
+    }
+
+    println!();
+    println!(
+        "=== summary ===  {listed} model(s) swept of the {} the entity tables reach, {read} read \
+         ({missing} unreadable), {batches} render batch(es)",
+        corpus.models.len()
+    );
+    println!(
+        "  sources: {} CreatureDisplayInfo row(s) ({} CreatureModelData row(s) no display reaches, \
+         unswept) · {} GameObjectDisplayInfo row(s) ({} name a .wmo) · {} ItemDisplayInfo model \
+         column(s) ({} name a file that ships under a folder this column is never joined to — \
+         thrown weapons named in both columns, already swept through the left one — and {} name a \
+         file nothing ships) · the bone piles",
+        corpus.creature_rows,
+        corpus.creature_orphan_models,
+        corpus.go_rows,
+        corpus.go_wmo,
+        corpus.item_rows,
+        corpus.item_other_dir,
+        corpus.item_absent,
+    );
+    println!(
+        "  {anim_models} model(s) / {anim_batches} batch(es) carry a keyed TEXTURE TRANSFORM — the \
+         channel `entity_variants` seeds and registers since 2295 ({no_uvs} more are keyed but \
+         carry no UVs to transform)"
+    );
+    println!(
+        "    channels  {}   (T translation · R rotation · S scaling — a sweep that read only T \
+         would miss a scale-only or rotate-only batch entirely)",
+        per_chans
+            .iter()
+            .map(|(k, n)| format!("{k} {n}"))
+            .collect::<Vec<_>>()
+            .join(" · "),
+    );
+    println!("    {:<10} {:>8} {:>9}", "", "identity", "first-key");
+    for c in FxClass::ALL {
+        println!(
+            "    {:<10} {:>8} {:>9}  — {}",
+            c.label(),
+            per_class.get(&c).copied().unwrap_or(0),
+            per_key_class.get(&c).copied().unwrap_or(0),
+            c.blurb(),
+        );
+    }
+    println!(
+        "  of the {} batch(es) FROZEN@identity, {misregistered} are frozen at UVs the loop never \
+         opens at (a non-zero first key); {seed_disagrees} batch(es) are classified differently by \
+         the two seeds",
+        per_class.get(&FxClass::Frozen).copied().unwrap_or(0),
+    );
+    println!();
+    println!("  --- the CLOCK the fix has to serve ---");
+    for c in UvClock::ALL {
+        println!(
+            "    {:<6} {:>5} batch(es)  — {}",
+            c.label(),
+            per_clock.get(&c).copied().unwrap_or(0),
+            c.blurb(),
+        );
+    }
+    println!();
+    println!(
+        "  --- cross-check against `uvslotscan` (whole corpus) ---\n    {live_shared} of this \
+         corpus's batch(es) carry a LIVE SHARED translation loop and {per_seq} carry a \
+         per-sequence translation set (`uv_seq`). Both must be <= `uvslotscan`'s whole-corpus \
+         counts for the same two lanes (its `of those … carry a LIVE loop there` and \
+         `PER-PLACEMENT` lines) — this corpus is a subset of that one by construction."
+    );
+    // The two translation lanes NAMED, not just counted: `uvslotscan` prints the same two
+    // populations over the whole corpus, so listing the models here makes the subset claim
+    // checkable by eye instead of on trust.
+    let mut shared_models: std::collections::BTreeSet<&str> = std::collections::BTreeSet::new();
+    let mut per_seq_models: BTreeMap<&str, u32> = BTreeMap::new();
+    for h in &hits {
+        if h.live_shared_trans {
+            shared_models.insert(h.key.as_str());
+        }
+        if h.per_seq_trans {
+            *per_seq_models.entry(h.key.as_str()).or_default() += 1;
+        }
+    }
+    println!(
+        "    the LIVE SHARED loop lands on {} model(s); the per-sequence set on these, which must \
+         each appear in `uvslotscan`'s PER-PLACEMENT listing:",
+        shared_models.len()
+    );
+    for (key, n) in &per_seq_models {
+        println!(
+            "      {n} batch(es)  {}",
+            corpus.models.get(*key).map_or(*key, |r| r.path.as_str())
+        );
+    }
+
+    println!(
+        "    {skin_filled} affected batch(es) take their sheet at RUNTIME (a creature skin \
+         variation or a character composite), so the visibility verdict is asked once per skin; \
+         {skin_disagrees} of them are classified differently by two skins of the same model."
+    );
+    if !unread.is_empty() {
+        println!();
+        println!(
+            "--- unreadable ---  {} model(s) the tables name but could not be swept",
+            unread.len()
+        );
+        for u in unread.iter().take(ENTITY_UNREAD_ROWS) {
+            println!("  {u}");
+        }
+        if let Some(rest) = unread
+            .len()
+            .checked_sub(ENTITY_UNREAD_ROWS)
+            .filter(|n| *n > 0)
+        {
+            println!("  … and {rest} more (top {ENTITY_UNREAD_ROWS} shown)");
+        }
+    }
+
+    // Every model carrying a batch of class `c`, with the rows that reach it — the join back from
+    // a verdict to something a director can go and stand in front of.
+    let listing = |title: &str, note: &str, pick: fn(&EntityHit) -> FxClass, c: FxClass| {
+        let rows: Vec<&EntityHit> = hits.iter().filter(|h| pick(h) == c).collect();
+        if rows.is_empty() {
+            return;
+        }
+        println!();
+        println!("--- {title} ---  {} batch(es){note}", rows.len());
+        let mut models: BTreeMap<&str, Vec<usize>> = BTreeMap::new();
+        for h in &rows {
+            models.entry(h.key.as_str()).or_default().push(h.batch);
+        }
+        for (key, bs) in &models {
+            let Some(reach) = corpus.models.get(*key) else {
+                continue;
+            };
+            println!(
+                "  {}  batch(es) {}",
+                reach.path,
+                bs.iter()
+                    .map(usize::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            println!("      {}", reach.cell());
+        }
+    };
+    for c in [
+        FxClass::Invisible,
+        FxClass::Never,
+        FxClass::Unknown,
+        FxClass::Held,
+    ] {
+        listing(
+            c.label(),
+            "  (frozen@identity — what the entity lane renders today)",
+            |h| h.class,
+            c,
+        );
+    }
+    // The batches the first-key seed alone condemns: they draw today, and would stop drawing on a
+    // lane that seeds the loop's opening value without running it. Named, because that is exactly
+    // the shape of a half-finished fix.
+    let key_only: Vec<&EntityHit> = hits
+        .iter()
+        .filter(|h| h.key_class == FxClass::Invisible && h.class != FxClass::Invisible)
+        .collect();
+    if !key_only.is_empty() {
+        println!();
+        println!(
+            "--- INVISIBLE under the FIRST-KEY seed only ---  {} batch(es)\n    (these draw today \
+             and would go dark on a lane that seeds `uv_anim.sample(0.0)` without ticking it)",
+            key_only.len()
+        );
+        let mut models: BTreeMap<&str, Vec<usize>> = BTreeMap::new();
+        for h in &key_only {
+            models.entry(h.key.as_str()).or_default().push(h.batch);
+        }
+        for (key, bs) in &models {
+            println!(
+                "  {}  batch(es) {}",
+                corpus.models.get(*key).map_or(*key, |r| r.path.as_str()),
+                bs.iter()
+                    .map(usize::to_string)
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+        }
+    }
+
+    // The deliverable: every affected model, what it renders today, and how much of the world
+    // reaches it — sorted by POPULATION, because that is what sizes the fix.
+    let mut models: BTreeMap<&str, (Vec<&EntityHit>, usize)> = BTreeMap::new();
+    for h in &hits {
+        let e = models.entry(h.key.as_str()).or_default();
+        e.0.push(h);
+        e.1 = corpus.models.get(&h.key).map_or(0, EntityReach::rows);
+    }
+    let mut tail: Vec<(&str, (Vec<&EntityHit>, usize))> = models.into_iter().collect();
+    tail.sort_by(|a, b| b.1 .1.cmp(&a.1 .1).then_with(|| a.0.cmp(b.0)));
+    println!();
+    println!(
+        "=== affected models, by population ===  {} model(s), {} batch(es)",
+        tail.len(),
+        hits.len()
+    );
+    for (key, (hs, rows)) in &tail {
+        let Some(reach) = corpus.models.get(*key) else {
+            continue;
+        };
+        let classes: Vec<String> = hs
+            .iter()
+            .map(|h| {
+                format!(
+                    "{}:{}{}{}/{}/{}",
+                    h.batch,
+                    if h.chans[0] { "T" } else { "" },
+                    if h.chans[1] { "R" } else { "" },
+                    if h.chans[2] { "S" } else { "" },
+                    h.class.label(),
+                    h.clock.label(),
+                )
+            })
+            .collect();
+        println!(
+            "  {rows:>5} row(s)  {}\n           batches {}\n           {}",
+            reach.path,
+            classes.join("  "),
+            reach.cell(),
+        );
+    }
+
+    // =====================================================================================
+    // The M2COLOR TINT half. Same corpus, same walk, a different dead channel — and a
+    // different failure mode, because a tint is a multiply and a UV offset is a lookup.
+    // =====================================================================================
+    println!();
+    println!(
+        "============================== M2COLOR TINT ==============================\n\
+         The same corpus asked about the OTHER channel `entity_variants` leaves unserved.\n\
+         `build` passes `sub.rgb_anim.as_ref()` unconditionally, so a tint-animating entity\n\
+         batch is SEEDED at the loop's first key (`model_material`'s `tint.xyz`) — and then\n\
+         nothing re-samples it, because `doodad_anim::register_tint`'s only call sites are in\n\
+         `terrain_stream/spawn/assemble.rs`. There is no `play_rgb` flag to flip: the hole is\n\
+         the missing registration, not a missing argument."
+    );
+    for (path, block) in &tint_blocks {
+        println!(
+            "{path}  [{}]",
+            corpus
+                .models
+                .get(&crate::model_key(path))
+                .map_or(String::new(), EntityReach::cell)
+        );
+        for l in block {
+            println!("{l}");
+        }
+    }
+    println!();
+    println!(
+        "=== tint summary ===  {tint_models} model(s) / {tint_batches} batch(es) of the same \
+         {read} read model(s) carry a keyed M2Color TINT"
+    );
+    for c in TintClass::ALL {
+        println!(
+            "    {:<11} {:>5} batch(es)  — {}",
+            c.label(),
+            tint_class.get(&c).copied().unwrap_or(0),
+            c.blurb(),
+        );
+    }
+    println!();
+    println!("  --- the CLOCK the tint fix has to serve ---");
+    for c in UvClock::ALL {
+        println!(
+            "    {:<6} {:>5} batch(es)  — {}",
+            c.label(),
+            tint_clock.get(&c).copied().unwrap_or(0),
+            c.blurb(),
+        );
+    }
+    let white = tint_hits.iter().filter(|h| h.seed_is_white).count();
+    let rest = tint_hits.iter().filter(|h| h.rest_wrong).count();
+    println!();
+    println!(
+        "  {rest} of {} batch(es) are wrong AT REST — slot 0, the band a resting instance plays, \
+         carries a live loop. The other {} key their tint only in a later slot, so the seed is the \
+         right colour until that animation plays and the error is confined to it (the per-batch \
+         `slots` line names which). Reporting those as flatly broken would overstate the hole.",
+        tint_hits.len(),
+        tint_hits.len() - rest,
+    );
+    println!(
+        "  {white} batch(es) seed WHITE — no slot-0 bake, so the shared material carries the \
+         IDENTITY tint while a later sequence slot colours the batch. The tint twin of the UV \
+         lane's DEAD-0, and the one shape a slot-0 shared loop could never fix."
+    );
+    println!();
+    println!(
+        "  --- cross-check against `uvslotscan`'s RGB section (whole corpus) ---\n    \
+         {tint_live_shared} of this corpus's batch(es) carry a LIVE SHARED tint loop and \
+         {tint_per_seq} carry a per-sequence set (`rgb_seq`). Both must be <= that report's \
+         `of those … carry a LIVE loop there` and `PER-PLACEMENT` counts for the RGB channel."
+    );
+    let mut tint_shared_models: std::collections::BTreeSet<&str> =
+        std::collections::BTreeSet::new();
+    let mut tint_seq_models: BTreeMap<&str, u32> = BTreeMap::new();
+    for h in &tint_hits {
+        if h.live_shared {
+            tint_shared_models.insert(h.key.as_str());
+        }
+        if h.per_seq {
+            *tint_seq_models.entry(h.key.as_str()).or_default() += 1;
+        }
+    }
+    println!(
+        "    the LIVE SHARED tint lands on {} model(s); the per-sequence set on these, which must \
+         each appear in `uvslotscan`'s RGB PER-PLACEMENT listing:",
+        tint_shared_models.len()
+    );
+    for (key, n) in &tint_seq_models {
+        println!(
+            "      {n} batch(es)  {}",
+            corpus.models.get(*key).map_or(*key, |r| r.path.as_str())
+        );
+    }
+    println!();
+    println!(
+        "  --- the ALPHA channel, for contrast: this lane DOES serve it ---\n    \
+         {alpha_models} model(s) / {alpha_batches} batch(es) carry a baked `alpha_anim`, \
+         {alpha_live} of them with a live loop — and every one of them is sampled per instance: \
+         `entities::attach::dress::spawn_part` inserts `MatAnim::following(anim, unit)` on each \
+         part and card (and `equipment::spawn` on each held item), which \
+         `doodad_anim::sample_mat_anim` ticks every frame off the instance's own AnimationPlayer. \
+         Counted here so the report cannot be read as `the entity lane runs no material \
+         animation`: it runs exactly one of the three channels, and that one is per-instance \
+         already."
+    );
+
+    // The join-back for the tint, by class — same shape as the UV listings.
+    let tlisting = |title: &str, c: TintClass| {
+        let rows: Vec<&TintHit> = tint_hits.iter().filter(|h| h.class == c).collect();
+        if rows.is_empty() {
+            return;
+        }
+        println!();
+        println!("--- {title} ---  {} batch(es)", rows.len());
+        let mut models: BTreeMap<&str, Vec<&TintHit>> = BTreeMap::new();
+        for h in &rows {
+            models.entry(h.key.as_str()).or_default().push(h);
+        }
+        for (key, bs) in &models {
+            let Some(reach) = corpus.models.get(*key) else {
+                continue;
+            };
+            println!(
+                "  {}  batch(es) {}",
+                reach.path,
+                bs.iter()
+                    .map(|h| {
+                        format!(
+                            "{} frozen [{:.2},{:.2},{:.2}] Δ{:.2}{}",
+                            h.batch,
+                            h.seed[0],
+                            h.seed[1],
+                            h.seed[2],
+                            h.delta,
+                            if h.seed_is_white { " (WHITE seed)" } else { "" },
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(" · "),
+            );
+            println!("      {}", reach.cell());
+        }
+    };
+    for c in [TintClass::Black, TintClass::Strong, TintClass::Slight] {
+        tlisting(c.label(), c);
+    }
+
+    // …and the population tail, sorted the same way the UV one is.
+    let mut tmodels: BTreeMap<&str, (Vec<&TintHit>, usize)> = BTreeMap::new();
+    for h in &tint_hits {
+        let e = tmodels.entry(h.key.as_str()).or_default();
+        e.0.push(h);
+        e.1 = corpus.models.get(&h.key).map_or(0, EntityReach::rows);
+    }
+    let mut ttail: Vec<(&str, (Vec<&TintHit>, usize))> = tmodels.into_iter().collect();
+    ttail.sort_by(|a, b| b.1 .1.cmp(&a.1 .1).then_with(|| a.0.cmp(b.0)));
+    println!();
+    println!(
+        "=== tint-affected models, by population ===  {} model(s), {} batch(es)",
+        ttail.len(),
+        tint_hits.len()
+    );
+    for (key, (hs, rows)) in &ttail {
+        let Some(reach) = corpus.models.get(*key) else {
+            continue;
+        };
+        println!(
+            "  {rows:>5} row(s)  {}\n           batches {}\n           {}",
+            reach.path,
+            hs.iter()
+                .map(|h| format!("{}:{}/{}", h.batch, h.class.label(), h.clock.label()))
+                .collect::<Vec<_>>()
+                .join("  "),
+            reach.cell(),
+        );
+    }
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// The M2COLOR TINT half of the same census — the second dead channel on the
+// same lane, found by asking where `register_tint` is called from.
+// ---------------------------------------------------------------------------
+
+/// Does this batch's M2Color tint animate? The runtime's own test: the shared slot-0 bake, or the
+/// per-sequence set the bake keeps when the slots disagree. The twin of [`uv_keyed`], and written
+/// as a union for the same reason — a predicate spelled `rgb_anim.is_some()` silently skips a batch
+/// whose slot 0 is a dead hold beside a live later slot (the tint corpus has four of those).
+fn tint_keyed(sub: &benilla_formats::RenderSubmesh) -> bool {
+    sub.rgb_anim.is_some() || sub.rgb_seq.is_some()
+}
+
+/// How many file sequence slots this batch's tint was baked across (1 when only the shared
+/// single-slot loop exists) — [`fx_slots`]'s tint twin.
+fn tint_slots(sub: &benilla_formats::RenderSubmesh) -> usize {
+    sub.rgb_seq.as_ref().map_or(1, |s| s.slots().len()).max(1)
+}
+
+/// The tint loop's period in slot `slot`; `0.0` where it is a constant hold.
+fn tint_period(sub: &benilla_formats::RenderSubmesh, slot: usize) -> f32 {
+    match (&sub.rgb_seq, &sub.rgb_anim) {
+        (Some(s), _) => s.seq(Some(slot)).map_or(0.0, |l| l.period),
+        (None, Some(a)) => a.period,
+        (None, None) => 0.0,
+    }
+}
+
+/// The tint at `(slot, t)`, read the way a consumer that RAN this channel would read it — the
+/// per-slot set when the bake built one, else the single shared loop ([`fx_state`]'s shape).
+/// White where neither exists, which is the tint identity.
+fn tint_state(sub: &benilla_formats::RenderSubmesh, slot: usize, t: f32) -> [f32; 3] {
+    match (&sub.rgb_seq, &sub.rgb_anim) {
+        (Some(s), _) => s.seq(Some(slot)).map_or([1.0; 3], |l| l.sample(t)),
+        (None, Some(a)) => a.sample(t),
+        (None, None) => [1.0; 3],
+    }
+}
+
+/// Rec.709 relative luminance — a reading aid for "how far apart are these two tints", not a
+/// perceptual model. The per-channel deltas beside it are the evidence; this is the single number
+/// that sorts a hue swap from a brightness swing.
+fn luma(c: [f32; 3]) -> f32 {
+    0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]
+}
+
+/// What a consumer that seeds the tint and never re-samples it renders.
+///
+/// A tint is a **multiply**, so the failure mode is never "invisible geometry" the way a UV freeze
+/// can be — it is the wrong colour, and how wrong is the only question worth asking. The bands are
+/// a reading aid over one measured number (the worst per-channel distance between the frozen value
+/// and anything the loop reaches, in 0..1 tint units); every batch prints that number, so the call
+/// is checkable and the thresholds are not load-bearing.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+enum TintClass {
+    /// The frozen tint is (near) BLACK while the loop reaches lit values: the multiply kills the
+    /// batch's colour outright, so it draws black — or, on an additive batch, not at all. The one
+    /// band where "wrong colour" becomes "wrong existence".
+    Black,
+    /// The frozen value is a quarter of the tint range or more away from what the loop reaches —
+    /// a colour difference nobody has to look for.
+    Strong,
+    /// Between 0.05 and 0.25 away: visible side by side, easy to miss alone.
+    Slight,
+    /// Under 0.05 away — the loop barely moves, or it moves and comes back. Frozen is
+    /// unobjectionable, and counting it as a bug would overstate the hole.
+    Negligible,
+}
+
+impl TintClass {
+    const ALL: [Self; 4] = [Self::Black, Self::Strong, Self::Slight, Self::Negligible];
+
+    fn label(self) -> &'static str {
+        match self {
+            Self::Black => "BLACK",
+            Self::Strong => "STRONG",
+            Self::Slight => "SLIGHT",
+            Self::Negligible => "NEGLIGIBLE",
+        }
+    }
+
+    fn blurb(self) -> &'static str {
+        match self {
+            Self::Black => {
+                "the frozen tint is ~black while the loop lights up — the multiply kills the batch \
+                 (an additive one disappears entirely)"
+            }
+            Self::Strong => {
+                "frozen >= 0.25 away from what the loop reaches — an obvious wrong colour"
+            }
+            Self::Slight => {
+                "frozen 0.05..0.25 away — visible against the real thing, easy to miss alone"
+            }
+            Self::Negligible => "frozen < 0.05 away — the loop barely moves; this is not a bug",
+        }
+    }
+}
+
+/// One batch's whole tint read.
+struct TintBatch {
+    class: TintClass,
+    /// What `model_material` actually bakes into `tint.xyz`: `rgb_anim.sample(0.0)` — the SHARED
+    /// slot-0 loop's first key — or identity white when there is no slot-0 bake at all.
+    seed: [f32; 3],
+    /// …and which of those two it was. A white seed is the tint twin of the UV lane's DEAD-0: the
+    /// batch's live tint lives in a later sequence slot the shared material cannot see.
+    seed_is_white: bool,
+    /// The worst per-channel distance between the seed and anything the loop reaches.
+    delta: f32,
+    /// This batch carries a per-sequence set (`rgb_seq`) — `uvslotscan`'s PER-PLACEMENT population.
+    per_seq: bool,
+    /// …and the shared slot-0 loop is live (`period > 0`) — its SHARED-live population.
+    live_shared: bool,
+    lines: Vec<String>,
+}
+
+/// Read one batch's animated tint — see [`TintBatch`]. The caller has established [`tint_keyed`].
+fn tint_batch(sub: &benilla_formats::RenderSubmesh, bi: usize) -> TintBatch {
+    let slots = tint_slots(sub);
+    // THE SEED, read off the builder rather than assumed: `model_render::model_material` does
+    // `rgb_anim.map_or([1,1,1], |a| a.sample(0.0))` and writes it to `tint.xyz`, and
+    // `batch::Materials::build` hands it `sub.rgb_anim.as_ref()` UNCONDITIONALLY — there is no
+    // `play_rgb` gate to flip. So unlike the UV channel, which freezes at the identity, the tint
+    // freezes at the loop's OPENING COLOUR… except where slot 0 baked nothing, and then it freezes
+    // at white while every live slot tints.
+    let seed = sub.rgb_anim.as_ref().map_or([1.0; 3], |a| a.sample(0.0));
+    let seed_is_white = sub.rgb_anim.is_none();
+
+    // Everything the loop reaches, over every slot and a uniform sweep of each — the same
+    // over-approximating union `uv_batch` takes, for the same reason.
+    let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
+    let mut delta = 0.0f32;
+    for slot in 0..slots {
+        let period = tint_period(sub, slot);
+        for i in 0..FX_ANIM_SAMPLES {
+            let t = period * i as f32 / (FX_ANIM_SAMPLES - 1) as f32;
+            let c = tint_state(sub, slot, t);
+            for k in 0..3 {
+                lo[k] = lo[k].min(c[k]);
+                hi[k] = hi[k].max(c[k]);
+                delta = delta.max((c[k] - seed[k]).abs());
+            }
+        }
+    }
+    let (ls, llo, lhi) = (luma(seed), luma(lo), luma(hi));
+    let class = if ls < 0.02 && lhi >= 0.05 {
+        TintClass::Black
+    } else if delta >= 0.25 {
+        TintClass::Strong
+    } else if delta >= 0.05 {
+        TintClass::Slight
+    } else {
+        TintClass::Negligible
+    };
+    let live_shared =
+        !sub.rgb_seq.is_some() && sub.rgb_anim.as_ref().is_some_and(|a| a.period > 0.0);
+    let mut lines = Vec::new();
+    lines.push(format!(
+        "  batch {bi:>3}  {:?}{}  {} verts  {slots} slot(s)",
+        sub.blend,
+        if sub.additive { " additive" } else { "" },
+        sub.positions.len(),
+    ));
+    lines.push(format!(
+        "      seed   [{:.3},{:.3},{:.3}] luma {ls:.3}   {}",
+        seed[0],
+        seed[1],
+        seed[2],
+        if seed_is_white {
+            "WHITE — no slot-0 bake, so the shared material seeds the IDENTITY while a later slot tints"
+        } else {
+            "the shared loop's first key (`model_material`'s `tint.xyz`)"
+        },
+    ));
+    lines.push(format!(
+        "      loop   r[{:+.3}..{:+.3}] g[{:+.3}..{:+.3}] b[{:+.3}..{:+.3}]  luma [{llo:.3}..{lhi:.3}]  \
+         over {} sample(s) x {slots} slot(s)",
+        lo[0], hi[0], lo[1], hi[1], lo[2], hi[2], FX_ANIM_SAMPLES,
+    ));
+    lines.push(format!(
+        "      frozen worst per-channel delta {delta:.3}  => {}",
+        class.label(),
+    ));
+    TintBatch {
+        class,
+        seed,
+        seed_is_white,
+        delta,
+        per_seq: sub.rgb_seq.is_some(),
+        live_shared,
+        lines,
+    }
+}
+
+/// One classified entity tint batch — the row the listings and the population tail are built from.
+struct TintHit {
+    key: String,
+    batch: usize,
+    class: TintClass,
+    clock: UvClock,
+    /// The colour the material is frozen at — printed in the listings, because "which wrong
+    /// colour" is the whole content of a tint bug.
+    seed: [f32; 3],
+    /// **Is the freeze visible at REST?** True when file sequence slot 0 — the band a resting
+    /// instance plays — carries a live loop. False means the seed is the right colour in every
+    /// state but the ones a later slot keys, so the batch is wrong only *while that animation
+    /// plays*. Four of this corpus's five are that second shape, and reporting them as flatly
+    /// broken would overstate the hole.
+    rest_wrong: bool,
+    seed_is_white: bool,
+    delta: f32,
+    per_seq: bool,
+    live_shared: bool,
+}
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs b/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
index ac968ed4..9cf28ccb 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
@@ -9,7 +9,8 @@
 //! - [`geometry`] — what geometry a model draws: billboards, geosets, flat ground quads.
 //! - [`material`] — how a batch is textured and blended: blend modes, UV wrap, env stages,
 //!   the batches whose UV/tint loop differs between sequence slots, and what the spell-effect
-//!   corpus's animated texture transforms render for a consumer that runs none of them.
+//!   (`fxuvscan`) and unit/GameObject/held-item (`entityuvscan`) corpora's animated texture
+//!   transforms render for a consumer that runs none of them.
 //! - [`particles`] — particle and ribbon emitters, and the features the corpus authors.
 //! - [`skeleton`] — the bone tree and the attachment table that addresses it.
 //! - [`sequence`] — which sequence an arm plays, what breaks when it is the wrong one, and
@@ -33,7 +34,7 @@ mod world;
 pub use geometry::{animboundscan, bbfacescan, bbscan, geosetscan, groundscan, normalscan};
 pub use lighting::{darkpropscan, m2lightscan, shadeat};
 pub use material::{
-    alphascan, blendscan, envmapscan, fxuvscan, texmodescan, uvslotscan, uvwrapscan,
+    alphascan, blendscan, entityuvscan, envmapscan, fxuvscan, texmodescan, uvslotscan, uvwrapscan,
 };
 pub use particles::{
     cellscan, fxordercensus, partcensus, partscan, partslotscan, ribbonscan, shardcensus,
diff --git a/crates/benilla-formats/src/item_sounds.rs b/crates/benilla-formats/src/item_sounds.rs
index 72232a4a..65a2cd15 100644
--- a/crates/benilla-formats/src/item_sounds.rs
+++ b/crates/benilla-formats/src/item_sounds.rs
@@ -113,7 +113,7 @@ mod tests {
         let displays = crate::load_item_display_catalog(&mut chain).expect("load ItemDisplayInfo");
         let mut nonzero = 0usize;
         let mut valid = 0usize;
-        for d in displays.iter() {
+        for (_, d) in displays.iter() {
             if d.group_sounds != 0 {
                 nonzero += 1;
                 if sounds.groups.contains_key(&d.group_sounds) {
diff --git a/crates/benilla-formats/src/item_visuals.rs b/crates/benilla-formats/src/item_visuals.rs
index b936e79b..2fa803e8 100644
--- a/crates/benilla-formats/src/item_visuals.rs
+++ b/crates/benilla-formats/src/item_visuals.rs
@@ -387,7 +387,7 @@ mod tests {
         let displays = crate::load_item_display_catalog(&mut chain).expect("load ItemDisplayInfo");
 
         let (mut carried, mut minus_one, mut resolved, mut models) = (0, 0, 0, 0);
-        for d in displays.iter() {
+        for (_, d) in displays.iter() {
             if d.item_visual == 0 {
                 continue;
             }
diff --git a/crates/benilla-formats/src/items.rs b/crates/benilla-formats/src/items.rs
index 8276d784..8762a1a1 100644
--- a/crates/benilla-formats/src/items.rs
+++ b/crates/benilla-formats/src/items.rs
@@ -164,9 +164,12 @@ impl ItemDisplayCatalog {
         self.displays.is_empty()
     }
 
-    /// Iterate the rows (order unspecified) — the cross-DBC join checks use it.
-    pub fn iter(&self) -> impl Iterator<Item = &ItemDisplay> {
-        self.displays.values()
+    /// Iterate `(displayId, row)` (order unspecified) — the cross-DBC join checks use it, and so
+    /// does the corpus sweep that has to name *which* display reaches a model
+    /// (`benilla-extract entityuvscan`). The id is carried because a census that cannot join back
+    /// to a row id answers "how many" and never "which one".
+    pub fn iter(&self) -> impl Iterator<Item = (u32, &ItemDisplay)> {
+        self.displays.iter().map(|(&id, d)| (id, d))
     }
 }
 
diff --git a/crates/benilla-formats/src/models/mat_anim.rs b/crates/benilla-formats/src/models/mat_anim.rs
index 739d911e..de14e816 100644
--- a/crates/benilla-formats/src/models/mat_anim.rs
+++ b/crates/benilla-formats/src/models/mat_anim.rs
@@ -115,6 +115,15 @@ impl AlphaAnim {
         self.seq(seq).sample(elapsed, shared_now)
     }
 
+    /// Every file sequence slot's pair, file order — the census instrument's read
+    /// (`benilla-extract entityuvscan`), the twin of [`SeqLoops::slots`] and there for the same
+    /// reason: an instrument that re-implements the per-slot walk can drift from the one the
+    /// runtime takes. Without it a sweep cannot even tell how many slots a batch was baked across,
+    /// because [`Self::seq`] degrades an out-of-range slot to slot 0 rather than refusing it.
+    pub fn slots(&self) -> &[AlphaSeq] {
+        &self.per_seq
+    }
+
     /// Whether ANY sequence can drive this batch's alpha to zero — i.e. whether the batch is ever
     /// culled. The spawn-side gate for "does this part need a live sampler at all".
     pub fn ever_hides(&self) -> bool {
diff --git a/crates/benilla-formats/src/sound_entries.rs b/crates/benilla-formats/src/sound_entries.rs
index 1c0dc6b8..2a4f704d 100644
--- a/crates/benilla-formats/src/sound_entries.rs
+++ b/crates/benilla-formats/src/sound_entries.rs
@@ -122,6 +122,37 @@ fn sound_entries_schema() -> Schema {
     s
 }
 
+/// Join one variation's `DirectoryBase` and `File[i]` into the path the archive is asked for —
+/// **the reference's own rule, byte-for-byte** (`0x45be10`, the sole caller `0x45c167` inside the
+/// `SOUNDDEFINITION` loader; wow-re `sound/scratch/soundentries-path-join.md`).
+///
+/// The client formats `"%s%s%s"` over `(dir, sep, file)` and chooses `sep` with exactly two tests:
+/// it is the empty string when `DirectoryBase` is **NULL/empty**, and when `SStrChrR(dir, '\')`
+/// says the directory **already ends in a separator**; otherwise it is `"\"`. That is the whole
+/// normalization in the client, at this layer or any other — and it has to be spelled here,
+/// because the archive layer below rescues nothing: `HashString` folds ASCII `a`–`z` to upper and
+/// maps `/` → `\` per character into the hash, and does **not** strip a leading separator, collapse
+/// a doubled one, or touch a trailing one (wow-re `mpq.md`, an evidenced absence — the hash loop
+/// read end to end). There is no loose-file fallback either: `SFileOpenFileEx`'s disk diversion
+/// takes `\\`, `X:` and a flag WoW's own startup clears, never a single leading `\`.
+///
+/// **27 of the 5875 data's 8961 variations do not resolve, and the reference cannot play them
+/// either** — 17 are simply absent from the archives (`GhostMusic01/02`, `mOgreFidget3`, and ids
+/// 195/196, where `mHumanFemaleWoundVoxA.wav` was authored across two `File` cells as
+/// `mHumanFemaleWoundVoxA` and `wav`), and the other 10 are kit **8940 `Ashbringer`**, whose
+/// `DirectoryBase` is `\Sound\Creature\Ashbringer\`: the client suppresses the *trailing*
+/// separator and then emits the *leading* one verbatim, so the path it opens
+/// (`\Sound\Creature\Ashbringer\ASH_SPEAK_01.wav`) misses in every archive although the asset is
+/// there. The Ashbringer's speak lines are dead data in the real client, and are meant to stay
+/// dead here: a leading-separator strip would be a deviation, not a fix.
+fn join_variation(dir: &str, file: &str) -> String {
+    if dir.is_empty() || dir.ends_with('\\') {
+        format!("{dir}{file}")
+    } else {
+        format!("{dir}\\{file}")
+    }
+}
+
 /// Read SoundEntries.dbc off the patch chain into a [`SoundKitCatalog`].
 pub fn load_sound_kit_catalog(chain: &mut Chain) -> Result<SoundKitCatalog> {
     let bytes = chain
@@ -140,11 +171,7 @@ pub fn load_sound_kit_catalog(chain: &mut Chain) -> Result<SoundKitCatalog> {
                 continue;
             };
             let weight = u32_at(r, 13 + i).unwrap_or(0);
-            let path = if dir.is_empty() {
-                file
-            } else {
-                format!("{dir}\\{file}")
-            };
+            let path = join_variation(&dir, &file);
             files.push((path, weight));
         }
         if !name.is_empty() {
@@ -253,4 +280,93 @@ mod tests {
             "creature barks split wet/dry"
         );
     }
+
+    /// The join's three legs, in the reference's own order (`0x45be10`): an empty directory emits
+    /// the file verbatim (26 shipped rows, e.g. 1103 `WyvernWingFlap`, whose variations are
+    /// themselves full paths), a directory that already ends in a separator gets none added, and
+    /// everything else gets exactly one. A **leading** separator is carried through untouched —
+    /// the client normalizes nothing there, and neither do we.
+    #[test]
+    fn the_variation_join_is_the_reference_s_separator_rule() {
+        assert_eq!(
+            join_variation("Sound\\Spells", "Dispel_Low_Base.wav"),
+            "Sound\\Spells\\Dispel_Low_Base.wav"
+        );
+        assert_eq!(
+            join_variation("Sound\\interface\\", "igNewTaxiNodeDiscovered.wav"),
+            "Sound\\interface\\igNewTaxiNodeDiscovered.wav"
+        );
+        assert_eq!(
+            join_variation("", "Sound\\Creature\\Wyvern\\WyvernWingFlap1.wav"),
+            "Sound\\Creature\\Wyvern\\WyvernWingFlap1.wav"
+        );
+        assert_eq!(
+            join_variation("\\Sound\\Creature\\Ashbringer\\", "ASH_SPEAK_01.wav"),
+            "\\Sound\\Creature\\Ashbringer\\ASH_SPEAK_01.wav",
+            "the leading separator survives — the reference emits it and misses too"
+        );
+    }
+
+    /// **Every kit path this loader builds, asked of the real chain.** The numbers are the
+    /// reference's own: the binary's join resolves 8934 of 8961 variations, and the 27 it does not
+    /// are authentic dead data. An unconditional `format!("{dir}\\{file}")` — what this loader did
+    /// before the join was derived — resolves exactly three fewer, and those three are whole kits:
+    /// 1519 `TaxiNodeDiscovered`, 2988 `Unarmed Small`, 3412 `Pirate Agro` each carry one variation
+    /// and a `DirectoryBase` that already ends in a separator, so every one of them was silent.
+    ///
+    /// The test pins both sides — what resolves and what is *meant* not to — so neither a
+    /// regression nor an over-eager "fix" of the Ashbringer can land quietly. Skips without client
+    /// data.
+    #[test]
+    fn real_sound_entries_paths_resolve_exactly_as_the_reference_s_do() {
+        let data = crate::wow_data_or_skip!();
+        let mut chain = crate::open_chain(&data).expect("open chain");
+        let cat = load_sound_kit_catalog(&mut chain).expect("load sound kits");
+
+        let mut total = 0usize;
+        let mut dead: Vec<(u32, &str, &str)> = Vec::new();
+        for kit in cat.kits.values() {
+            for (path, _) in &kit.files {
+                total += 1;
+                if !chain.contains(path) {
+                    dead.push((kit.id, &kit.name, path));
+                }
+            }
+        }
+        dead.sort_unstable();
+        assert_eq!(total, 8961, "non-empty variation cells in the 5875 table");
+        assert_eq!(
+            total - dead.len(),
+            8934,
+            "variations that resolve — the binary's own count; {dead:?}"
+        );
+
+        // The ten that are one kit, and the one kit that is therefore silent — in the reference
+        // too (its `DirectoryBase` opens with a separator the client passes straight through).
+        let ashbringer: Vec<_> = dead.iter().filter(|(id, ..)| *id == 8940).collect();
+        assert_eq!(ashbringer.len(), 10, "every ASH_SPEAK line misses");
+        assert!(
+            chain.contains("Sound\\Creature\\Ashbringer\\ASH_SPEAK_01.wav"),
+            "the asset ships — it is the authored path that cannot reach it"
+        );
+
+        // …and the other 17 are ordinary absent assets, spread across kits that mostly still play.
+        assert_eq!(dead.len() - ashbringer.len(), 17, "absent assets: {dead:?}");
+
+        // No OTHER kit is fully silent through a path benilla built. 8588 is, and is meant to be:
+        // its single variation is simply not in the archives.
+        let silent: Vec<u32> = cat
+            .kits
+            .values()
+            .filter(|k| !k.files.is_empty() && !k.files.iter().any(|(p, _)| chain.contains(p)))
+            .map(|k| k.id)
+            .collect();
+        let mut silent = silent;
+        silent.sort_unstable();
+        assert_eq!(
+            silent,
+            vec![8588, 8940],
+            "the only kits with no playable variation at all"
+        );
+    }
 }
diff --git a/crates/benilla-formats/tests/helm_vis_wants_a_helm.rs b/crates/benilla-formats/tests/helm_vis_wants_a_helm.rs
index e41c43fe..492e61c2 100644
--- a/crates/benilla-formats/tests/helm_vis_wants_a_helm.rs
+++ b/crates/benilla-formats/tests/helm_vis_wants_a_helm.rs
@@ -44,9 +44,9 @@ fn a_modelless_head_display_is_not_a_worn_helm() {
     );
 
     // 3. A real helm still hides what it should — the change must not disarm the mechanism.
-    let helm = items
+    let (_, helm) = items
         .iter()
-        .find(|d| d.model[0].is_some() && d.helmet_vis != [0, 0])
+        .find(|(_, d)| d.model[0].is_some() && d.helmet_vis != [0, 0])
         .expect("some display is a modelled helm with a vis row");
     assert_eq!(
         helm.worn_helm_vis(),
@@ -57,10 +57,10 @@ fn a_modelless_head_display_is_not_a_worn_helm() {
     // 4. The blast radius, pinned: of the 1314 rows that author a vis pair, exactly 12 leave the
     //    LEFT model slot empty. If the shipped data ever changes, this test says so rather than the
     //    change silently growing.
-    let masked = items.iter().filter(|d| d.helmet_vis != [0, 0]).count();
+    let masked = items.iter().filter(|(_, d)| d.helmet_vis != [0, 0]).count();
     let masked_modelless = items
         .iter()
-        .filter(|d| d.helmet_vis != [0, 0] && d.model[0].is_none())
+        .filter(|(_, d)| d.helmet_vis != [0, 0] && d.model[0].is_none())
         .count();
     assert_eq!((masked, masked_modelless), (1314, 12));
 
@@ -70,11 +70,11 @@ fn a_modelless_head_display_is_not_a_worn_helm() {
     //    reference's answer is the left slot's.
     let right_only = items
         .iter()
-        .filter(|d| d.model[0].is_none() && d.model[1].is_some())
+        .filter(|(_, d)| d.model[0].is_none() && d.model[1].is_some())
         .count();
     let right_only_masked = items
         .iter()
-        .filter(|d| d.model[0].is_none() && d.model[1].is_some() && d.helmet_vis != [0, 0])
+        .filter(|(_, d)| d.model[0].is_none() && d.model[1].is_some() && d.helmet_vis != [0, 0])
         .count();
     assert_eq!((right_only, right_only_masked), (41, 0));
 }
diff --git a/crates/benilla-formats/tests/m2_entity_mat_anim.rs b/crates/benilla-formats/tests/m2_entity_mat_anim.rs
new file mode 100644
index 00000000..6e7e19ef
--- /dev/null
+++ b/crates/benilla-formats/tests/m2_entity_mat_anim.rs
@@ -0,0 +1,165 @@
+//! The **entity** corpus's material animation (decision 2295) — the four shapes the unit /
+//! GameObject / held-item lane has to serve, each pinned on the asset that makes it unavoidable.
+//!
+//! Decision 0130 phase 3 built the texture transform for placed doodads and left every other lane
+//! off it; 2282 put the spell effects on; this file is the entity lane's turn, and it exists for
+//! the same reason 2282's does — *the premise that a lane needs no channel is a measurement, and an
+//! unmeasured one is how a channel gets quietly dropped.* `benilla-extract entityuvscan` is the
+//! census; these are the four rows of it a reader has to be able to check by hand.
+//!
+//! Skips (passes) when the client isn't present at `<repo>/WoW/Data`.
+
+use benilla_formats::{open_chain, parse_m2_render_submeshes};
+
+/// The whole entity corpus's widest case: **a creature, on a global sequence.** Every wind
+/// elemental in the game is this model, and 26 of its 32 batches slide a full sheet across
+/// themselves on a free-running clock — which is the one case where a shared material uniform is
+/// not a compromise but exactly what the reference does (0136 choice 1: the reference clocks a
+/// global-sequence loop on one per-scene ms cursor).
+#[test]
+fn a_creature_scrolls_on_a_global_sequence() {
+    let data = benilla_formats::wow_data_or_skip!();
+    let mut chain = open_chain(&data).expect("open vanilla patch chain");
+    let bytes = chain
+        .read_file("Creature\\AirElemental\\AirElemental.m2")
+        .expect("AirElemental is in the chain");
+    let subs = parse_m2_render_submeshes(&bytes, "Creature\\AirElemental", &[]).expect("parse");
+
+    let live: Vec<_> = subs
+        .iter()
+        .filter_map(|s| s.uv_anim.as_ref())
+        .filter(|a| a.period > 0.0)
+        .collect();
+    assert_eq!(live.len(), 26, "the banded shell's animating batches");
+    assert!(
+        live.iter().all(|a| a.gseq),
+        "every one rides a GLOBAL sequence — no host, no play head, a shared clock is faithful"
+    );
+    // A full sheet per loop: the batches slide u by 1.0 over their period, which is what makes the
+    // shell read as moving air rather than as a painted band.
+    for a in &live {
+        let (lo, hi) = a
+            .keys
+            .iter()
+            .fold((f32::MAX, f32::MIN), |(lo, hi), (_, v)| {
+                (lo.min(v[0]), hi.max(v[0]))
+            });
+        // A whole sheet, to the key quantization the exporter left behind (one batch ends at
+        // 1.0017): what matters is that a full repeat passes under the geometry each loop.
+        assert!(
+            (hi - lo - 1.0).abs() < 5e-3,
+            "a whole sheet of U per loop: [{lo}, {hi}]"
+        );
+    }
+    // Nothing here is per-sequence, so these batches keep the shared, deduped material.
+    assert!(subs.iter().all(|s| s.uv_seq.is_none()));
+}
+
+/// **A batch that rotates and never translates.** Both of the corpus's two live on GameObjects,
+/// and both answer `None` on the channel a reader checks first — so a lane whose predicate is
+/// `uv_anim.is_some()`, or whose row carries only a translation, drops them without a trace. This
+/// is `UvLoops::animates`' whole reason for existing, and 2019's affine row's.
+#[test]
+fn a_gameobject_batch_rotates_with_no_translation_at_all() {
+    let data = benilla_formats::wow_data_or_skip!();
+    let mut chain = open_chain(&data).expect("open vanilla patch chain");
+    for (path, batches) in [
+        ("World\\Goober\\G_ScryingBowl.m2", 1usize),
+        ("World\\Goober\\G_ScourgeRuneCircleCrystal.m2", 1),
+    ] {
+        let bytes = chain.read_file(path).expect("in the chain");
+        let dir = path.rsplit_once('\\').expect("a directory").0;
+        let subs = parse_m2_render_submeshes(&bytes, dir, &[]).expect("parse");
+        let turning: Vec<_> = subs.iter().filter(|s| s.uv_rot_seq.is_some()).collect();
+        assert_eq!(turning.len(), batches, "{path}: the rotating batches");
+        for s in &turning {
+            assert!(
+                s.uv_anim.is_none() && s.uv_seq.is_none(),
+                "{path}: no translation channel at all — the obvious test answers None"
+            );
+            assert!(s.uv_scale_seq.is_none(), "{path}: and no scaling either");
+            let rot = s.uv_rot_seq.as_ref().expect("checked");
+            let l = rot.seq(None).expect("slot 0 animates");
+            assert!(l.period > 0.0 && l.keys.len() > 1, "{path}: a live turn");
+        }
+    }
+}
+
+/// **The slots disagree, so no shared material can be right.** `BloodOfHeroes` authors its five
+/// bubble sheets twice over one animation id — file slot 0 holds them still, slot 1 sweeps them —
+/// at `freq` 16384/16383, so its 114 placements bubble independently of each other. That is
+/// 1408's population reached from the entity side: the instance needs a material of its own, and
+/// the row has to read whichever slot the instance is playing.
+#[test]
+fn a_gameobjects_slots_bake_different_loops() {
+    let data = benilla_formats::wow_data_or_skip!();
+    let mut chain = open_chain(&data).expect("open vanilla patch chain");
+    let path = "World\\Lordaeron\\Plagueland\\PassiveDoodads\\BloodOfHeroes\\BloodOfHeroes.m2";
+    let bytes = chain.read_file(path).expect("in the chain");
+    let dir = path.rsplit_once('\\').expect("a directory").0;
+    let subs = parse_m2_render_submeshes(&bytes, dir, &[]).expect("parse");
+
+    let split: Vec<_> = subs.iter().filter(|s| s.uv_seq.is_some()).collect();
+    assert_eq!(split.len(), 5, "the bubble sheets");
+    for s in &split {
+        assert!(
+            s.uv_anim.is_none(),
+            "no single loop serves both slots — which is why the shared lane registers nothing \
+             here and the bubbles never moved"
+        );
+        let seqs = s.uv_seq.as_ref().expect("checked");
+        let slots = seqs.slots();
+        assert_eq!(slots.len(), 2, "two file sequence slots");
+        assert!(slots[0].is_none(), "slot 0 holds the sheet still");
+        let live = slots[1].as_ref().expect("slot 1 sweeps it");
+        let hi = live.keys.iter().fold(f32::MIN, |hi, (_, v)| hi.max(v[1]));
+        assert!(
+            (live.period - 3.334).abs() < 1e-2 && (hi - 0.605).abs() < 1e-2,
+            "slot 1 sweeps v to {hi} over {}s",
+            live.period
+        );
+    }
+    // The pool itself is a sixth batch with no transform at all — so what was missing was never
+    // "the blood pool", it was the bubbling.
+    assert_eq!(
+        subs.iter().filter(|s| s.uv_seq.is_none()).count(),
+        1,
+        "the pool draws with no transform, and always did"
+    );
+}
+
+/// **The same shape on the TINT channel**, and worse: four of the corpus's five animated entity
+/// tints bake *nothing* in file slot 0, so `rgb_anim` is `None` for them and a shared material can
+/// only ever seed white however faithfully it is ticked. `G_FreezingTrap` is the one with play
+/// frequency — the hunter's trap, whose glow card is meant to pulse blue-white as it arms, on the
+/// `Custom0` clip the server rings.
+#[test]
+fn a_gameobjects_tint_is_keyed_in_a_later_slot_alone() {
+    let data = benilla_formats::wow_data_or_skip!();
+    let mut chain = open_chain(&data).expect("open vanilla patch chain");
+    let bytes = chain
+        .read_file("World\\Goober\\G_FreezingTrap.m2")
+        .expect("in the chain");
+    let subs = parse_m2_render_submeshes(&bytes, "World\\Goober", &[]).expect("parse");
+
+    let tinted: Vec<_> = subs.iter().filter(|s| s.rgb_seq.is_some()).collect();
+    assert!(!tinted.is_empty(), "the glow card's tint is per-sequence");
+    for s in &tinted {
+        assert!(
+            s.rgb_anim.is_none(),
+            "slot 0 bakes nothing — the shared lane's seed is white, for ever"
+        );
+        let seqs = s.rgb_seq.as_ref().expect("checked");
+        let slots = seqs.slots();
+        assert!(slots[0].is_none(), "…which is exactly what slot 0 holds");
+        let live = slots
+            .iter()
+            .enumerate()
+            .find_map(|(i, l)| l.as_ref().map(|l| (i, l)));
+        let (slot, l) = live.expect("some later slot keys the pulse");
+        assert!(
+            slot > 0 && l.period > 0.0 && l.keys.len() > 1,
+            "slot {slot}"
+        );
+    }
+}
diff --git a/crates/benilla-world/src/doodad_anim/mat_anim.rs b/crates/benilla-world/src/doodad_anim/mat_anim.rs
index ac85114e..8049dec7 100644
--- a/crates/benilla-world/src/doodad_anim/mat_anim.rs
+++ b/crates/benilla-world/src/doodad_anim/mat_anim.rs
@@ -258,7 +258,15 @@ pub struct AnimMatPart;
 /// decision 0785). Revisit if the population ever grows.
 pub enum UvLoop {
     /// Every sequence bakes the same loop: the shared material, on the free-running shared clock.
-    Shared(std::sync::Arc<benilla_formats::UvAnim>),
+    ///
+    /// `None` when the batch's transform carries **no translation at all** — a rotate-only or
+    /// scale-only transform, whose whole motion is the [`UvAnimEntry::affine`] row beside this
+    /// one. Two entity batches in the shipped corpus are exactly that
+    /// (`World\Goober\G_ScryingBowl`'s water and `G_ScourgeRuneCircleCrystal`'s rune ring, both
+    /// `chans —R—`), so a lane that made the translation mandatory would have to invent a
+    /// zero loop for them or drop them silently. The entry still holds its translation row; it
+    /// stays at zero, which is what that row means.
+    Shared(Option<std::sync::Arc<benilla_formats::UvAnim>>),
     /// The slots disagree: this material belongs to ONE placement, and the loop is whichever slot
     /// `host` is playing right now.
     PerSeq {
@@ -301,9 +309,9 @@ pub struct UvAnimEntry {
     pub anim: UvLoop,
     pub slot: u16,
     pub seed: [f32; 2],
-    /// The effect lane's **affine half** ([`FxAffine`], decision 2282) — `None` on every other
+    /// The effect lane's **affine half** ([`UvAffine`], decision 2282) — `None` on every other
     /// lane, and on an effect batch whose transform only translates (the common case).
-    affine: Option<FxAffine>,
+    affine: Option<UvAffine>,
 }
 
 /// A texture transform's ROTATION and SCALING, on the effect lane: the two channels the
@@ -315,7 +323,7 @@ pub struct UvAnimEntry {
 /// `Spells\GroundingTotem_Impact.mdx` is a **scale-only** transform, so a lane that ran only the
 /// scroll would still render both wrong. `benilla-extract fxuvscan` is where that population is
 /// read; it is three models today, which is exactly why nobody would have found them by eye.
-struct FxAffine {
+struct UvAffine {
     rot: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 4]>>>,
     scale: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 2]>>>,
     /// The affine row's slot (`anim_slots.z`). Its encoding is a delta from the IDENTITY, not
@@ -335,7 +343,7 @@ impl UvAnimEntry {
     /// table gives.
     pub(crate) fn delta(&self, now: f32, gseq_now: f64, playing: Option<(usize, f32)>) -> [f32; 4] {
         let uv = match &self.anim {
-            UvLoop::Shared(anim) => anim.sample(now),
+            UvLoop::Shared(anim) => anim.as_ref().map_or([0.0, 0.0], |a| a.sample(now)),
             UvLoop::PerSeq { seqs, .. } => playing
                 .and_then(|(seq, band_t)| {
                     seqs.seq(Some(seq))
@@ -369,21 +377,29 @@ impl UvAnimEntry {
     }
 
     /// This entry's **affine** row and the slot it goes in, or `None` when the transform only
-    /// translates. Sampled on the same instance clocks [`Self::delta`] uses, so the three channels
-    /// of one transform are always read at one instant.
+    /// translates. Sampled on **the same clocks [`Self::delta`] uses for this entry's own lane**,
+    /// so the three channels of one transform are always read at one instant — a rotation read on
+    /// the scene clock beside a translation read on an instance's play head would be two different
+    /// moments of the same matrix.
     pub(crate) fn affine(
         &self,
         now: f32,
+        gseq_now: f64,
         playing: Option<(usize, f32)>,
     ) -> Option<(u16, [f32; 4])> {
         let a = self.affine.as_ref()?;
-        let UvLoop::Instance { attached_at, .. } = &self.anim else {
-            return None; // the affine half is the effect lane's alone
+        // Per lane, exactly as `delta` does it: the shared lane reads the free-running scene clock
+        // on both, the per-placement lane its host's playing clip, and the effect lane its own
+        // age-anchored pair (decisions 0856/0858).
+        let (band_t, gseq) = match &self.anim {
+            UvLoop::Shared(_) => (now, gseq_now),
+            UvLoop::PerSeq { .. } => (playing.map_or(now, |(_, t)| t), gseq_now),
+            UvLoop::Instance { attached_at, .. } => {
+                let age = now - attached_at;
+                (playing.map_or(age, |(_, t)| t), f64::from(age))
+            }
         };
-        let age = now - attached_at;
-        let band_t = playing.map_or(age, |(_, t)| t);
         let seq = playing.map(|(seq, _)| seq);
-        let gseq = f64::from(age);
         let q = a
             .rot
             .as_ref()
@@ -421,7 +437,7 @@ impl UvAnimEntry {
     /// the same resolution [`Self::delta`] makes rather than a hand-rolled twin of it.
     fn resolved(&self, playing: Option<(usize, f32)>) -> Option<&benilla_formats::UvAnim> {
         match &self.anim {
-            UvLoop::Shared(a) => Some(a),
+            UvLoop::Shared(a) => a.as_deref(),
             UvLoop::PerSeq { seqs, .. } => seqs.seq(playing.map(|(seq, _)| seq)),
             UvLoop::Instance { seqs, single, .. } => seqs
                 .as_ref()
@@ -533,6 +549,41 @@ pub(crate) fn register_uv(
     );
 }
 
+/// Attach the ROTATION/SCALING half to an entry [`register_uv`] has just made, if the batch has
+/// one — the second table row, `anim_slots.z`, and 2019's `[cos − 1, sin, sx − 1, sy − 1]`
+/// encoding whose zero row IS the identity.
+///
+/// The translation half decides whether there is an entry at all (a full table, a dead handle);
+/// the affine half attaches to it or not at all. A transform that ONLY rotates or scales still
+/// takes a translation row that stays at zero — one row, on a population of five models corpus-
+/// wide, for a registration path with one shape instead of two.
+fn attach_affine(
+    reg: &mut UvAnimMaterials,
+    table: &mut crate::mat_anim_table::MatAnimTable,
+    materials: &mut bevy::asset::Assets<benilla_assets::materials::WowModelMaterial>,
+    id: bevy::asset::AssetId<benilla_assets::materials::WowModelMaterial>,
+    rot: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 4]>>>,
+    scale: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 2]>>>,
+) {
+    if rot.is_none() && scale.is_none() {
+        return;
+    }
+    let Some(entry) = reg.0.get_mut(&id) else {
+        return;
+    };
+    match table.alloc() {
+        Some(slot) => {
+            crate::model_render::lazy::with_material_mut(materials, id, |mat| {
+                mat.extension.anim_slots.z = f32::from(slot);
+            });
+            entry.affine = Some(UvAffine { rot, scale, slot });
+        }
+        None => {
+            bevy::log::warn_once!("mat-anim table full — a UV rotation/scale stays at the identity")
+        }
+    }
+}
+
 /// Put one **spell-effect material clone** on the per-instance UV lane (decision 2282): the
 /// engine's whole door for `entities::spell_fx`, which owns the clone and nothing else about how
 /// the scroll is delivered.
@@ -552,11 +603,11 @@ pub fn register_fx_uv(
     table: &mut crate::mat_anim_table::MatAnimTable,
     materials: &mut bevy::asset::Assets<benilla_assets::materials::WowModelMaterial>,
     id: bevy::asset::AssetId<benilla_assets::materials::WowModelMaterial>,
-    loops: FxUvLoops,
+    loops: UvLoops,
     host: Entity,
     attached_at: f32,
 ) {
-    let FxUvLoops {
+    let UvLoops {
         seqs,
         single,
         rot,
@@ -575,52 +626,98 @@ pub fn register_fx_uv(
             attached_at,
         },
     );
-    // The translation half decides whether there is an entry at all (a full table, a dead handle);
-    // the affine half attaches to it or not at all. A transform that ONLY rotates or scales still
-    // takes a translation row that stays at zero — one row, on a population of three models, for a
-    // registration path with one shape instead of two.
-    let Some(entry) = reg.0.get_mut(&id) else {
+    attach_affine(reg, table, materials, id, rot, scale);
+    let Some(entry) = reg.0.get(&id) else {
         return;
     };
-    if turns {
-        match table.alloc() {
-            Some(slot) => {
-                crate::model_render::lazy::with_material_mut(materials, id, |mat| {
-                    mat.extension.anim_slots.z = f32::from(slot);
-                });
-                entry.affine = Some(FxAffine { rot, scale, slot });
-            }
-            None => bevy::log::warn_once!(
-                "mat-anim table full — an effect's UV rotation/scale stays at the identity"
-            ),
-        }
-    }
+    let _ = turns;
     // **Both rows, written now.** `tick_anim_materials` runs once per frame in `Update` and this
     // registration happens in the same schedule, so an instance that attaches after the tick would
     // otherwise draw its first frame at row 0 — the identity, which on this population is the
     // authored-UV frame the whole decision is about (a Swipe strip renders NOTHING there). One
     // write at spawn costs nothing and removes the class.
     let (slot, row) = (entry.slot, entry.delta(attached_at, 0.0, None));
-    let affine = entry.affine(attached_at, None);
+    let affine = entry.affine(attached_at, 0.0, None);
     table.set(slot, row);
     if let Some((slot, row)) = affine {
         table.set(slot, row);
     }
 }
 
+/// Put one **unit / GameObject / held-item** batch material on the UV lane (decision 2295) — the
+/// engine's whole door for the entity lane, and the twin of [`register_fx_uv`] for a population
+/// that is resident rather than pooled.
+///
+/// It picks the lane from the authored record rather than making the caller reason about it,
+/// which is the same argument [`UvLoops`] itself rests on:
+///
+/// - **`host` is `Some` and the slots disagree** ⇒ [`UvLoop::PerSeq`]. This material belongs to
+///   that one instance (the caller owns the clone), and the loop is whichever file-sequence slot
+///   the instance is playing — 1408's lane, reached from the entity side for the first time.
+///   `World\Lordaeron\Plagueland\PassiveDoodads\BloodOfHeroes` is the class: slot 0 holds its
+///   bubble sheets still while slot 1 sweeps them, at freq 16384/16383, so its placements bubble
+///   independently and one shared row cannot serve two of them.
+/// - **otherwise** ⇒ [`UvLoop::Shared`], the free-running scene clock on the batch's shared,
+///   deduped material — 0136 choice 1. Exactly faithful for a global-sequence loop (the
+///   reference clocks those on one per-scene ms cursor), and 0136's recorded, still-invisible
+///   divergence for a seamless band loop.
+///
+/// A period-0 translation is not a loop — its seed IS its forever value, so registering it would
+/// buy a per-frame re-write of the same number (1375) — but a batch that only rotates or scales
+/// still registers, because its motion is the affine row and its translation row is the zero it
+/// is meant to be.
+pub fn register_entity_uv(
+    reg: &mut UvAnimMaterials,
+    table: &mut crate::mat_anim_table::MatAnimTable,
+    materials: &mut bevy::asset::Assets<benilla_assets::materials::WowModelMaterial>,
+    id: bevy::asset::AssetId<benilla_assets::materials::WowModelMaterial>,
+    loops: &UvLoops,
+    host: Option<Entity>,
+) {
+    if !loops.animates() {
+        return;
+    }
+    let lane = match (loops.seqs.clone(), host) {
+        (Some(seqs), Some(host)) => UvLoop::PerSeq { seqs, host },
+        _ => UvLoop::Shared(loops.single.clone().filter(|l| l.period > 0.0)),
+    };
+    register_uv(reg, table, materials, id, lane);
+    attach_affine(
+        reg,
+        table,
+        materials,
+        id,
+        loops.rot.clone(),
+        loops.scale.clone(),
+    );
+}
+
 /// The four baked channels of one batch's texture transform, as [`register_fx_uv`] takes them —
 /// 1408's two translation spellings plus 2019's per-slot rotation and scaling sets. A struct
 /// because they are one authored record, and a caller passing four `Option`s positionally is a
 /// caller that will eventually swap two of them.
 #[derive(Default)]
-pub struct FxUvLoops {
+pub struct UvLoops {
     pub seqs: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 2]>>>,
     pub single: Option<std::sync::Arc<benilla_formats::UvAnim>>,
     pub rot: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 4]>>>,
     pub scale: Option<std::sync::Arc<benilla_formats::SeqLoops<[f32; 2]>>>,
 }
 
-impl FxUvLoops {
+impl UvLoops {
+    /// The record as one authored batch carries it — **the one place the four channels are read
+    /// off a submesh**, so a lane that registers and a spawner that marks can never disagree about
+    /// which batches animate (decision 2038's law, whose violation froze every waterfall in the
+    /// game for three days).
+    pub fn of(sub: &benilla_assets::ModelSubmesh) -> Self {
+        Self {
+            seqs: sub.uv_seq.clone(),
+            single: sub.uv_anim.clone(),
+            rot: sub.uv_rot_seq.clone(),
+            scale: sub.uv_scale_seq.clone(),
+        }
+    }
+
     /// Does this batch animate its texture transform at all? The test the effect attach makes
     /// before cloning a material: any of the four channels, because a scale-only transform
     /// (`Spells\GroundingTotem_Impact.mdx`) and a dead-slot-0 translation (1408) each answer
@@ -629,6 +726,18 @@ impl FxUvLoops {
         self.seqs.is_some() || self.single.is_some() || self.rot.is_some() || self.scale.is_some()
     }
 
+    /// Does it need a per-frame SAMPLE — i.e. does it move? [`Self::any`] minus the constants: a
+    /// translation keyed to one value for the whole clip is its material's seed and nothing more
+    /// (1375), while a rotate-only or scale-only batch answers `None` on the translation channel
+    /// and still moves. The **one predicate** the entity lane's registration and its
+    /// [`AnimMatPart`] marker both ask.
+    pub fn animates(&self) -> bool {
+        self.seqs.is_some()
+            || self.rot.is_some()
+            || self.scale.is_some()
+            || self.single.as_ref().is_some_and(|l| l.period > 0.0)
+    }
+
     /// The offset the batch opens on — what a caller seeds the clone's `sun_scale.zw` with so its
     /// first frame is the loop's own `t = 0` and not the authored, unscrolled UV.
     pub fn open_offset(&self) -> [f32; 2] {
@@ -717,7 +826,7 @@ pub(super) fn tick_anim_materials(
     // instance's frame-stepped `AnimationPlayer` — the `fxview` carve-out `MatAnim` and
     // `spell_fx::FxTintAnims` already take (decision 2282). A capture with no effect in it — every
     // golden scenario — holds no such entry, so it returns here exactly as it always has.
-    let frozen = crate::dev_state::deterministic_run();
+    let frozen = crate::dev_state::deterministic_run() && !matanim_live();
     if frozen && !uv_reg.0.values().any(UvAnimEntry::instance_lane) {
         return;
     }
@@ -770,7 +879,7 @@ pub(super) fn tick_anim_materials(
             table.set(entry.slot, entry.delta(now, gseq_now, playing));
             // …and the rotation/scale row beside it, for the effect models that turn or scale
             // their UVs rather than only sliding them (2282).
-            if let Some((slot, row)) = entry.affine(now, playing) {
+            if let Some((slot, row)) = entry.affine(now, gseq_now, playing) {
                 table.set(slot, row);
             }
         }
@@ -820,6 +929,22 @@ fn matanim_off(time: &Time<bevy::time::Real>) -> bool {
     })
 }
 
+/// **`WOW_MATANIM_LIVE=1` — run the shared lanes inside a deterministic capture too.**
+///
+/// The freeze above is what makes a golden frame reproducible, and it is right for every scenario
+/// in the sweep. It also means `fxview` — the fixture whose whole job is to age a subject — cannot
+/// show a **unit's or GameObject's** texture transform at all, because those are shared-clock
+/// entries (decision 2295); the effect lane is exempt only because its clock is one instance's
+/// frame-stepped player. Without this knob the A/B for "does this creature's skin scroll" does not
+/// exist, and the answer would have to come from the director's screen, which is not what §7 means
+/// by leaving the look to them.
+///
+/// Off by default, read once, and no golden scenario sets it — so the sweep is untouched.
+fn matanim_live() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| std::env::var("WOW_MATANIM_LIVE").is_ok_and(|v| v != "0"))
+}
+
 /// The **tint-animated materials** registry — the M2Color-RGB twin of [`UvAnimMaterials`]: each
 /// batch material whose colour track animates (the vertex bake is skipped for those —
 /// `benilla-formats` `m2_batches`), keyed by material asset id. [`tick_anim_materials`]
@@ -972,7 +1097,12 @@ pub(super) fn matanim_probe(
         // The per-placement lane has one loop per sequence, so its phase sweep is meaningless
         // without a play head — it prints the head instead, and samples on the shared clock.
         let (lane, period) = match &e.anim {
-            UvLoop::Shared(a) => (format!("shared period {:.3}s", a.period), a.period),
+            UvLoop::Shared(a) => {
+                // `None` = a rotate-/scale-only transform: the translation row is real and stays
+                // at zero, and the period the sweep needs is the AFFINE channel's, not this one's.
+                let p = a.as_ref().map_or(0.0, |a| a.period);
+                (format!("shared period {p:.3}s"), p)
+            }
             UvLoop::PerSeq { .. } => (format!("per-seq playing {playing:?}"), 0.0),
             // The effect lane HAS a resolved loop (the clip it opened on), so unlike the
             // per-placement lane its sweep is meaningful — read across the instance's own
@@ -1001,7 +1131,7 @@ pub(super) fn matanim_probe(
         let live = e.delta(now, gseq_now, playing);
         // The affine half, when the transform has one: `[cos − 1, sin, sx − 1, sy − 1]`, so all
         // zeros IS the identity and a flat row there says the turn/scale never reached the shader.
-        let affine = e.affine(now, playing).map_or(String::new(), |(slot, want)| {
+        let affine = e.affine(now, gseq_now, playing).map_or(String::new(), |(slot, want)| {
             let row = table.row(slot);
             format!(
                 " · affine slot {slot} row ({:+.4},{:+.4},{:+.4},{:+.4}) live ({:+.4},{:+.4},{:+.4},{:+.4})",
@@ -1124,6 +1254,100 @@ mod delta_tests {
         }
     }
 
+    /// A rotation-only loop, as `G_ScryingBowl`'s water and `G_ScourgeRuneCircleCrystal`'s rune
+    /// ring author one: a quarter turn about Z over two seconds, keyed in file slot 0 only.
+    fn quarter_turn() -> std::sync::Arc<benilla_formats::SeqLoops<[f32; 4]>> {
+        const Q: f32 = std::f32::consts::FRAC_1_SQRT_2;
+        const QUARTER: [f32; 4] = [0.0, 0.0, Q, Q];
+        std::sync::Arc::new(
+            benilla_formats::SeqLoops::new(vec![Some(benilla_formats::KeyAnim {
+                period: 2.0,
+                step: false,
+                wrap: true,
+                gseq: false,
+                // 90° about Z = (0, 0, sin 45°, cos 45°).
+                keys: vec![(0.0, [0.0, 0.0, 0.0, 1.0]), (2.0, QUARTER)],
+            })])
+            .expect("one animating slot"),
+        )
+    }
+
+    /// **`animates()` is the one predicate, and it is not `uv_anim.is_some()`** (decision 2295).
+    /// Two entity batches in the shipped corpus rotate and never translate, so the channel a
+    /// reader would check first answers `None` for them; and a translation keyed to one constant
+    /// value is the material's seed, not a loop to sample (1375).
+    #[test]
+    fn the_animates_predicate_sees_a_rotation_only_batch() {
+        let rot_only = UvLoops {
+            rot: Some(quarter_turn()),
+            ..Default::default()
+        };
+        assert!(rot_only.single.is_none(), "the obvious channel is empty");
+        assert!(rot_only.animates(), "and it still moves");
+
+        let constant = UvLoops {
+            single: Some(std::sync::Arc::new(benilla_formats::UvAnim {
+                period: 0.0,
+                step: false,
+                wrap: false,
+                gseq: false,
+                keys: vec![(0.0, [0.25, 0.0])],
+            })),
+            ..Default::default()
+        };
+        assert!(constant.any(), "it has a channel");
+        assert!(
+            !constant.animates(),
+            "…but a period-0 translation is a seed, never a per-frame sample"
+        );
+        assert!(!UvLoops::default().animates());
+    }
+
+    /// **The affine half runs on whichever clock its own lane runs on** (decision 2295 widening
+    /// 2282's). A shared entity entry has no host and no attach time, so its rotation reads the
+    /// free-running scene clock — which is what makes a rune ring on a shared, deduped material
+    /// turn at all.
+    #[test]
+    fn a_shared_entry_turns_on_the_scene_clock() {
+        let e = UvAnimEntry {
+            anim: UvLoop::Shared(None),
+            slot: 4,
+            seed: [0.0, 0.0],
+            affine: Some(UvAffine {
+                rot: Some(quarter_turn()),
+                scale: None,
+                slot: 5,
+            }),
+        };
+        // No translation channel at all: the row it still owns stays at the zero it means.
+        assert_eq!(e.delta(1.0, 1.0, None), [0.0, 0.0, 0.0, 0.0]);
+        // Half-way through the turn, and the row is `[cos − 1, sin, sx − 1, sy − 1]` of the
+        // **raw, unnormalised** lerped quaternion — which is the reference's own arithmetic, not
+        // an oversight: `0x713ea0` lerps each component and `0x7bddb0` consumes the result as is,
+        // so between two keys `|q| < 1` and the 2×2 is a rotation with a slight shrink (wow-re
+        // `modelframe-texanim-and-sequence-law.md` §3.4: *"a re-implementation that slerps, or
+        // normalises before building the matrix, diverges from the reference between keys"*).
+        // Here `q = (0, 0, 0.35355, 0.85355)`, so `c = 1 − 2z² = 0.75` and `s = 2zw = 0.60355` —
+        // NOT the 0.7071/0.7071 a normalised 45° would give. Asserted exactly so a future
+        // "obvious fix" to normalise fails here.
+        let (slot, row) = e.affine(1.0, 1.0, None).expect("the affine row");
+        assert_eq!(slot, 5);
+        assert!(
+            (row[0] + 0.25).abs() < 1e-4 && (row[1] - 0.603_553).abs() < 1e-4,
+            "the unnormalised lerp at t = 1 s of a 2 s turn: {row:?}"
+        );
+        assert!(
+            row[2].abs() < 1e-6 && row[3].abs() < 1e-6,
+            "no scaling authored, so the scale half is the identity: {row:?}"
+        );
+        // …and the clock really is `now`: a different scene time gives a different angle.
+        let later = e.affine(1.5, 1.5, None).expect("the affine row").1;
+        assert!(
+            (later[1] - row[1]).abs() > 1e-2,
+            "the shared lane's affine must move with the scene clock: {row:?} vs {later:?}"
+        );
+    }
+
     /// **The effect lane reads its INSTANCE's play head, not the scene clock** (decision 2282).
     /// The band clock is the clip time the host's `AnimationPlayer` reports, so two casts a minute
     /// apart are at the same point of their own scroll — the property a shared-material lane
@@ -1163,10 +1387,10 @@ mod delta_tests {
     fn the_effect_lane_samples_rotation_and_scale_on_the_same_clock() {
         let mut e = fx_entry(100.0);
         assert!(
-            e.affine(100.5, Some((0, 0.5))).is_none(),
+            e.affine(100.5, 0.0, Some((0, 0.5))).is_none(),
             "a translation-only transform takes no affine row"
         );
-        e.affine = Some(FxAffine {
+        e.affine = Some(UvAffine {
             rot: None,
             scale: Some(std::sync::Arc::new(
                 benilla_formats::SeqLoops::new(vec![Some(benilla_formats::UvAnim {
@@ -1180,7 +1404,9 @@ mod delta_tests {
             )),
             slot: 12,
         });
-        let (slot, row) = e.affine(100.0, Some((0, 1.0))).expect("the affine row");
+        let (slot, row) = e
+            .affine(100.0, 0.0, Some((0, 1.0)))
+            .expect("the affine row");
         assert_eq!(slot, 12);
         // Half-way: scale 0.625, encoded as `sx − 1`; rotation untouched, so `cos − 1` and `sin`
         // are the identity's zeros.
@@ -1212,7 +1438,7 @@ mod delta_tests {
         let anim = uv_loop();
         let seed = anim.sample(0.0);
         let entry = UvAnimEntry {
-            anim: UvLoop::Shared(anim.clone()),
+            anim: UvLoop::Shared(Some(anim.clone())),
             slot: 3,
             seed,
             affine: None,
diff --git a/crates/benilla-world/src/doodad_anim/mod.rs b/crates/benilla-world/src/doodad_anim/mod.rs
index 4382b2b9..de4386dd 100644
--- a/crates/benilla-world/src/doodad_anim/mod.rs
+++ b/crates/benilla-world/src/doodad_anim/mod.rs
@@ -41,8 +41,8 @@ mod mat_anim;
 pub(crate) use lazy::{LazyRig, SkinnedTwin};
 use mat_anim::tick_anim_materials;
 pub use mat_anim::{
-    playing_seq, register_fx_uv, register_tint, sample_mat_anim, AnimMatPart, FxUvLoops, MatAnim,
-    TintAnimMaterials, TintLoop, UvAnimMaterials,
+    playing_seq, register_entity_uv, register_fx_uv, register_tint, sample_mat_anim, AnimMatPart,
+    MatAnim, TintAnimMaterials, TintLoop, UvAnimMaterials, UvLoops,
 };
 pub(crate) use mat_anim::{register_uv, UvLoop};
 
diff --git a/crates/benilla-world/src/model_render.rs b/crates/benilla-world/src/model_render.rs
index 407fca9a..69c96e51 100644
--- a/crates/benilla-world/src/model_render.rs
+++ b/crates/benilla-world/src/model_render.rs
@@ -17,7 +17,7 @@ pub mod lazy;
 pub mod park;
 mod visibility;
 
-pub use batch::{BatchVariants, M2BatchMaterials, ModelMaterials, SkyboxBatch};
+pub use batch::{BatchVariants, EntityUvLane, M2BatchMaterials, ModelMaterials, SkyboxBatch};
 
 /// Yards of transparent-pass sort bias per authored batch-order step (`MatKey::batch_order` ×
 /// this, on `StandardMaterial::depth_bias` — bevy adds that field to the phase item's sort
diff --git a/crates/benilla-world/src/model_render/batch.rs b/crates/benilla-world/src/model_render/batch.rs
index ea4f7263..93cc786b 100644
--- a/crates/benilla-world/src/model_render/batch.rs
+++ b/crates/benilla-world/src/model_render/batch.rs
@@ -58,6 +58,23 @@ pub struct BatchVariants {
     pub zfill: Option<Handle<WowModelMaterial>>,
 }
 
+/// The **UV lane** an [`M2BatchMaterials::entity_variants`] call registers into (decision 2295) —
+/// the animated-material registry, the delta table (decision 1381) and, for the one measured class
+/// that needs it, the instance the materials belong to.
+///
+/// A bundle rather than three arguments because they are one thing — *where this batch's texture
+/// transform is delivered* — and because the shape that keeps failing on this lane is a caller who
+/// takes some of the pieces and not the rest.
+pub struct EntityUvLane<'a> {
+    pub reg: &'a mut crate::doodad_anim::UvAnimMaterials,
+    pub table: &'a mut crate::mat_anim_table::MatAnimTable,
+    /// `Some` when these materials belong to ONE instance rather than to the batch — the clone a
+    /// spawner makes for a GameObject whose file-sequence slots bake different loops (1408's
+    /// population, reached from the entity side by 2295). `None` — the overwhelming majority — is
+    /// the shared, deduped material every instance of the batch draws through.
+    pub instance: Option<Entity>,
+}
+
 /// The pair one skybox batch draws with ([`M2BatchMaterials::skybox`]): the authored blend at full
 /// weight, and the promoted SRC_ALPHA twin the 4-second crossfade rides (equal to `steady` when the
 /// authored blend already blends).
@@ -239,11 +256,27 @@ impl M2BatchMaterials<'_> {
     /// The full variant set an **entity** part needs: every M2 entity — unit, player, GameObject,
     /// held item, spell effect — is built LIT and carries the same indoor pair, because the
     /// reference hands every entity M2 the same entity-node fill (wow-re `unit-m2-shader-light`).
+    ///
+    /// **It also puts the batch on the UV lane** (decision 2295), and takes `uv` for exactly that
+    /// reason rather than leaving it to the caller: seeding a material's `sun_scale.zw` and
+    /// registering it for the per-frame sample are one fact — *this batch's texture transform
+    /// runs* — and the recurring bug on this lane is a caller that does one and not the other
+    /// (2038 marked without registering and froze every waterfall; a `play_uv` flip without a
+    /// registration would freeze every entity batch at its first key instead of its identity,
+    /// which is a different wrong frame, not a fix). Every variant that carries the loop is
+    /// registered here, because a unit walking indoors or feathering in swaps material and would
+    /// otherwise stop scrolling mid-stride.
+    ///
+    /// The **depth-prime twin is deliberately not registered**, matching the placed-doodad lane
+    /// (`terrain_stream::spawn::assemble` registers the cutout and blend materials and no other):
+    /// it draws only while a batch feathers, and its alpha test reading unscrolled UVs for those
+    /// frames is the behaviour the streamer has always had.
     pub fn entity_variants(
         &mut self,
         sub: &ModelSubmesh,
         texture: Option<Handle<Image>>,
         order: u16,
+        uv: &mut EntityUvLane<'_>,
     ) -> Option<BatchVariants> {
         let light = self.light.as_ref()?.0.clone();
         let steady = self.build(
@@ -253,7 +286,7 @@ impl M2BatchMaterials<'_> {
             ShadeSel::Lit,
             false,
             false,
-            false,
+            true,
             &light,
         );
         let interior = self.build(
@@ -263,7 +296,7 @@ impl M2BatchMaterials<'_> {
             ShadeSel::Matte,
             false,
             false,
-            false,
+            true,
             &light,
         );
         let interior_bake = self.build(
@@ -273,7 +306,7 @@ impl M2BatchMaterials<'_> {
             ShadeSel::Matte,
             true,
             false,
-            false,
+            true,
             &light,
         );
         // A multiply batch (Mod/Mod2x) and an authored-Blend batch are their own twin: the first
@@ -296,7 +329,7 @@ impl M2BatchMaterials<'_> {
                 ShadeSel::Lit,
                 false,
                 true,
-                false,
+                true,
                 &light,
             )
         };
@@ -310,10 +343,31 @@ impl M2BatchMaterials<'_> {
                 ShadeSel::Matte,
                 true,
                 true,
-                false,
+                true,
                 &light,
             )
         };
+        // On the lane, now, in the same call that built and seeded them. `register_entity_uv` is
+        // idempotent per material, so the variants that collapsed onto each other cost nothing.
+        let loops = crate::doodad_anim::UvLoops::of(sub);
+        if loops.animates() {
+            for id in [
+                &steady,
+                &interior,
+                &interior_bake,
+                &interior_bake_blend,
+                &fade_blend,
+            ] {
+                crate::doodad_anim::register_entity_uv(
+                    uv.reg,
+                    uv.table,
+                    &mut self.materials,
+                    id.id(),
+                    &loops,
+                    uv.instance,
+                );
+            }
+        }
         Some(BatchVariants {
             steady,
             interior,
diff --git a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
index 255539dc..ec7af3c8 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
@@ -622,7 +622,7 @@ pub fn spawn_model_entities(
                     anim_table,
                     materials,
                     id,
-                    crate::doodad_anim::UvLoop::Shared(anim.clone()),
+                    crate::doodad_anim::UvLoop::Shared(Some(anim.clone())),
                 );
             }
         }