diff --git a/crates/benilla-world/src/lib.rs b/crates/benilla-world/src/lib.rs
index 02aef8e8..38281004 100644
--- a/crates/benilla-world/src/lib.rs
+++ b/crates/benilla-world/src/lib.rs
@@ -146,6 +146,8 @@ mod shaders;
 pub mod sky;
 pub mod sky_order;
 pub mod skybox;
+// MONKEY (skybox): the skybox rig and material loops.
+mod skybox_anim;
 pub mod static_gx;
 pub mod static_merge;
 pub mod straddle;
diff --git a/crates/benilla-world/src/model_render/batch.rs b/crates/benilla-world/src/model_render/batch.rs
index 9adc718e..eeeded74 100644
--- a/crates/benilla-world/src/model_render/batch.rs
+++ b/crates/benilla-world/src/model_render/batch.rs
@@ -110,11 +110,16 @@ impl M2BatchMaterials<'_> {
     /// (`[CM2Model+0x180]`, from the interior crossfade `[0xce9bdc]`) scales every batch's alpha,
     /// and `0 < A < 1` promotes a batch to SRC_ALPHA blending (`0x70c190`): `fade_blend` is that
     /// twin, or `steady` when the batch already blends.
+    ///
+    /// MONKEY (skybox): `uv` and `tint` are the batch's texture-transform and colour loops, the
+    /// material's seed and identity; [`crate::skybox_anim`] drives their rows.
     pub fn skybox(
         &mut self,
         sub: &benilla_formats::RenderSubmesh,
         texture: Option<Handle<Image>>,
         order: u16,
+        uv: Option<&std::sync::Arc<benilla_formats::UvAnim>>,
+        tint: Option<&std::sync::Arc<benilla_formats::RgbAnim>>,
     ) -> Option<SkyboxBatch> {
         let light = self.light.as_ref()?.0.clone();
         let torch = self.torch.binds()?;
@@ -136,10 +141,9 @@ impl M2BatchMaterials<'_> {
                 sub.env_map,
                 ShadeSel::Lit, // unread: every shipped skybox batch is UNLIT (0x01)
                 order,
-                // No texture-transform or colour loop: neither shipped skybox authors one. Wiring
-                // one needs the `M2Model` lane's `Arc`, which the material key identifies it by.
-                None,
-                None,
+                // MONKEY (skybox): the loops' `Arc`s, which the material key identifies them by.
+                uv,
+                tint,
                 None, // M2: no MOBA class, no SIDN, no WINDOW
                 None,
                 false,
@@ -161,6 +165,40 @@ impl M2BatchMaterials<'_> {
         Some(SkyboxBatch { steady, fade_blend })
     }
 
+    /// MONKEY (skybox): the flag `0x4` fog cone's material: an untextured, unlit, two-sided blend
+    /// on the sky lane, its colour the vertex colour times the tint row the skybox lane writes.
+    pub fn sky_fog_cone(&mut self, order: u16) -> Option<Handle<WowModelMaterial>> {
+        let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
+        Some(model_material(
+            &mut self.cache.0,
+            &mut self.materials,
+            None,
+            ModelBlend::Blend,
+            true,
+            false,
+            false,
+            true, // unlit
+            false,
+            false,
+            true,  // never writes depth
+            false, // …and always tests it
+            benilla_formats::FogPolicy::Off,
+            false,
+            ShadeSel::Lit,
+            order,
+            None,
+            None,
+            None,
+            None,
+            false,
+            true, // the sky lane
+            &light,
+            &torch,
+            None,
+        ))
+    }
+
     /// One steady material lit by a render target's own light buffer (a portrait booth, the model
     /// pane, char-select), which [`super::MatKey::light`] keys apart from the world. `rig` lights
     /// by the scene's authored M2 rig ([`ShadeSel::Rig`]) and plays the UV animation. `order` must
diff --git a/crates/benilla-world/src/skybox.rs b/crates/benilla-world/src/skybox.rs
index d4995c09..c7ab7add 100644
--- a/crates/benilla-world/src/skybox.rs
+++ b/crates/benilla-world/src/skybox.rs
@@ -14,31 +14,88 @@
 //! both moons, gradient band and cloud dome; below it they draw under the sky. The glare quads
 //! draw on their own path (`0x483740` → `0x6d48c0` → `0x7e57e0`), and the fog, ambient and
 //! diffuse are untouched.
+//!
+//! MONKEY (skybox): a third slot, the living player's zone skybox, behind the cvar
+//! `zoneSkyboxes` ([`ZoneSkyboxes`]). The 1.12 engine never draws a `LightParams` skybox for the
+//! living; the modern client does, weighted by the Light sphere falloff
+//! ([`benilla_formats::LightCatalog::zone_skyboxes`]). The backdrop is a weighted list
+//! ([`CameraSkybox`]): ghost > WMO > zone, the WMO sky crossfading the zone list by the modern
+//! collector's rule. `LightSkybox.dbc` flags from the extended table: `0x1` plays sequence 0 over
+//! the game day, `0x2` keeps the celestial pass, `0x4` draws a fog-colour cone over the horizon;
+//! a celestial model draws as a layer under its main model. Every batch animates
+//! ([`crate::skybox_anim`]): bones, texture transforms, colour and alpha tracks.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
 
 use bevy::asset::RenderAssetUsages;
+use bevy::camera::visibility::NoFrustumCulling;
+use bevy::math::Affine3A;
 use bevy::mesh::{Indices, MeshTag, PrimitiveTopology};
 use bevy::prelude::*;
 
 use crate::model_render::M2BatchMaterials;
+use crate::skybox_anim::{SkyMatLane, SkyRig};
 use crate::view::WorldCamera;
 use benilla_assets::coords::{bevy_to_wow, wow_to_bevy};
 use benilla_assets::materials::WowModelMaterial;
 use benilla_assets::WmoModel;
 use benilla_assets::{LockRecover, WorldAssets};
+use benilla_formats::{SKYBOX_FOG_BLEND, SKYBOX_FULL_DAY, SKYBOX_KEEP_CELESTIAL};
 
 /// The MOGP/MOGI group flag asking for the root's MOSB sky; the loader keeps the MOGP copy in
 /// `WmoGroupNav::flags`.
 const SHOW_SKYBOX: u32 = 0x40000;
 
-/// The skybox model this frame asks for; `None` leaves the [`crate::sky`] gradient dome.
-#[derive(Resource, Default, PartialEq, Eq)]
-pub struct CameraSkybox(pub Option<String>);
+/// MONKEY (skybox): batch-order base of a main model's batches; a celestial layer takes `1..`, so
+/// it draws first, under the main model, and the fog cone takes [`FOG_CONE_ORDER`], last.
+const MAIN_ORDER_BASE: u16 = 24;
+/// MONKEY (skybox): the fog cone's batch order, the band's last distinct step.
+const FOG_CONE_ORDER: u16 = 56;
+
+/// MONKEY (skybox): cvar `zoneSkyboxes` (0/1, default 0): draw the living player's zone skybox
+/// from `LightParams`. Off leaves the reference's two slots only.
+#[derive(Resource, Default, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct ZoneSkyboxes(pub bool);
+
+/// One skybox model the frame asks for, at its weight.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SkyboxLayer {
+    /// The model path, as the slot named it.
+    pub path: String,
+    /// The slot weight, `[0, 1]`; 0 fills the slot without drawing (`0x6d4afe`).
+    pub weight: f32,
+    /// `LightSkybox.dbc` flags, 0 without a row or in the 1.12 table.
+    pub flags: u32,
+    /// The celestial layer of another layer's row, drawn under it.
+    pub celestial: bool,
+}
+
+/// The skybox models this frame asks for; empty leaves the [`crate::sky`] gradient dome.
+#[derive(Resource, Default, PartialEq)]
+pub struct CameraSkybox(pub Vec<SkyboxLayer>);
+
+impl CameraSkybox {
+    /// The heaviest main layer, the one a readout names.
+    pub fn primary(&self) -> Option<&SkyboxLayer> {
+        self.0
+            .iter()
+            .filter(|l| !l.celestial)
+            .fold(None, |best: Option<&SkyboxLayer>, l| match best {
+                Some(b) if b.weight >= l.weight => Some(b),
+                _ => Some(l),
+            })
+    }
+
+    fn layer(&self, path: &str) -> Option<&SkyboxLayer> {
+        self.0.iter().find(|l| l.path == path)
+    }
+}
 
 /// The skybox slot's weight this frame: the interior crossfade [`crate::lighting::WmoCrossfade`]
 /// (±0.25/s, `[0x8115b0]`) for a WMO sky, 1.0 for the ghost sky (`0x6d2260`), and 0 when none
-/// resolves.
+/// resolves. MONKEY (skybox): the heaviest layer that does not keep the celestial pass (flag
+/// `0x2`), so a combining zone sky never stands the procedural sky down.
 #[derive(Resource, Default, PartialEq)]
 pub struct SkyboxWeight(pub f32);
 
@@ -60,22 +117,55 @@ struct SkyboxPart {
     /// The blend-promotion twin for `0 < weight < 1` (`0x811fe0`); `steady` itself when the batch
     /// already blends.
     fade_blend: Handle<WowModelMaterial>,
+    /// MONKEY (skybox): the batch's colour-alpha × transparency loops (`0x707680`).
+    alpha: Option<benilla_formats::AlphaAnim>,
+    /// MONKEY (skybox): the last sampled alpha factor.
+    anim_alpha: f32,
+    /// MONKEY (skybox): the batch's texture-transform and colour rows.
+    lane: SkyMatLane,
+    /// MONKEY (skybox): how the rig moves the batch.
+    pose: PartPose,
 }
 
-/// A batch wholly weighted to one parentless rotation-only bone, so it spins rigidly about the
-/// bone's pivot ([`benilla_formats::BoneSpin`]) with no joint children, which would lag the
-/// post-propagation anchor a frame. Only `CavernsOfTimeSky.m2`'s four asteroid belts spin.
-#[derive(Component)]
-struct SkyboxSpin {
-    /// The bone's pivot, in the same (Bevy) space the batch's vertices were baked into.
-    pivot: Vec3,
-    spin: benilla_formats::BoneSpin,
+/// MONKEY (skybox): how a batch follows its model's rig.
+enum PartPose {
+    /// No moving bone under the batch.
+    Static,
+    /// Wholly weighted to one bone: the bone's matrix is the batch's transform.
+    Rigid(u16),
+    /// Spread over moving bones: skinned on the CPU into its mesh.
+    Skinned {
+        mesh: Handle<Mesh>,
+        base: Vec<Vec3>,
+        joints: Vec<[u16; 4]>,
+        weights: Vec<[f32; 4]>,
+    },
 }
 
+/// MONKEY (skybox): the batch's model-space pose this frame, composed with the eye in
+/// [`follow_camera`].
+#[derive(Component, Default)]
+struct SkyboxLocal(Affine3A);
+
 /// Skybox paths built this session, failed loads included, so a failure is not retried per frame.
 #[derive(Resource, Default)]
 struct BuiltSkyboxes(HashSet<String>);
 
+/// MONKEY (skybox): each built model's rig, by path.
+#[derive(Resource, Default)]
+struct SkyRigs(HashMap<String, Arc<SkyRig>>);
+
+/// MONKEY (skybox): the flag `0x4` fog cone: its entity and its tint row.
+#[derive(Resource, Default)]
+struct FogCone {
+    entity: Option<Entity>,
+    slot: Option<u16>,
+}
+
+/// MONKEY (skybox): marks the fog cone's entity.
+#[derive(Component)]
+struct FogConePart;
+
 /// [`CameraSkybox`] is settled after this set; the dome's gate runs after it, so the two backdrops
 /// agree within a frame.
 #[derive(SystemSet, Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -89,9 +179,17 @@ impl Plugin for SkyboxPlugin {
         app.init_resource::<CameraSkybox>()
             .init_resource::<SkyboxWeight>()
             .init_resource::<BuiltSkyboxes>()
+            .init_resource::<ZoneSkyboxes>()
+            .init_resource::<SkyRigs>()
+            .init_resource::<FogCone>()
             .add_systems(
                 Update,
-                (resolve_camera_skybox, build_skybox, apply_skybox_visibility)
+                (
+                    resolve_camera_skybox,
+                    build_skybox,
+                    animate_skyboxes,
+                    apply_skybox_visibility,
+                )
                     .chain()
                     // After the PVS pass, whose flood this reads the same frame.
                     .after(crate::wmo_portal::WmoPvsSet)
@@ -108,9 +206,49 @@ impl Plugin for SkyboxPlugin {
     }
 }
 
+/// MONKEY (skybox): a path as `model_path` spells it, for comparing a MOSB name with a DBC one.
+fn norm(path: &str) -> String {
+    let lower = path.to_ascii_lowercase();
+    match lower
+        .strip_suffix(".mdx")
+        .or_else(|| lower.strip_suffix(".mdl"))
+    {
+        Some(stem) => format!("{stem}.m2"),
+        None => lower,
+    }
+}
+
+/// MONKEY (skybox): the modern collector's step on layers (`addSkyBox`): the same model keeps the
+/// larger weight and every other layer is scaled by `1 − weight`.
+fn collect_layer(layers: &mut Vec<SkyboxLayer>, path: &str, weight: f32, flags: u32) {
+    let key = norm(path);
+    let at = match layers.iter().position(|l| norm(&l.path) == key) {
+        Some(i) => {
+            layers[i].weight = layers[i].weight.max(weight);
+            i
+        }
+        None => {
+            layers.push(SkyboxLayer {
+                path: path.to_owned(),
+                weight,
+                flags,
+                celestial: false,
+            });
+            layers.len() - 1
+        }
+    };
+    let w = layers[at].weight;
+    for (i, l) in layers.iter_mut().enumerate() {
+        if i != at {
+            l.weight *= 1.0 - w;
+        }
+    }
+}
+
 /// Resolve the wanted skybox and its weight. A WMO sky needs a group of the placement's flood PVS,
 /// not the camera's own group, to carry [`SHOW_SKYBOX`] (`0x6b42e0`, `ebx` the group visited) and
 /// its root to name a MOSB; the weight rides the down-ray claim's crossfade, a separate resolver.
+#[allow(clippy::too_many_arguments)]
 fn resolve_camera_skybox(
     instances: Query<&crate::wmo_portal::WmoPortalInstance>,
     wmos: Res<Assets<WmoModel>>,
@@ -119,71 +257,158 @@ fn resolve_camera_skybox(
     current_map: Option<Res<crate::world_map::CurrentMap>>,
     cam: Query<&GlobalTransform, With<WorldCamera>>,
     crossfade: Res<crate::lighting::WmoCrossfade>,
+    zone: Res<ZoneSkyboxes>,
+    weather: Option<Res<crate::weather::WeatherState>>,
+    eye_liquid: crate::liquid::EyeLiquid,
     mut want: ResMut<CameraSkybox>,
     mut weight: ResMut<SkyboxWeight>,
 ) {
+    let pos = cam.single().ok().map(|t| bevy_to_wow(t.translation()));
+    let map = current_map.as_ref().map_or(0, |m| m.0);
+    let catalog = sampler.as_ref().map(|s| &s.0);
+    let flags_of = |path: &str| {
+        catalog
+            .and_then(|c| c.skybox_def_by_path(&norm(path)))
+            .map_or(0, |d| d.flags)
+    };
+    let mut layers: Vec<SkyboxLayer> = Vec::new();
+
     // The ghost sky first, as its slot skips the WMO one. Resolved from the atmosphere's map and
     // camera position, off the same ghost flag (`PLAYER_FLAGS` 0x10), so the two switch together.
-    if viewer.ghost {
-        let ghost_sky = sampler.as_ref().and_then(|s| {
-            let pos = bevy_to_wow(cam.single().ok()?.translation());
-            let map = current_map.as_ref().map_or(0, |m| m.0);
-            s.0.ghost_skybox(map, pos)
+    let ghost_sky = viewer
+        .ghost
+        .then(|| catalog.zip(pos).and_then(|(c, p)| c.ghost_skybox(map, p)))
+        .flatten();
+    if let Some(sky) = ghost_sky {
+        // The DBC slot's weight is 1.0 whenever filled (`0x6d26cb`/`0x6d26d0`): it pops in.
+        layers.push(SkyboxLayer {
+            path: sky.to_owned(),
+            weight: 1.0,
+            flags: flags_of(sky),
+            celestial: false,
         });
-        if let Some(sky) = ghost_sky {
-            if want.0.as_deref() != Some(sky) {
-                want.0 = Some(sky.to_owned());
+    } else {
+        // MONKEY (skybox): the zone list, under the WMO slot. Hidden submerged, as the celestial
+        // pass is; a storm lerps the storm slot's list over the clear one, as the atmosphere does.
+        if zone.0 && !eye_liquid.submersion().any() {
+            if let (Some(c), Some(p)) = (catalog, pos) {
+                let storm = weather
+                    .as_ref()
+                    .map_or(0.0, |w| crate::weather::storm_blend(w.sky_density));
+                let mut acc: Vec<(u32, f32)> = c
+                    .zone_skyboxes(map, p, false, benilla_formats::Submersion::Dry)
+                    .into_iter()
+                    .map(|e| (e.id, e.weight * (1.0 - storm)))
+                    .collect();
+                if storm > 0.0 {
+                    for e in c.zone_skyboxes(map, p, true, benilla_formats::Submersion::Dry) {
+                        match acc.iter_mut().find(|a| a.0 == e.id) {
+                            Some(a) => a.1 += e.weight * storm,
+                            None => acc.push((e.id, e.weight * storm)),
+                        }
+                    }
+                }
+                for (id, w) in acc {
+                    let Some(def) = c.skybox_def(id) else {
+                        continue;
+                    };
+                    if w <= 0.0 {
+                        continue;
+                    }
+                    match layers.iter_mut().find(|l| norm(&l.path) == def.path) {
+                        Some(l) => l.weight = l.weight.max(w),
+                        None => layers.push(SkyboxLayer {
+                            path: def.path.clone(),
+                            weight: w,
+                            flags: def.flags,
+                            celestial: false,
+                        }),
+                    }
+                }
+            }
+        }
+        // `min()`, not the first match: query order is unstable across frames, and two
+        // overlapping Caverns of Time shells both qualify.
+        let resolved = instances
+            .iter()
+            .filter_map(|inst| {
+                let model = wmos.get(&inst.handle)?;
+                // The MOSB test first: 810 of the game's 815 WMO roots name no skybox.
+                let sky = model.skybox.as_deref()?;
+                model
+                    .group_nav
+                    .iter()
+                    .enumerate()
+                    .any(|(i, nav)| {
+                        // Fail closed, unlike the cull: a lookup miss here would paint a sky over
+                        // the whole world.
+                        nav.flags & SHOW_SKYBOX != 0
+                            && inst.visible.get(i).copied().unwrap_or(false)
+                    })
+                    .then(|| sky.to_owned())
+            })
+            .min();
+        // The WMO slot's weight is the interior crossfade `[0xce9bdc]`; a name seen through a
+        // doorway at weight 0 fills the slot, which `0x6d4afe` declines to draw.
+        if let Some(sky) = resolved {
+            let t = crossfade.t();
+            let flags = flags_of(&sky);
+            if t > 0.0 {
+                collect_layer(&mut layers, &sky, t, flags);
+            } else if !layers.iter().any(|l| norm(&l.path) == norm(&sky)) {
+                layers.push(SkyboxLayer {
+                    path: sky,
+                    weight: 0.0,
+                    flags,
+                    celestial: false,
+                });
             }
-            // The DBC slot's weight is 1.0 whenever filled (`0x6d26cb`/`0x6d26d0`): it pops in.
-            weight.set_if_neq(SkyboxWeight(1.0));
-            return;
         }
     }
-    // `min()`, not the first match: query order is unstable across frames, and two overlapping
-    // Caverns of Time shells both qualify.
-    let resolved = instances
+    // MONKEY (skybox): each row's celestial model, a layer at its main model's weight and flags.
+    let celestial: Vec<SkyboxLayer> = layers
         .iter()
-        .filter_map(|inst| {
-            let model = wmos.get(&inst.handle)?;
-            // The MOSB test first: 810 of the game's 815 WMO roots name no skybox.
-            let sky = model.skybox.as_deref()?;
-            model
-                .group_nav
-                .iter()
-                .enumerate()
-                .any(|(i, nav)| {
-                    // Fail closed, unlike the cull: a lookup miss here would paint a sky over the
-                    // whole world.
-                    nav.flags & SHOW_SKYBOX != 0 && inst.visible.get(i).copied().unwrap_or(false)
-                })
-                .then(|| sky.to_owned())
+        .filter_map(|l| {
+            let path = catalog?
+                .skybox_def_by_path(&norm(&l.path))?
+                .celestial
+                .clone()?;
+            Some(SkyboxLayer {
+                path,
+                weight: l.weight,
+                flags: l.flags,
+                celestial: true,
+            })
         })
-        .min();
-    if want.0 != resolved {
-        want.0 = resolved;
+        .collect();
+    layers.extend(celestial);
+    if want.0 != layers {
+        want.0 = layers;
     }
-    // The WMO slot's weight is the interior crossfade `[0xce9bdc]`; a name seen through a doorway
-    // at weight 0 fills the slot, which `0x6d4afe` declines to draw.
-    weight.set_if_neq(SkyboxWeight(match want.0 {
-        Some(_) => crossfade.t(),
-        None => 0.0,
-    }));
+    let stand_down = want
+        .0
+        .iter()
+        .filter(|l| l.flags & SKYBOX_KEEP_CELESTIAL == 0)
+        .map(|l| l.weight)
+        .fold(0.0, f32::max);
+    weight.set_if_neq(SkyboxWeight(stand_down));
 }
 
-/// Build the wanted skybox on first request; the models are small and few, so it stays built.
+/// Build the wanted skyboxes on first request; the models are small and few, so they stay built.
+#[allow(clippy::too_many_arguments)]
 fn build_skybox(
     mut commands: Commands,
     want: Res<CameraSkybox>,
     mut built: ResMut<BuiltSkyboxes>,
+    mut rigs: ResMut<SkyRigs>,
+    mut cone: ResMut<FogCone>,
     world_assets: Option<ResMut<WorldAssets>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut images: ResMut<Assets<Image>>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
     mut mats: M2BatchMaterials,
 ) {
-    let Some(path) = want.0.as_deref() else {
-        return;
-    };
-    if built.0.contains(path) {
+    if want.0.is_empty() {
         return;
     }
     // Before the shared light buffer exists: retry, without latching `built`.
@@ -193,84 +418,213 @@ fn build_skybox(
     let Some(mut world_assets) = world_assets else {
         return; // assetless run: the gradient dome stays the backdrop
     };
-    // The model's rigid spins by bone; none under a deterministic run, which keeps bind poses.
-    let spins = if crate::dev_state::deterministic_run() {
-        Default::default()
-    } else {
-        benilla_formats::load_m2_bone_spins(&mut world_assets.chain.lock_recover(), path)
-            .unwrap_or_default()
-    };
-    let subs = benilla_formats::load_m2_mesh(&mut world_assets.chain.lock_recover(), path);
-    let subs = match subs {
-        Ok(subs) if !subs.is_empty() => subs,
-        Ok(_) => {
-            warn!("skybox '{path}' has no render batches — keeping the gradient dome");
-            built.0.insert(path.to_string());
-            return;
+    if cone.entity.is_none() && want.0.iter().any(|l| l.flags & SKYBOX_FOG_BLEND != 0) {
+        build_fog_cone(&mut commands, &mut cone, &mut meshes, &mut table, &mut mats);
+    }
+    for layer in &want.0 {
+        let path = layer.path.as_str();
+        if built.0.contains(path) {
+            continue;
         }
-        Err(e) => {
-            warn!("skybox '{path}' failed to load, keeping the gradient dome: {e:#}");
-            built.0.insert(path.to_string());
-            return;
-        }
-    };
-    for (i, sub) in subs.iter().enumerate() {
-        let mut mesh = Mesh::new(
-            PrimitiveTopology::TriangleList,
-            RenderAssetUsages::default(),
-        );
-        let positions: Vec<[f32; 3]> = sub
-            .positions
-            .iter()
-            .map(|p| wow_to_bevy(*p).to_array())
-            .collect();
-        mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
-        // Unread by the unlit sky, but the shared shader's vertex layout needs it.
-        mesh.insert_attribute(
-            Mesh::ATTRIBUTE_NORMAL,
-            sub.normals
-                .iter()
-                .map(|n| wow_to_bevy(*n).to_array())
-                .collect::<Vec<_>>(),
+        // MONKEY (skybox): the rig, off the same bytes the batches come from.
+        let bytes = world_assets
+            .chain
+            .lock_recover()
+            .read_file(&norm(path))
+            .ok();
+        let rig = Arc::new(
+            bytes
+                .as_deref()
+                .map(SkyRig::from_bytes)
+                .unwrap_or_default(),
         );
-        mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, sub.uvs.clone());
-        mesh.insert_indices(Indices::U32(sub.indices.clone()));
-        // The batch's authored address mode: Caverns of Time's belts wrap their UVs.
-        let texture = sub
-            .texture
-            .as_deref()
-            .and_then(|t| world_assets.texture(t, (sub.wrap_x, sub.wrap_y), &mut images));
-        // `i + 1`, the authored batch order (0 is unordered): every batch shares one sort distance.
-        let Some(pair) = mats.skybox(sub, texture, u16::try_from(i + 1).unwrap_or(0)) else {
-            return; // light buffer vanished mid-build; `built` is unlatched, so we retry
+        let subs = benilla_formats::load_m2_mesh(&mut world_assets.chain.lock_recover(), path);
+        let subs = match subs {
+            Ok(subs) if !subs.is_empty() => subs,
+            Ok(_) => {
+                warn!("skybox '{path}' has no render batches — keeping the gradient dome");
+                built.0.insert(path.to_string());
+                continue;
+            }
+            Err(e) => {
+                warn!("skybox '{path}' failed to load, keeping the gradient dome: {e:#}");
+                built.0.insert(path.to_string());
+                continue;
+            }
         };
-        let part = commands
-            .spawn((
-                Mesh3d(meshes.add(mesh)),
-                MeshMaterial3d(pair.steady.clone()),
-                Transform::default(),
-                Visibility::Hidden, // `apply_skybox_visibility` turns on exactly the wanted one
-                // The crossfade's alpha (bits 0..=5), written only by `apply_skybox_visibility`.
-                MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
-                SkyboxPart {
-                    path: path.to_string(),
-                    steady: pair.steady,
-                    fade_blend: pair.fade_blend,
+        let base = if layer.celestial { 0 } else { MAIN_ORDER_BASE };
+        for (i, sub) in subs.iter().enumerate() {
+            let mut mesh = Mesh::new(
+                PrimitiveTopology::TriangleList,
+                RenderAssetUsages::default(),
+            );
+            let positions: Vec<Vec3> = sub.positions.iter().map(|p| wow_to_bevy(*p)).collect();
+            mesh.insert_attribute(
+                Mesh::ATTRIBUTE_POSITION,
+                positions.iter().map(|p| p.to_array()).collect::<Vec<_>>(),
+            );
+            // Unread by the unlit sky, but the shared shader's vertex layout needs it.
+            mesh.insert_attribute(
+                Mesh::ATTRIBUTE_NORMAL,
+                sub.normals
+                    .iter()
+                    .map(|n| wow_to_bevy(*n).to_array())
+                    .collect::<Vec<_>>(),
+            );
+            mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, sub.uvs.clone());
+            // MONKEY (skybox): the constant M2Color, when the batch has one that is not white.
+            if sub.vertex_colors.len() == sub.positions.len()
+                && sub
+                    .vertex_colors
+                    .iter()
+                    .any(|c| c.iter().any(|v| (v - 1.0).abs() > 1e-3))
+            {
+                mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, sub.vertex_colors.clone());
+            }
+            mesh.insert_indices(Indices::U32(sub.indices.clone()));
+            // The batch's authored address mode: Caverns of Time's belts wrap their UVs.
+            let texture = sub
+                .texture
+                .as_deref()
+                .and_then(|t| world_assets.texture(t, (sub.wrap_x, sub.wrap_y), &mut images));
+            // MONKEY (skybox): the texture transform and colour loops as material identities.
+            let uv = sub.uv_anim.clone().map(Arc::new);
+            let tint = sub.rgb_anim.clone().map(Arc::new);
+            // The authored batch order after the layer's base (0 is unordered): every batch shares
+            // one sort distance.
+            let order = base + u16::try_from(i + 1).unwrap_or(0);
+            let Some(pair) = mats.skybox(sub, texture, order, uv.as_ref(), tint.as_ref()) else {
+                return; // light buffer vanished mid-build; `built` is unlatched, so we retry
+            };
+            let lane = SkyMatLane::register(
+                sub,
+                uv,
+                tint,
+                &mut table,
+                mats.materials(),
+                &[pair.steady.id(), pair.fade_blend.id()],
+            );
+            let mesh = meshes.add(mesh);
+            let pose = match sole_bone(sub) {
+                Some(b) if rig.bone_moves(b) => PartPose::Rigid(b),
+                Some(_) => PartPose::Static,
+                None if rig.animates() && !sub.joints.is_empty() => PartPose::Skinned {
+                    mesh: mesh.clone(),
+                    base: positions,
+                    joints: sub.joints.clone(),
+                    weights: sub.weights.clone(),
                 },
-            ))
-            .id();
-        if let Some(spin) = sole_bone(sub).and_then(|b| spins.get(&b)) {
-            commands.entity(part).insert(SkyboxSpin {
-                pivot: wow_to_bevy(spin.pivot),
-                spin: spin.clone(),
-            });
+                None => PartPose::Static,
+            };
+            let skinned = matches!(pose, PartPose::Skinned { .. });
+            let part = commands
+                .spawn((
+                    Mesh3d(mesh),
+                    MeshMaterial3d(pair.steady.clone()),
+                    Transform::default(),
+                    Visibility::Hidden, // `apply_skybox_visibility` turns on exactly the wanted one
+                    // The crossfade's alpha (bits 0..=5), written only by `apply_skybox_visibility`.
+                    MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
+                    SkyboxLocal::default(),
+                    SkyboxPart {
+                        path: path.to_string(),
+                        steady: pair.steady,
+                        fade_blend: pair.fade_blend,
+                        alpha: sub.alpha_anim.clone(),
+                        anim_alpha: 1.0,
+                        lane,
+                        pose,
+                    },
+                ))
+                .id();
+            if skinned {
+                // The mesh moves under its bounds; the shell surrounds the eye anyway.
+                commands.entity(part).insert(NoFrustumCulling);
+            }
         }
+        rigs.0.insert(path.to_string(), rig);
+        built.0.insert(path.to_string());
     }
-    built.0.insert(path.to_string());
 }
 
-/// The bone every vertex of this batch is wholly weighted to, if any: the batch's half of
-/// [`benilla_formats::BoneSpin`]'s rigid condition.
+/// MONKEY (skybox): the flag `0x4` cone, the modern client's sky-cone draw in the final fog colour
+/// (`skyMesh0x4Sky`): a band around the eye, opaque at and below the horizon, fading out by 24°
+/// of elevation. White vertices carry the alpha; the fog colour rides its tint row.
+fn build_fog_cone(
+    commands: &mut Commands,
+    cone: &mut FogCone,
+    meshes: &mut Assets<Mesh>,
+    table: &mut crate::mat_anim_table::MatAnimTable,
+    mats: &mut M2BatchMaterials,
+) {
+    const SEGMENTS: usize = 32;
+    const RADIUS: f32 = 40.0;
+    // (elevation degrees, alpha), bottom to top.
+    const RINGS: [(f32, f32); 7] = [
+        (-60.0, 1.0),
+        (0.0, 1.0),
+        (4.0, 0.85),
+        (8.0, 0.6),
+        (12.0, 0.35),
+        (18.0, 0.12),
+        (24.0, 0.0),
+    ];
+    let mut positions = Vec::new();
+    let mut colors = Vec::new();
+    for (elev, alpha) in RINGS {
+        let (se, ce) = elev.to_radians().sin_cos();
+        for s in 0..=SEGMENTS {
+            let az = s as f32 / SEGMENTS as f32 * std::f32::consts::TAU;
+            positions.push([RADIUS * ce * az.cos(), RADIUS * se, RADIUS * ce * az.sin()]);
+            colors.push([1.0, 1.0, 1.0, alpha]);
+        }
+    }
+    let row = SEGMENTS as u32 + 1;
+    let mut indices = Vec::new();
+    for r in 0..(RINGS.len() as u32 - 1) {
+        for s in 0..SEGMENTS as u32 {
+            let a = r * row + s;
+            let b = a + row;
+            indices.extend_from_slice(&[a, b, a + 1, a + 1, b, b + 1]);
+        }
+    }
+    let n = positions.len();
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, vec![[0.0, 1.0, 0.0]; n]);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, vec![[0.0, 0.0]; n]);
+    mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, colors);
+    mesh.insert_indices(Indices::U32(indices));
+    let Some(material) = mats.sky_fog_cone(FOG_CONE_ORDER) else {
+        return;
+    };
+    let slot = table.alloc();
+    if let Some(slot) = slot {
+        crate::model_render::lazy::with_material_mut(mats.materials(), material.id(), |m| {
+            m.extension.anim_slots.y = f32::from(slot);
+        });
+    }
+    let entity = commands
+        .spawn((
+            Mesh3d(meshes.add(mesh)),
+            MeshMaterial3d(material),
+            Transform::default(),
+            Visibility::Hidden,
+            MeshTag(crate::mesh_tag::spawn_tag(0, 1.0)),
+            SkyboxLocal::default(),
+            FogConePart,
+            NoFrustumCulling,
+        ))
+        .id();
+    cone.entity = Some(entity);
+    cone.slot = slot;
+}
+
+/// The bone every vertex of this batch is wholly weighted to, if any: a rigid batch takes the
+/// bone's matrix whole, with no skinning.
 fn sole_bone(sub: &benilla_formats::RenderSubmesh) -> Option<u16> {
     let bone = sub.joints.first()?[0];
     (sub.weights.len() == sub.joints.len()
@@ -283,22 +637,145 @@ fn sole_bone(sub: &benilla_formats::RenderSubmesh) -> Option<u16> {
     .then_some(bone)
 }
 
-/// Show the wanted skybox at the slot weight and hide every other, the sole `Visibility`, material
-/// and `MeshTag` writer for these entities. As the reference: hidden at weight 0 (`0x6d4afe`), the
-/// weight in every batch's alpha (`0x710cb0` → `[CM2Model+0x180]`), and below 1 the batch
-/// promoted to SRC_ALPHA blending whatever its mode (`0x811fe0`).
+/// MONKEY (skybox): one model's clock and pose this frame.
+struct ModelClock {
+    band_t: f32,
+    gseq: f64,
+    live: bool,
+    pose: Vec<Affine3A>,
+}
+
+/// MONKEY (skybox): pose every shown skybox and run its material loops on the model's clock:
+/// sequence 0 at `duration × day fraction` under flag `0x1`, else the scene clock. A capture keeps
+/// the bind pose and the seeds, as the shared lanes freeze, unless the day drives the clock.
+#[allow(clippy::too_many_arguments)]
+fn animate_skyboxes(
+    time: Res<Time>,
+    clock: Res<crate::lighting::GameClock>,
+    want: Res<CameraSkybox>,
+    rigs: Res<SkyRigs>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut parts: Query<(&mut SkyboxPart, &mut SkyboxLocal)>,
+    mut clocks: Local<HashMap<String, ModelClock>>,
+) {
+    if want.0.is_empty() {
+        return;
+    }
+    let deterministic = crate::dev_state::deterministic_run();
+    let now = time.elapsed_secs();
+    let day = clock.minute.min(1439) as f32 / 1440.0;
+    clocks.clear();
+    for layer in want.0.iter().filter(|l| l.weight > 0.0) {
+        let Some(rig) = rigs.0.get(&layer.path) else {
+            continue;
+        };
+        let (band_t, gseq, live) = if layer.flags & SKYBOX_FULL_DAY != 0 {
+            let g = if deterministic { 0.0 } else { f64::from(now) };
+            (rig.duration * day, g, true)
+        } else if deterministic {
+            (0.0, 0.0, false)
+        } else {
+            (now, f64::from(now), true)
+        };
+        let pose = if live && rig.animates() {
+            rig.pose(rig.band_time(band_t), gseq)
+        } else {
+            Vec::new()
+        };
+        clocks.insert(
+            layer.path.clone(),
+            ModelClock {
+                band_t,
+                gseq,
+                live,
+                pose,
+            },
+        );
+    }
+    for (mut part, mut local) in &mut parts {
+        let Some(c) = clocks.get(&part.path) else {
+            continue;
+        };
+        let seq = rigs.0.get(&part.path).and_then(|r| r.seq_slot);
+        let a = part
+            .alpha
+            .as_ref()
+            .map_or(1.0, |a| a.sample(seq, c.band_t, c.gseq).clamp(0.0, 1.0));
+        if part.anim_alpha != a {
+            part.anim_alpha = a;
+        }
+        if c.live && part.lane.any() {
+            part.lane.tick(c.band_t, c.gseq, &mut table);
+        }
+        let bone = |b: u16| {
+            c.pose
+                .get(usize::from(b))
+                .copied()
+                .unwrap_or(Affine3A::IDENTITY)
+        };
+        match &part.pose {
+            PartPose::Static => {}
+            PartPose::Rigid(b) => {
+                let m = bone(*b);
+                if local.0 != m {
+                    local.0 = m;
+                }
+            }
+            PartPose::Skinned {
+                mesh,
+                base,
+                joints,
+                weights,
+            } => {
+                if c.pose.is_empty() {
+                    continue;
+                }
+                let skinned: Vec<[f32; 3]> = base
+                    .iter()
+                    .zip(joints.iter().zip(weights))
+                    .map(|(p, (j, w))| {
+                        let mut out = Vec3::ZERO;
+                        for k in 0..4 {
+                            if w[k] > 0.0 {
+                                out += bone(j[k]).transform_point3(*p) * w[k];
+                            }
+                        }
+                        out.to_array()
+                    })
+                    .collect();
+                if let Some(m) = meshes.get_mut(mesh) {
+                    m.insert_attribute(Mesh::ATTRIBUTE_POSITION, skinned);
+                }
+            }
+        }
+    }
+}
+
+/// Show the wanted skyboxes at their layer weights and hide every other, the sole `Visibility`,
+/// material and `MeshTag` writer for these entities. As the reference: hidden at weight 0
+/// (`0x6d4afe`), the weight in every batch's alpha (`0x710cb0` → `[CM2Model+0x180]`), and below 1
+/// the batch promoted to SRC_ALPHA blending whatever its mode (`0x811fe0`). MONKEY (skybox): the
+/// weight carries the batch's alpha tracks too, and a layer that keeps the celestial pass draws
+/// its batches blended, so they sort over the procedural sky as the modern client orders them.
+#[allow(clippy::type_complexity)]
 fn apply_skybox_visibility(
     want: Res<CameraSkybox>,
-    weight: Res<SkyboxWeight>,
+    lighting: Res<crate::lighting::WowLighting>,
+    cone: Res<FogCone>,
+    mut table: ResMut<crate::mat_anim_table::MatAnimTable>,
     mut parts: Query<(
         &SkyboxPart,
         &mut Visibility,
         &mut MeshMaterial3d<WowModelMaterial>,
         &mut MeshTag,
     )>,
+    mut cones: Query<(&mut Visibility, &mut MeshTag), (With<FogConePart>, Without<SkyboxPart>)>,
 ) {
     for (part, mut vis, mut mat, mut tag) in &mut parts {
-        let show = weight.0 > 0.0 && want.0.as_deref() == Some(part.path.as_str());
+        let layer = want.layer(&part.path);
+        let w = layer.map_or(0.0, |l| l.weight) * part.anim_alpha;
+        let show = w > 0.0;
         let target = if show {
             Visibility::Visible
         } else {
@@ -310,7 +787,8 @@ fn apply_skybox_visibility(
         if !show {
             continue;
         }
-        let handle = if weight.0 < 1.0 {
+        let keep = layer.is_some_and(|l| l.flags & SKYBOX_KEEP_CELESTIAL != 0);
+        let handle = if w < 1.0 || keep {
             &part.fade_blend
         } else {
             &part.steady
@@ -318,44 +796,62 @@ fn apply_skybox_visibility(
         if mat.0 != *handle {
             mat.0 = handle.clone();
         }
-        let bits = crate::mesh_tag::with_alpha(tag.0, weight.0);
+        let bits = crate::mesh_tag::with_alpha(tag.0, w);
         if tag.0 != bits {
             tag.0 = bits;
         }
     }
+    // MONKEY (skybox): the fog cone at the heaviest fog-blending layer's weight, in the fog colour.
+    let Some(entity) = cone.entity else {
+        return;
+    };
+    let w = want
+        .0
+        .iter()
+        .filter(|l| l.flags & SKYBOX_FOG_BLEND != 0 && !l.celestial)
+        .map(|l| l.weight)
+        .fold(0.0, f32::max);
+    if let Ok((mut vis, mut tag)) = cones.get_mut(entity) {
+        let target = if w > 0.0 {
+            Visibility::Visible
+        } else {
+            Visibility::Hidden
+        };
+        if *vis != target {
+            *vis = target;
+        }
+        let bits = crate::mesh_tag::with_alpha(tag.0, w);
+        if tag.0 != bits {
+            tag.0 = bits;
+        }
+    }
+    if let (Some(slot), true) = (cone.slot, w > 0.0) {
+        let c = benilla_assets::quant255(lighting.fog_color);
+        table.set(slot, [c[0] - 1.0, c[1] - 1.0, c[2] - 1.0, 0.0]);
+    }
 }
 
 /// Pin the box to the camera, world-aligned and at authored scale, the model's origin at the eye as
 /// the reference places it (`0x707680` given a zeroed recentre vector, `0x6d4b3a`–`0x6d4b48`):
-/// `StratholmeSkybox` is authored off-centre, so recentring it would be wrong. A spinning batch
-/// turns about its bone's pivot inside the anchor, `T(eye) · T(pivot) · R(t) · T(−pivot)`, on the
-/// scene clock; the reference's phase starts at load, which a 66.7 s ring does not show.
+/// `StratholmeSkybox` is authored off-centre, so recentring it would be wrong. MONKEY (skybox): a
+/// posed batch rides its bone's matrix inside the anchor, `T(eye) · M(bone)`.
 #[allow(clippy::type_complexity)]
 fn follow_camera(
-    time: Res<Time>,
     cam: Query<&GlobalTransform, With<WorldCamera>>,
     mut parts: Query<
-        (&mut Transform, &mut GlobalTransform, Option<&SkyboxSpin>),
-        (With<SkyboxPart>, Without<WorldCamera>),
+        (&mut Transform, &mut GlobalTransform, &SkyboxLocal),
+        Without<WorldCamera>,
     >,
 ) {
     let Some(cam_gt) = cam.iter().next() else {
         return;
     };
-    let now = time.elapsed_secs();
-    for (mut tf, mut gt, spin) in &mut parts {
-        let (rot, pivot) = match spin {
-            Some(s) => (
-                benilla_assets::coords::wow_rotation_to_bevy(s.spin.sample(now)),
-                s.pivot,
-            ),
-            None => (Quat::IDENTITY, Vec3::ZERO),
-        };
-        tf.translation = cam_gt.translation() + pivot - rot * pivot;
-        tf.rotation = rot;
-        tf.scale = Vec3::ONE;
+    let eye = cam_gt.translation();
+    for (mut tf, mut gt, local) in &mut parts {
+        let m = Affine3A::from_translation(eye) * local.0;
+        *tf = Transform::from_matrix(m.into());
         // Propagation already ran this frame: the direct global write is what renders.
-        *gt = GlobalTransform::from(*tf);
+        *gt = GlobalTransform::from(m);
     }
 }
 
@@ -365,12 +861,13 @@ mod tests {
 
     /// On the real art: the seventeen other batches are wholly on bone 0, which has no track.
     #[test]
-    fn only_the_belt_batches_of_the_caverns_sky_resolve_to_a_spinning_bone() {
+    fn only_the_belt_batches_of_the_caverns_sky_resolve_to_a_moving_bone() {
         let data = benilla_formats::wow_data_or_skip!();
         let mut chain = benilla_formats::Chain::open(&data).expect("open vanilla patch chain");
         const SKY: &str = "Environments\\Stars\\CavernsOfTimeSky.m2";
         let subs = benilla_formats::load_m2_mesh(&mut chain, SKY).expect("load the sky");
-        let spins = benilla_formats::load_m2_bone_spins(&mut chain, SKY).expect("its spins");
+        let bytes = chain.read_file(SKY).expect("read the sky");
+        let rig = SkyRig::from_bytes(&bytes);
 
         let bones: Vec<Option<u16>> = subs.iter().map(sole_bone).collect();
         assert_eq!(bones.len(), 21, "21 authored batches");
@@ -388,11 +885,41 @@ mod tests {
                 .all(|(_, b)| *b == Some(0)),
             "every non-belt batch is wholly on bone 0: {bones:?}"
         );
-
-        let spinning = bones
+        let moving = bones
             .iter()
-            .filter(|b| b.and_then(|b| spins.get(&b)).is_some())
+            .filter(|b| b.is_some_and(|b| rig.bone_moves(b)))
             .count();
-        assert_eq!(spinning, 4, "exactly the four belt batches turn");
+        assert_eq!(moving, 4, "exactly the four belt batches turn");
+    }
+
+    fn layer(path: &str, weight: f32) -> SkyboxLayer {
+        SkyboxLayer {
+            path: path.into(),
+            weight,
+            flags: 0,
+            celestial: false,
+        }
+    }
+
+    #[test]
+    fn a_wmo_sky_crossfades_the_zone_sky() {
+        let mut layers = vec![layer("a.m2", 1.0)];
+        collect_layer(&mut layers, "B.MDX", 0.25, 0);
+        assert!((layers[0].weight - 0.75).abs() < 1e-6);
+        assert!((layers[1].weight - 0.25).abs() < 1e-6);
+        // The same model under another spelling merges.
+        collect_layer(&mut layers, "b.m2", 1.0, 0);
+        assert_eq!(layers.len(), 2);
+        assert_eq!(layers[0].weight, 0.0);
+    }
+
+    #[test]
+    fn the_primary_layer_is_the_heaviest_main_one() {
+        let mut sky = CameraSkybox(vec![layer("a", 0.4), layer("b", 0.6)]);
+        sky.0.push(SkyboxLayer {
+            celestial: true,
+            ..layer("c", 1.0)
+        });
+        assert_eq!(sky.primary().map(|l| l.path.as_str()), Some("b"));
     }
 }
diff --git a/crates/benilla-world/src/skybox_anim.rs b/crates/benilla-world/src/skybox_anim.rs
new file mode 100644
index 00000000..9f835f40
--- /dev/null
+++ b/crates/benilla-world/src/skybox_anim.rs
@@ -0,0 +1,527 @@
+//! MONKEY (skybox): the animated half of the skybox lane. A skybox draws camera-anchored at the far
+//! depth ([`crate::skybox`]), so it cannot ride the joint-entity rig: its anchor is written after
+//! transform propagation. Its bones are posed here on the CPU instead, each frame, from the armed
+//! sequence (animation id 0) and the global sequences, as `0x714260` composes them:
+//! `M = parent · T(pivot) · T(t) · R(q) · S(s) · T(−pivot)`. A batch wholly on one bone takes that
+//! bone's matrix as its transform; a batch spread over several moving bones is skinned on the CPU
+//! (skyboxes are a few thousand vertices).
+//!
+//! Its texture-transform, colour and alpha tracks run on the same clock through the shared
+//! mat-anim table ([`crate::mat_anim_table`]), in rows this module owns, so a skybox flagged
+//! `0x1` (sequence 0 across the game day) drives every channel from the day fraction.
+
+use std::sync::Arc;
+
+use bevy::math::Affine3A;
+use bevy::prelude::*;
+
+use benilla_assets::coords::{wow_rotation_to_bevy, wow_to_bevy};
+
+/// A key list for one channel: `(seconds, value)` time-ascending, and whether it interpolates.
+#[derive(Clone, Debug, Default)]
+struct Channel<V> {
+    keys: Vec<(f32, V)>,
+    linear: bool,
+}
+
+impl<V: Copy> Channel<V> {
+    /// The value at `t` (seconds inside the channel's own span): held before the first key and past
+    /// the last, stepped or blended between, as the reference's key search clamps.
+    fn sample(&self, t: f32, blend: impl Fn(V, V, f32) -> V) -> Option<V> {
+        let (&(t0, v0), rest) = self.keys.split_first()?;
+        if rest.is_empty() || t <= t0 {
+            return Some(v0);
+        }
+        let mut k = 0;
+        while k + 1 < self.keys.len() && self.keys[k + 1].0 <= t {
+            k += 1;
+        }
+        let (ta, va) = self.keys[k];
+        if !self.linear || k + 1 >= self.keys.len() {
+            return Some(va);
+        }
+        let (tb, vb) = self.keys[k + 1];
+        let f = if tb > ta { (t - ta) / (tb - ta) } else { 0.0 };
+        Some(blend(va, vb, f))
+    }
+}
+
+/// A global-sequence channel: keys in seconds over `period`, sampled at the free clock mod it.
+#[derive(Clone, Debug, Default)]
+struct GlobalChannel<V> {
+    period: f32,
+    channel: Channel<V>,
+}
+
+/// One bone's channels, Bevy space. A global-sequence channel replaces the sequence one.
+#[derive(Clone, Debug, Default)]
+struct BoneTracks {
+    translation: Channel<Vec3>,
+    rotation: Channel<Quat>,
+    scale: Channel<Vec3>,
+    g_translation: Option<GlobalChannel<Vec3>>,
+    g_rotation: Option<GlobalChannel<Quat>>,
+    g_scale: Option<GlobalChannel<Vec3>>,
+}
+
+impl BoneTracks {
+    fn moves(&self) -> bool {
+        !self.translation.keys.is_empty()
+            || !self.rotation.keys.is_empty()
+            || !self.scale.keys.is_empty()
+            || self.g_translation.is_some()
+            || self.g_rotation.is_some()
+            || self.g_scale.is_some()
+    }
+}
+
+/// A skybox model's rig: the bone tree and the armed sequence's tracks, Bevy space.
+#[derive(Debug, Default)]
+pub(crate) struct SkyRig {
+    parents: Vec<i16>,
+    pivots: Vec<Vec3>,
+    tracks: Vec<BoneTracks>,
+    /// The armed sequence's length in seconds and its file slot (the alpha bake's slot index).
+    pub(crate) duration: f32,
+    pub(crate) seq_slot: Option<usize>,
+    looping: bool,
+}
+
+fn lerp3(a: Vec3, b: Vec3, f: f32) -> Vec3 {
+    a.lerp(b, f)
+}
+
+fn slerp(a: Quat, b: Quat, f: f32) -> Quat {
+    a.slerp(b, f)
+}
+
+/// The interpolation flag of the `M2Track` at `track` (`interp_type != 0`), linear when unreadable.
+fn track_linear(bytes: &[u8], track: usize) -> bool {
+    bytes
+        .get(track..track + 2)
+        .is_none_or(|b| u16::from_le_bytes([b[0], b[1]]) != 0)
+}
+
+/// WoW-space scale to Bevy space: [`wow_to_bevy`] permutes the axes, so a scale permutes too.
+fn scale_to_bevy(s: [f32; 3]) -> Vec3 {
+    Vec3::new(s[1], s[2], s[0])
+}
+
+impl SkyRig {
+    /// Parse the rig out of the model bytes; an unparsable or boneless model has an empty rig.
+    pub(crate) fn from_bytes(bytes: &[u8]) -> Self {
+        let Ok(skeleton) = benilla_formats::parse_m2_skeleton(bytes) else {
+            return Self::default();
+        };
+        let n = skeleton.bones.len();
+        let mut rig = SkyRig {
+            parents: skeleton.bones.iter().map(|b| b.parent).collect(),
+            pivots: skeleton.bones.iter().map(|b| wow_to_bevy(b.pivot)).collect(),
+            tracks: vec![BoneTracks::default(); n],
+            duration: 0.0,
+            seq_slot: None,
+            looping: true,
+        };
+        let bone_ofs = bytes
+            .get(0x38..0x3c)
+            .map_or(0, |b| u32::from_le_bytes([b[0], b[1], b[2], b[3]]) as usize);
+        let rec = |i: usize| bone_ofs + i * 0x6c;
+        // The armed sequence: animation id 0 (`0x70ebd0`), else the file's first.
+        let anims = benilla_formats::parse_m2_animations(bytes);
+        if let Some(seq) = anims
+            .iter()
+            .find(|a| a.anim_id == 0)
+            .or_else(|| anims.first())
+        {
+            rig.duration = seq.duration;
+            rig.seq_slot = Some(seq.seq_index);
+            rig.looping = seq.looping;
+            for keys in &seq.bones {
+                let i = usize::from(keys.bone);
+                let Some(t) = rig.tracks.get_mut(i) else {
+                    continue;
+                };
+                t.translation = Channel {
+                    keys: keys
+                        .translation
+                        .iter()
+                        .map(|&(s, v)| (s, wow_to_bevy(v)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x0c),
+                };
+                t.rotation = Channel {
+                    keys: keys
+                        .rotation
+                        .iter()
+                        .map(|&(s, q)| (s, wow_rotation_to_bevy(q)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x28),
+                };
+                t.scale = Channel {
+                    keys: keys
+                        .scale
+                        .iter()
+                        .map(|&(s, v)| (s, scale_to_bevy(v)))
+                        .collect(),
+                    linear: track_linear(bytes, rec(i) + 0x44),
+                };
+            }
+        }
+        fn global<T, V>(
+            c: &Option<benilla_formats::GlobalSeqChannel<T>>,
+            linear: bool,
+            conv: impl Fn(T) -> V,
+        ) -> Option<GlobalChannel<V>>
+        where
+            T: Copy,
+        {
+            let c = c.as_ref()?;
+            Some(GlobalChannel {
+                period: c.period_ms as f32 / 1000.0,
+                channel: Channel {
+                    keys: c
+                        .keys
+                        .iter()
+                        .map(|&(ms, v)| (ms as f32 / 1000.0, conv(v)))
+                        .collect(),
+                    linear,
+                },
+            })
+        }
+        for g in benilla_formats::parse_m2_global_sequence_bones(bytes) {
+            let i = usize::from(g.bone);
+            let Some(t) = rig.tracks.get_mut(i) else {
+                continue;
+            };
+            t.g_translation = global(&g.translation, track_linear(bytes, rec(i) + 0x0c), |v| {
+                wow_to_bevy(v)
+            });
+            t.g_rotation = global(&g.rotation, track_linear(bytes, rec(i) + 0x28), |q| {
+                wow_rotation_to_bevy(q)
+            });
+            t.g_scale = global(&g.scale, track_linear(bytes, rec(i) + 0x44), scale_to_bevy);
+        }
+        rig
+    }
+
+    /// Whether any bone has a channel, i.e. posing can move a vertex.
+    pub(crate) fn animates(&self) -> bool {
+        self.tracks.iter().any(BoneTracks::moves)
+    }
+
+    /// Whether `bone` or any bone above it has a channel.
+    pub(crate) fn bone_moves(&self, bone: u16) -> bool {
+        let mut i = usize::from(bone);
+        for _ in 0..=self.parents.len() {
+            let Some(t) = self.tracks.get(i) else {
+                return false;
+            };
+            if t.moves() {
+                return true;
+            }
+            match usize::try_from(self.parents[i]) {
+                Ok(p) => i = p,
+                Err(_) => return false,
+            }
+        }
+        false
+    }
+
+    /// The sequence clock for `t` seconds on the scene or day clock: wrapped for a looping
+    /// sequence, clamped for a one-shot, as the band bake does.
+    pub(crate) fn band_time(&self, t: f32) -> f32 {
+        if self.duration <= 0.0 {
+            0.0
+        } else if self.looping {
+            t.rem_euclid(self.duration)
+        } else {
+            t.clamp(0.0, self.duration)
+        }
+    }
+
+    /// Every bone's model-space matrix at band time `band_t` and free clock `gseq_now` seconds.
+    pub(crate) fn pose(&self, band_t: f32, gseq_now: f64) -> Vec<Affine3A> {
+        let n = self.parents.len();
+        let mut out: Vec<Option<Affine3A>> = vec![None; n];
+        for i in 0..n {
+            self.resolve(i, band_t, gseq_now, &mut out, 0);
+        }
+        out.into_iter()
+            .map(|m| m.unwrap_or(Affine3A::IDENTITY))
+            .collect()
+    }
+
+    fn resolve(
+        &self,
+        i: usize,
+        band_t: f32,
+        gseq_now: f64,
+        out: &mut Vec<Option<Affine3A>>,
+        depth: usize,
+    ) -> Affine3A {
+        if let Some(m) = out[i] {
+            return m;
+        }
+        let local = self.local(i, band_t, gseq_now);
+        // Bounded by the bone count: the guard against a malformed parent cycle.
+        let m = match usize::try_from(self.parents[i]) {
+            Ok(p) if p < out.len() && p != i && depth < out.len() => {
+                self.resolve(p, band_t, gseq_now, out, depth + 1) * local
+            }
+            _ => local,
+        };
+        out[i] = Some(m);
+        m
+    }
+
+    fn local(&self, i: usize, band_t: f32, gseq_now: f64) -> Affine3A {
+        let t = &self.tracks[i];
+        if !t.moves() {
+            return Affine3A::IDENTITY;
+        }
+        fn at<V: Copy>(
+            g: &Option<GlobalChannel<V>>,
+            c: &Channel<V>,
+            band_t: f32,
+            gseq_now: f64,
+            blend: impl Fn(V, V, f32) -> V,
+        ) -> Option<V> {
+            match g {
+                Some(g) if g.period > 0.0 => {
+                    let tt = (gseq_now % f64::from(g.period)) as f32;
+                    g.channel.sample(tt, blend)
+                }
+                _ => c.sample(band_t, blend),
+            }
+        }
+        let tr = at(&t.g_translation, &t.translation, band_t, gseq_now, lerp3).unwrap_or(Vec3::ZERO);
+        let rot = at(&t.g_rotation, &t.rotation, band_t, gseq_now, slerp)
+            .unwrap_or(Quat::IDENTITY)
+            .normalize();
+        let sc = at(&t.g_scale, &t.scale, band_t, gseq_now, lerp3).unwrap_or(Vec3::ONE);
+        let pivot = self.pivots[i];
+        Affine3A::from_translation(pivot + tr)
+            * Affine3A::from_scale_rotation_translation(sc, rot, Vec3::ZERO)
+            * Affine3A::from_translation(-pivot)
+    }
+}
+
+/// The mat-anim rows a skybox batch owns: its texture transform (translation row, and an affine
+/// row for rotation/scale) and its colour track, each seeded at `t = 0` like the shared lane.
+#[derive(Default)]
+pub(crate) struct SkyMatLane {
+    pub(crate) uv: Option<(u16, [f32; 2], Arc<benilla_formats::UvAnim>)>,
+    pub(crate) affine: Option<(u16, AffineLoops)>,
+    pub(crate) tint: Option<(u16, [f32; 3], Arc<benilla_formats::RgbAnim>)>,
+}
+
+/// The rotation and scaling channels of a texture transform, slot 0's loops.
+pub(crate) struct AffineLoops {
+    pub(crate) rot: Option<benilla_formats::KeyAnim<[f32; 4]>>,
+    pub(crate) scale: Option<benilla_formats::KeyAnim<[f32; 2]>>,
+}
+
+impl SkyMatLane {
+    /// Allocate the rows for a batch and write their slots into every material it draws with
+    /// (`anim_slots.x` UV, `.y` tint, `.z` affine). A full table leaves the batch at its seed.
+    pub(crate) fn register(
+        sub: &benilla_formats::RenderSubmesh,
+        uv: Option<Arc<benilla_formats::UvAnim>>,
+        tint: Option<Arc<benilla_formats::RgbAnim>>,
+        table: &mut crate::mat_anim_table::MatAnimTable,
+        materials: &mut Assets<benilla_assets::materials::WowModelMaterial>,
+        mats: &[AssetId<benilla_assets::materials::WowModelMaterial>],
+    ) -> Self {
+        let mut lane = SkyMatLane::default();
+        let write = |materials: &mut Assets<benilla_assets::materials::WowModelMaterial>,
+                     f: &dyn Fn(&mut benilla_assets::materials::WowModelMaterial)| {
+            for id in mats {
+                crate::model_render::lazy::with_material_mut(materials, *id, |m| f(m));
+            }
+        };
+        if let Some(uv) = uv.filter(|a| a.period > 0.0) {
+            if let Some(slot) = table.alloc() {
+                let seed = mats
+                    .first()
+                    .and_then(|id| {
+                        crate::model_render::lazy::with_material_mut(materials, *id, |m| {
+                            [m.extension.sun_scale.z, m.extension.sun_scale.w]
+                        })
+                    })
+                    .unwrap_or([0.0, 0.0]);
+                write(materials, &|m| m.extension.anim_slots.x = f32::from(slot));
+                lane.uv = Some((slot, seed, uv));
+            }
+        }
+        let rot = sub
+            .uv_rot_seq
+            .as_ref()
+            .and_then(|s| s.seq(None))
+            .cloned();
+        let scale = sub
+            .uv_scale_seq
+            .as_ref()
+            .and_then(|s| s.seq(None))
+            .cloned();
+        if rot.is_some() || scale.is_some() {
+            if let Some(slot) = table.alloc() {
+                write(materials, &|m| m.extension.anim_slots.z = f32::from(slot));
+                lane.affine = Some((slot, AffineLoops { rot, scale }));
+            }
+        }
+        if let Some(tint) = tint {
+            if let Some(slot) = table.alloc() {
+                let seed = mats
+                    .first()
+                    .and_then(|id| {
+                        crate::model_render::lazy::with_material_mut(materials, *id, |m| {
+                            [m.extension.tint.x, m.extension.tint.y, m.extension.tint.z]
+                        })
+                    })
+                    .unwrap_or([1.0, 1.0, 1.0]);
+                write(materials, &|m| m.extension.anim_slots.y = f32::from(slot));
+                lane.tint = Some((slot, seed, tint));
+            }
+        }
+        lane
+    }
+
+    pub(crate) fn any(&self) -> bool {
+        self.uv.is_some() || self.affine.is_some() || self.tint.is_some()
+    }
+
+    /// Write this frame's rows: the delta from each seed, quantized as the shared lane does.
+    pub(crate) fn tick(
+        &self,
+        band_t: f32,
+        gseq_now: f64,
+        table: &mut crate::mat_anim_table::MatAnimTable,
+    ) {
+        if let Some((slot, seed, a)) = &self.uv {
+            let v = a.sample(a.clock(band_t, gseq_now));
+            table.set(
+                *slot,
+                [
+                    benilla_assets::quantize(v[0], 4096.0) - seed[0],
+                    benilla_assets::quantize(v[1], 4096.0) - seed[1],
+                    0.0,
+                    0.0,
+                ],
+            );
+        }
+        if let Some((slot, loops)) = &self.affine {
+            let q = loops
+                .rot
+                .as_ref()
+                .map_or([0.0, 0.0, 0.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            let s = loops
+                .scale
+                .as_ref()
+                .map_or([1.0, 1.0], |l| l.sample(l.clock(band_t, gseq_now)));
+            table.set(*slot, crate::mat_anim_table::affine_row(q, s));
+        }
+        if let Some((slot, seed, a)) = &self.tint {
+            let c = benilla_assets::quant255(a.sample(a.clock(band_t, gseq_now)));
+            table.set(
+                *slot,
+                [c[0] - seed[0], c[1] - seed[1], c[2] - seed[2], 0.0],
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn spin_rig() -> SkyRig {
+        // One parentless bone at pivot (1,0,0) turning about +Y over 4 s, linear.
+        SkyRig {
+            parents: vec![-1],
+            pivots: vec![Vec3::X],
+            tracks: vec![BoneTracks {
+                rotation: Channel {
+                    keys: vec![
+                        (0.0, Quat::IDENTITY),
+                        (4.0, Quat::from_rotation_y(std::f32::consts::PI)),
+                    ],
+                    linear: true,
+                },
+                ..Default::default()
+            }],
+            duration: 4.0,
+            seq_slot: Some(0),
+            looping: true,
+        }
+    }
+
+    #[test]
+    fn a_bone_turns_about_its_pivot() {
+        let rig = spin_rig();
+        let m = rig.pose(rig.band_time(4.0 + 2.0), 0.0)[0];
+        // Half way: a quarter turn about the pivot; the pivot itself stays put.
+        assert!(m.transform_point3(Vec3::X).abs_diff_eq(Vec3::X, 1e-5));
+        let p = m.transform_point3(Vec3::new(2.0, 0.0, 0.0));
+        assert!(p.abs_diff_eq(Vec3::new(1.0, 0.0, -1.0), 1e-5), "{p}");
+    }
+
+    #[test]
+    fn a_child_composes_onto_its_parent() {
+        let mut rig = spin_rig();
+        rig.parents.push(0);
+        rig.pivots.push(Vec3::new(2.0, 0.0, 0.0));
+        rig.tracks.push(BoneTracks {
+            translation: Channel {
+                keys: vec![(0.0, Vec3::Y)],
+                linear: true,
+            },
+            ..Default::default()
+        });
+        let pose = rig.pose(2.0, 0.0);
+        let p = pose[1].transform_point3(Vec3::new(2.0, 0.0, 0.0));
+        // Lifted by the child, then turned a quarter by the parent.
+        assert!(p.abs_diff_eq(Vec3::new(1.0, 1.0, -1.0), 1e-5), "{p}");
+        assert!(rig.bone_moves(1) && rig.animates());
+    }
+
+    #[test]
+    fn a_trackless_rig_is_the_bind_pose() {
+        let rig = SkyRig {
+            parents: vec![-1, 0],
+            pivots: vec![Vec3::ZERO, Vec3::ONE],
+            tracks: vec![BoneTracks::default(); 2],
+            ..Default::default()
+        };
+        assert!(!rig.animates());
+        assert!(rig
+            .pose(1.0, 1.0)
+            .iter()
+            .all(|m| *m == Affine3A::IDENTITY));
+    }
+
+    /// The Caverns of Time belts: the general rig reproduces the rigid spin the old lane drew.
+    #[test]
+    fn the_caverns_belts_spin_as_the_bone_spin_does() {
+        let data = benilla_formats::wow_data_or_skip!();
+        let mut chain = benilla_formats::Chain::open(&data).expect("open chain");
+        const SKY: &str = "Environments\\Stars\\CavernsOfTimeSky.m2";
+        let bytes = chain.read_file(SKY).expect("read the sky");
+        let rig = SkyRig::from_bytes(&bytes);
+        let spins = benilla_formats::m2_bone_spins(&bytes);
+        assert!(!spins.is_empty());
+        for t in [0.0f32, 3.3, 17.0, 50.0] {
+            let pose = rig.pose(rig.band_time(t), f64::from(t));
+            for (bone, spin) in &spins {
+                let pivot = wow_to_bevy(spin.pivot);
+                let rot = wow_rotation_to_bevy(spin.sample(t));
+                let old = Affine3A::from_translation(pivot)
+                    * Affine3A::from_quat(rot)
+                    * Affine3A::from_translation(-pivot);
+                let p = Vec3::new(10.0, 3.0, -7.0) + pivot;
+                let a = pose[usize::from(*bone)].transform_point3(p);
+                let b = old.transform_point3(p);
+                assert!(a.abs_diff_eq(b, 1e-2), "bone {bone} t {t}: {a} vs {b}");
+            }
+        }
+    }
+}
diff --git a/crates/benilla-world/src/world_census.rs b/crates/benilla-world/src/world_census.rs
index 3426e0a5..0ad4c49c 100644
--- a/crates/benilla-world/src/world_census.rs
+++ b/crates/benilla-world/src/world_census.rs
@@ -244,8 +244,9 @@ impl WorldCensus<'_, '_> {
         };
 
         let sky = self.skybox.as_ref().map(|s| {
-            s.0.as_deref()
-                .map_or_else(|| "dome".to_string(), str::to_ascii_lowercase)
+            // MONKEY (skybox): the heaviest layer of the weighted list.
+            s.primary()
+                .map_or_else(|| "dome".to_string(), |l| l.path.to_ascii_lowercase())
         });
 
         CensusReport {