diff --git a/crates/benilla-formats/examples/batch_alpha.rs b/crates/benilla-formats/examples/batch_alpha.rs
index 957d3e5b..cce5b4f8 100644
--- a/crates/benilla-formats/examples/batch_alpha.rs
+++ b/crates/benilla-formats/examples/batch_alpha.rs
@@ -28,7 +28,7 @@ fn main() -> anyhow::Result<()> {
             continue;
         };
         let samples: Vec<f32> = (0..24u16)
-            .map(|k| a.sample(Some(slot), 3.0 * f32::from(k) / 24.0))
+            .map(|k| a.sample(Some(slot), 3.0 * f32::from(k) / 24.0, 0.0))
             .collect();
         let lo = samples.iter().copied().fold(f32::MAX, f32::min);
         let hi = samples.iter().copied().fold(f32::MIN, f32::max);
diff --git a/crates/benilla-formats/examples/dump_emitters.rs b/crates/benilla-formats/examples/dump_emitters.rs
index 792bcf5c..3fb09663 100644
--- a/crates/benilla-formats/examples/dump_emitters.rs
+++ b/crates/benilla-formats/examples/dump_emitters.rs
@@ -27,7 +27,7 @@ fn main() -> anyhow::Result<()> {
             "  texture {:?} tiles {}x{} head_tail {}",
             e.texture, e.tile_rows, e.tile_cols, e.head_tail
         );
-        let now = e.params.sample(None, 0.0);
+        let now = e.params.sample(None, 0.0, 0.0);
         println!(
             "  speed {} var {} vrange {} hrange {} gravity {} life {} drag {}   (params at t=0)",
             now.emission_speed,
diff --git a/crates/benilla-formats/examples/emdump.rs b/crates/benilla-formats/examples/emdump.rs
index ee3f09bd..a4e7e312 100644
--- a/crates/benilla-formats/examples/emdump.rs
+++ b/crates/benilla-formats/examples/emdump.rs
@@ -27,7 +27,7 @@ fn main() -> anyhow::Result<()> {
         .iter()
         .enumerate()
     {
-        let now = e.params.sample(None, 0.0);
+        let now = e.params.sample(None, 0.0, 0.0);
         println!(
             "emitter {i}: bone {:>3} flags {:#06x} model_space={} pos ({:.4},{:.4},{:.4}) blend {:?} \
              shape {:?} speed {:.4}±{:.4} grav {:.4} life {:.4} tex {:?}",
diff --git a/crates/benilla-formats/examples/seamswing.rs b/crates/benilla-formats/examples/seamswing.rs
index 13d44703..89de02f8 100644
--- a/crates/benilla-formats/examples/seamswing.rs
+++ b/crates/benilla-formats/examples/seamswing.rs
@@ -1,11 +1,18 @@
-//! How far does a welded billboard bone's geometry actually MOVE when the bone is re-oriented?
+//! Where does a welded billboard bone's geometry SIT relative to its pivot — how far, and along
+//! which local axis?
 //!
-//! The question decision 0841's regression turns on. A spherical billboard replaces the bone's
-//! world rotation outright, so a vertex weighted to it swings by up to `2·|v − pivot|` — while a
-//! **seam** vertex (partially weighted) swings by its weight times that, *and* linear-blend skinning
-//! shrinks it toward the pivot on the way (the candy-wrapper). If the seam ring sits ON the pivot,
-//! both effects vanish and the flap hinges cleanly; if it sits far out, the seam sweeps through
-//! whatever it is welded to and no implementation of the law can avoid it.
+//! Two readings, and the second is the one that decides anything. **Distance** answers the seam
+//! question: a partially-weighted seam vertex is dragged by its weight times the re-orientation and
+//! linear-blend skinning shrinks it toward the pivot on the way (the candy-wrapper), so a seam ring
+//! sitting ON the pivot hinges cleanly and one sitting far out tears.
+//!
+//! **Direction answers whether the geometry moves at all.** A spherical billboard maps the bone's
+//! local axes onto fixed camera axes, so an offset lying along a single local axis lands on the same
+//! camera axis from every angle: it does not sweep, it only loses its roll and its foreshortening.
+//! Only an offset spread across the axes sweeps. Magnitude alone cannot tell those apart, and
+//! reading a 0.29 yd radius as a 0.29 yd arc is exactly how decision 0847 withdrew a correct change
+//! — the spikes it measured run **along** their bone (worst vertex 12° off axis), so the sweep it
+//! described never existed (wow-re `billboard-bone-law.md` §6.3, and this tool's own output).
 //!
 //! Usage: `cargo run -p benilla-formats --example seamswing -- <WoW/Data> <internal\path.m2>`
 
@@ -33,14 +40,15 @@ fn main() -> anyhow::Result<()> {
                 if v.bone_indices[i] as u16 != b || v.bone_weights[i] == 0 {
                     continue;
                 }
-                let pos = [v.position.x, v.position.y, v.position.z];
-                let d = ((pos[0] - piv[0]).powi(2)
-                    + (pos[1] - piv[1]).powi(2)
-                    + (pos[2] - piv[2]).powi(2))
-                .sqrt();
+                let off = [
+                    v.position.x - piv[0],
+                    v.position.y - piv[1],
+                    v.position.z - piv[2],
+                ];
+                let d = (off[0].powi(2) + off[1].powi(2) + off[2].powi(2)).sqrt();
                 let w = f32::from(v.bone_weights[i]) / 255.0;
                 if w > 0.999 {
-                    pure.push(d)
+                    pure.push((d, off))
                 } else {
                     seam.push((w, d))
                 }
@@ -60,15 +68,65 @@ fn main() -> anyhow::Result<()> {
             )
         };
         let seam_d: Vec<f32> = seam.iter().map(|&(_, d)| d).collect();
+        let pure_d: Vec<f32> = pure.iter().map(|&(d, _)| d).collect();
         println!(
             "bone {b} pivot ({:.3}, {:.3}, {:.3})",
             piv[0], piv[1], piv[2]
         );
-        println!("  fully-weighted verts, |v−pivot|: {}", stat(&pure));
+        println!("  fully-weighted verts, |v−pivot|: {}", stat(&pure_d));
         println!("  SEAM verts,          |v−pivot|: {}", stat(&seam_d));
         if let Some(&(w, _)) = seam.first() {
             println!("  seam weight on this bone: {w:.2}");
         }
+        // DIRECTION, which is what actually decides whether re-orientation moves the geometry.
+        // A spherical billboard maps the bone's local axes to fixed camera axes, so an offset that
+        // lies along ONE local axis lands on that camera axis from every angle: it does not sweep,
+        // it only loses its roll and its foreshortening. An offset spread across the axes does
+        // sweep. Magnitude alone cannot tell these apart — decision 0847 read a 0.29 yd radius as a
+        // 0.29 yd arc and withdrew a correct change on the strength of it.
+        if !pure.is_empty() {
+            let mut lo = [f32::MAX; 3];
+            let mut hi = [f32::MIN; 3];
+            for &(_, o) in &pure {
+                for k in 0..3 {
+                    lo[k] = lo[k].min(o[k]);
+                    hi[k] = hi[k].max(o[k]);
+                }
+            }
+            // The DIRECTION axis is the one the offsets are largest along — NOT the one they are
+            // most spread across. Those differ here and confusing them inverts the reading: this
+            // spike runs along z (|z| ≈ 0.29) but is widest across y (spread 0.105, its cross
+            // section). Report both, named, so neither can be mistaken for the other.
+            let mean_abs =
+                |k: usize| pure.iter().map(|&(_, o)| o[k].abs()).sum::<f32>() / pure.len() as f32;
+            let along = (0..3)
+                .max_by(|&a, &c| mean_abs(a).total_cmp(&mean_abs(c)))
+                .unwrap();
+            let widest = (0..3)
+                .max_by(|&a, &c| (hi[a] - lo[a]).total_cmp(&(hi[c] - lo[c])))
+                .unwrap();
+            // How far the WORST vertex strays from that one axis — the number that decides whether
+            // "runs along a single axis" is a fair description of the whole batch or only its mean.
+            let worst_deg = pure
+                .iter()
+                .filter(|&&(d, _)| d > 1e-6)
+                .map(|&(d, o)| (o[along].abs() / d).clamp(-1.0, 1.0).acos().to_degrees())
+                .fold(0.0f32, f32::max);
+            println!(
+                "  offset from pivot, per axis: x[{:+.3},{:+.3}] y[{:+.3},{:+.3}] z[{:+.3},{:+.3}]",
+                lo[0], hi[0], lo[1], hi[1], lo[2], hi[2]
+            );
+            println!(
+                "  → RUNS ALONG {} (mean |{}| = {:.3}); widest across {} (cross section {:.3}); \
+                 worst vertex {worst_deg:.1}° off {}",
+                ["x", "y", "z"][along],
+                ["x", "y", "z"][along],
+                mean_abs(along),
+                ["x", "y", "z"][widest],
+                hi[widest] - lo[widest],
+                ["x", "y", "z"][along],
+            );
+        }
     }
     Ok(())
 }
diff --git a/crates/benilla-formats/src/bin/benilla-extract/m2dump.rs b/crates/benilla-formats/src/bin/benilla-extract/m2dump.rs
index eeeb63d4..bc17cf4b 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/m2dump.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/m2dump.rs
@@ -281,7 +281,7 @@ fn print_m2anim_summary(s: &M2AnimSummary, bytes: &[u8]) {
         // line shows their opening values, and any channel that actually MOVES prints its full
         // keyed ramp below — the view whose absence hid Frost Nova's 0.19 → 13.2 yd emission-
         // radius ride behind a flat "radius [0.19..0.19]" (decision 0844).
-        let now = d.params.sample(None, 0.0);
+        let now = d.params.sample(None, 0.0, 0.0);
         println!(
             "             {:?} {:?} {}  {rate}  life {:.2}s  speed {:.2}  grav {:.2}  drag {:.1}{tail}  twinkle [{:.2}..{:.2}] spd {:.1} pct {:.2}  spin {:.2}",
             d.shape,
@@ -1157,7 +1157,7 @@ pub fn m2alpha(chain: &mut Chain, internal_path: &str) -> Result<()> {
             let (lo, hi) = match &sub.alpha_anim {
                 None => (1.0, 1.0),
                 Some(a) => (0..=32)
-                    .map(|k| a.sample(Some(i), period * k as f32 / 32.0))
+                    .map(|k| a.sample(Some(i), period * k as f32 / 32.0, 0.0))
                     .fold((f32::MAX, f32::MIN), |(lo, hi), v| (lo.min(v), hi.max(v))),
             };
             let cell = if (hi - lo).abs() < 1e-4 {
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan.rs b/crates/benilla-formats/src/bin/benilla-extract/scan.rs
index 050f7bbe..f612801d 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan.rs
@@ -1321,7 +1321,7 @@ pub fn partcensus(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
             // instrument could LIST that population, so the swapped pairing outlived both audits
             // until Gressil's 0.1 × 1.1 blade smoke drew its curtain across the blade. Bucketed by
             // aspect so a thin curtain (load-bearing) separates from a near-square (invisible).
-            let now = d.params.sample(None, 0.0);
+            let now = d.params.sample(None, 0.0, 0.0);
             if d.shape == benilla_formats::ParticleShape::Plane {
                 let lo = now.area_length.abs().min(now.area_width.abs());
                 let hi = now.area_length.abs().max(now.area_width.abs());
@@ -1770,7 +1770,7 @@ pub fn alphascan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
         // sampling grid is coarse on purpose — a batch that so much as flickers non-zero is drawn.
         let hidden_in = |sub: &benilla_formats::RenderSubmesh, slot: usize| -> bool {
             sub.alpha_anim.as_ref().is_some_and(|a| {
-                (0..=16u16).all(|k| a.sample(Some(slot), f32::from(k) * 0.25) <= 0.0)
+                (0..=16u16).all(|k| a.sample(Some(slot), f32::from(k) * 0.25, 0.0) <= 0.0)
             })
         };
         let (mut first, mut any, mut varies) = (0usize, 0usize, 0usize);
diff --git a/crates/benilla-formats/src/emit_timing.rs b/crates/benilla-formats/src/emit_timing.rs
index 304af879..9c820de5 100644
--- a/crates/benilla-formats/src/emit_timing.rs
+++ b/crates/benilla-formats/src/emit_timing.rs
@@ -68,21 +68,23 @@ impl EmitTiming {
     }
 
     /// Is the gate ON, `elapsed` seconds into sequence slot `seq`? A slot with no baked gate is
-    /// ON (the loader default).
-    pub fn emitting(&self, seq: Option<usize>, elapsed: f32) -> bool {
+    /// ON (the loader default). `shared_now` is the world's shared elapsed seconds — a
+    /// gseq-tagged gate routes to it ([`crate::models::KeyAnim::clock`]).
+    pub fn emitting(&self, seq: Option<usize>, elapsed: f32, shared_now: f64) -> bool {
         self.enabled
             .get(self.idx(seq))
             .and_then(|o| o.as_ref())
-            .is_none_or(|a| a.sample_or(elapsed, 1.0) > 0.5)
+            .is_none_or(|a| a.sample_or(a.clock(elapsed, shared_now), 1.0) > 0.5)
     }
 
     /// The spawn rate (particles/sec), `elapsed` seconds into sequence slot `seq`. A slot with no
     /// baked rate spawns nothing. Floored at 0 (a track tail may legitimately go negative).
-    pub fn rate(&self, seq: Option<usize>, elapsed: f32) -> f32 {
+    /// `shared_now` routes a gseq-tagged rate loop to the shared world clock.
+    pub fn rate(&self, seq: Option<usize>, elapsed: f32, shared_now: f64) -> f32 {
         self.rate
             .get(self.idx(seq))
             .and_then(|o| o.as_ref())
-            .map_or(0.0, |a| a.sample_or(elapsed, 0.0))
+            .map_or(0.0, |a| a.sample_or(a.clock(elapsed, shared_now), 0.0))
             .max(0.0)
     }
 
@@ -128,6 +130,7 @@ impl EmitTiming {
                 period: 0.0,
                 step: true,
                 wrap: true,
+                gseq: false,
                 keys: vec![(0.0, rate)],
             })],
             enabled: vec![None],
@@ -211,8 +214,9 @@ impl EmitParams {
     }
 
     /// Sample every channel `elapsed` seconds into sequence slot `seq` (same slot resolution as
-    /// [`EmitTiming`]: out-of-range degrades to slot 0).
-    pub fn sample(&self, seq: Option<usize>, elapsed: f32) -> ParamsNow {
+    /// [`EmitTiming`]: out-of-range degrades to slot 0). `shared_now` routes gseq-tagged
+    /// channels to the shared world clock.
+    pub fn sample(&self, seq: Option<usize>, elapsed: f32, shared_now: f64) -> ParamsNow {
         let d = ParamsNow::default();
         let at = |i: usize, default: f32| -> f32 {
             let ch = &self.channels[i];
@@ -220,9 +224,9 @@ impl EmitParams {
                 Some(s) if s < ch.len() => s,
                 _ => 0,
             };
-            ch.get(slot)
-                .and_then(|o| o.as_ref())
-                .map_or(default, |a| a.sample_or(elapsed, default))
+            ch.get(slot).and_then(|o| o.as_ref()).map_or(default, |a| {
+                a.sample_or(a.clock(elapsed, shared_now), default)
+            })
         };
         ParamsNow {
             emission_speed: at(0, d.emission_speed),
@@ -261,6 +265,7 @@ impl EmitParams {
                 period: 0.0,
                 step: true,
                 wrap: true,
+                gseq: false,
                 keys: vec![(0.0, v)],
             })]
         };
@@ -344,10 +349,14 @@ mod tests {
             &slots(&[((0, 1000), true)]),
             &[],
         );
-        assert_eq!(t.rate(None, 0.050), 0.0, "before the key: step holds 0");
-        assert_eq!(t.rate(None, 0.070), 30.0, "at/after the key: 30");
-        assert_eq!(t.rate(None, 0.500), 30.0, "held to the band end");
-        assert!(t.emitting(None, 0.5), "no gate track = always on");
+        assert_eq!(
+            t.rate(None, 0.050, 0.0),
+            0.0,
+            "before the key: step holds 0"
+        );
+        assert_eq!(t.rate(None, 0.070, 0.0), 30.0, "at/after the key: 30");
+        assert_eq!(t.rate(None, 0.500, 0.0), 30.0, "held to the band end");
+        assert!(t.emitting(None, 0.5, 0.0), "no gate track = always on");
     }
 
     /// The LINEAR ramp law (the BloodSpurt shape `0 → 100 → 0`, interp 1): mid-ramp pours the
@@ -360,12 +369,15 @@ mod tests {
             &slots(&[((0, 1000), true)]),
             &[],
         );
-        assert!((t.rate(None, 0.050) - 50.0).abs() < 1e-4, "rising mid-ramp");
         assert!(
-            (t.rate(None, 0.150) - 50.0).abs() < 1e-4,
+            (t.rate(None, 0.050, 0.0) - 50.0).abs() < 1e-4,
+            "rising mid-ramp"
+        );
+        assert!(
+            (t.rate(None, 0.150, 0.0) - 50.0).abs() < 1e-4,
             "falling mid-ramp"
         );
-        assert_eq!(t.rate(None, 0.500), 0.0, "the ramp self-closes");
+        assert_eq!(t.rate(None, 0.500, 0.0), 0.0, "the ramp self-closes");
     }
 
     /// The per-sequence window law — the B27 shape, synthesized: an enabled gate authored ON
@@ -393,23 +405,26 @@ mod tests {
         );
         // Idle (slot 1): the collapsed window (1,1) resolves to keys[1] = OFF — at every time,
         // wrap included.
-        assert!(!t.emitting(Some(1), 0.0));
-        assert!(!t.emitting(Some(1), 0.25));
-        assert!(!t.emitting(Some(1), 400.0));
+        assert!(!t.emitting(Some(1), 0.0, 0.0));
+        assert!(!t.emitting(Some(1), 0.25, 0.0));
+        assert!(!t.emitting(Some(1), 400.0, 0.0));
         // The one-shot clip (slot 0): ON at its start, OFF from 333 ms — and the clamped clock
         // HOLDS that tail at/after the band end instead of aliasing back to the ON start.
-        assert!(t.emitting(Some(0), 0.1));
-        assert!(!t.emitting(Some(0), 0.5));
-        assert!(!t.emitting(Some(0), 1.0), "t == period must not alias to 0");
+        assert!(t.emitting(Some(0), 0.1, 0.0));
+        assert!(!t.emitting(Some(0), 0.5, 0.0));
         assert!(
-            !t.emitting(Some(0), 5.0),
+            !t.emitting(Some(0), 1.0, 0.0),
+            "t == period must not alias to 0"
+        );
+        assert!(
+            !t.emitting(Some(0), 5.0, 0.0),
             "parked long past the end: still off"
         );
         // The later clip (slot 2): its degenerate window is the ON key.
-        assert!(t.emitting(Some(2), 0.05));
+        assert!(t.emitting(Some(2), 0.05, 0.0));
         // Unknown/out-of-range degrades to slot 0 (the doodad law).
-        assert!(t.emitting(None, 0.1));
-        assert!(!t.emitting(Some(9), 0.5));
+        assert!(t.emitting(None, 0.1, 0.0));
+        assert!(!t.emitting(Some(9), 0.5, 0.0));
         // The rate is a whole-track constant: same in every slot.
         assert_eq!(t.constant_rate(), Some(20.0));
         assert_eq!(t.peak_rate(), 20.0);
@@ -431,7 +446,7 @@ mod tests {
             &slots(&[((0, 867), false)]),
             &[],
         );
-        let at = |t: f32| p.sample(None, t);
+        let at = |t: f32| p.sample(None, t, 0.0);
         assert!((at(0.0).area_length - 0.1944).abs() < 1e-3, "opens tight");
         let mid = at(0.3335).area_length;
         assert!(
@@ -457,9 +472,12 @@ mod tests {
             &slots(&[((0, 1000), true)]),
             &[],
         );
-        assert!(t.emitting(None, 0.1), "first pass: inside the window");
-        assert!(!t.emitting(None, 0.8), "first pass: past it");
-        assert!(t.emitting(None, 1.1), "second pass: the window re-fires");
+        assert!(t.emitting(None, 0.1, 0.0), "first pass: inside the window");
+        assert!(!t.emitting(None, 0.8, 0.0), "first pass: past it");
+        assert!(
+            t.emitting(None, 1.1, 0.0),
+            "second pass: the window re-fires"
+        );
     }
 
     /// **The dead-slot-0 shape** — `BlastedLandsLightningbolt01.m2`'s emitter 2, synthesized
@@ -494,17 +512,25 @@ mod tests {
         );
         // Slot 0 — what the old pinned consumer sampled. Silent across its whole band.
         for s in [0.0, 0.3, 0.6, 0.9, 1.2] {
-            assert_eq!(t.rate(Some(0), s), 0.0, "slot 0 is a flat zero at {s}s");
+            assert_eq!(
+                t.rate(Some(0), s, 0.0),
+                0.0,
+                "slot 0 is a flat zero at {s}s"
+            );
         }
         assert_eq!(
-            t.rate(None, 0.5),
+            t.rate(None, 0.5, 0.0),
             0.0,
             "`None` degrades to slot 0 — also silent"
         );
         // Slot 1 — what the arm actually rolled. The strike is here, and only here.
-        assert_eq!(t.rate(Some(1), 0.0), 0.0, "slot 1 opens closed");
-        assert_eq!(t.rate(Some(1), 0.316), 30.0, "the burst fires mid-band");
-        assert_eq!(t.rate(Some(1), 0.5), 0.0, "and self-closes");
+        assert_eq!(t.rate(Some(1), 0.0, 0.0), 0.0, "slot 1 opens closed");
+        assert_eq!(
+            t.rate(Some(1), 0.316, 0.0),
+            30.0,
+            "the burst fires mid-band"
+        );
+        assert_eq!(t.rate(Some(1), 0.5, 0.0), 0.0, "and self-closes");
         // The trap that hid it: the build-time cull sees a live emitter either way.
         assert_eq!(
             t.peak_rate(),
diff --git a/crates/benilla-formats/src/models/key_anim.rs b/crates/benilla-formats/src/models/key_anim.rs
index f4e2ed14..6a419129 100644
--- a/crates/benilla-formats/src/models/key_anim.rs
+++ b/crates/benilla-formats/src/models/key_anim.rs
@@ -86,10 +86,37 @@ pub struct KeyAnim<V> {
     /// onto its **opening** value: an elemental's Death sequence fades every batch to alpha 0 and
     /// then — one frame later, for ever — snapped back to a fully opaque body frozen in mid-air.
     pub wrap: bool,
+    /// **Which clock feeds the loop** — the other half of the clock law, also decided at bake
+    /// time. `true` = a global-sequence loop: the reference's cursor is
+    /// `(sceneClock − instanceAttachTime) % duration` (wow-re `gseq-anchor.md`, byte-verified:
+    /// one free-running per-scene ms clock, snapshotted ONCE per model instance at attach —
+    /// `CM2Model+0x68`). Per-INSTANCE anchoring, stamped at attach; sequence tracks instead
+    /// re-arm their cursor at every play. `false` = a sequence-band loop: clocked by the host's
+    /// playing-clip time. Consumers route via [`Self::clock`], passing their instance's anchored
+    /// gseq cursor — the spell-fx lane passes the raw scene clock (its pooled-instance
+    /// emulation). Decisions 0855/0856: sampling a gseq loop on a per-play clock pinned every
+    /// Arcane Intellect cast's twinkles to phase 0 (clustered, low, identical cast to cast).
+    pub gseq: bool,
     /// `(secs from loop start, value)`, time-ascending.
     pub keys: Vec<(f32, V)>,
 }
 
+impl<V> KeyAnim<V> {
+    /// The sampling time for this loop, given the caller's two clocks: `band_t` — the host's
+    /// playing-clip / spawn-age seconds (the per-play arm cursor) — and `gseq_now`, the
+    /// instance's global-sequence cursor (`sceneClock − attachTime`; the spell-fx pool lane
+    /// passes the raw scene clock — see [`Self::gseq`]). A gseq loop reads `gseq_now`
+    /// (pre-wrapped in f64, so a long-uptime cursor keeps millisecond precision through the f32
+    /// narrowing); everything else keeps its band clock.
+    pub fn clock(&self, band_t: f32, gseq_now: f64) -> f32 {
+        if self.gseq && self.period > 0.0 {
+            (gseq_now % f64::from(self.period)) as f32
+        } else {
+            band_t
+        }
+    }
+}
+
 impl<V: Lerp> KeyAnim<V> {
     /// Sample at `elapsed` seconds on this loop's own clock ([`Self::wrap`]); `empty` is the
     /// channel's identity for the keyless case (the bake never emits that — each channel's
@@ -205,12 +232,13 @@ pub(crate) fn bake_track<T: Copy, V: Lerp + PartialEq>(
     }
     let keys: Vec<(u32, V)> = track.keys.iter().map(|&(t, v)| (t, proj(v))).collect();
     let step = track.interp == 0;
-    // A constant has no clock at all (`period == 0` short-circuits the sampler), so `wrap` is
-    // arbitrary — `true` keeps it the identity value it has always been.
+    // A constant has no clock at all (`period == 0` short-circuits the sampler), so `wrap` and
+    // `gseq` are arbitrary — `true`/`false` keep it the identity value it has always been.
     let constant = |v: V| KeyAnim {
         period: 0.0,
         step,
         wrap: true,
+        gseq: false,
         keys: vec![(0.0, v)],
     };
     // An all-equal track is a constant in every band: dropped when the static path owns it, else a
@@ -236,6 +264,7 @@ pub(crate) fn bake_track<T: Copy, V: Lerp + PartialEq>(
             // A global sequence runs its own free clock, the same loop in every animation — it
             // always wraps, whatever the playing sequence's own loop flag says.
             wrap: true,
+            gseq: true,
             keys: keys.iter().map(|&(t, v)| (t as f32 / 1000.0, v)).collect(),
         });
     }
@@ -280,6 +309,7 @@ pub(crate) fn bake_track<T: Copy, V: Lerp + PartialEq>(
         step,
         // The band's own loop flag IS this loop's clock: a one-shot sequence holds its tail.
         wrap: looping,
+        gseq: false,
         keys: baked,
     })
 }
diff --git a/crates/benilla-formats/src/models/mat_anim.rs b/crates/benilla-formats/src/models/mat_anim.rs
index ff4f352a..8ab77fd6 100644
--- a/crates/benilla-formats/src/models/mat_anim.rs
+++ b/crates/benilla-formats/src/models/mat_anim.rs
@@ -53,10 +53,13 @@ pub struct AlphaSeq {
 }
 
 impl AlphaSeq {
-    /// The combined factor at `elapsed` seconds into this sequence.
-    pub fn sample(&self, elapsed: f32) -> f32 {
-        let c = self.color.as_ref().map_or(1.0, |a| a.sample(elapsed));
-        let w = self.weight.as_ref().map_or(1.0, |a| a.sample(elapsed));
+    /// The combined factor at `elapsed` seconds into this sequence, with `shared_now` the world's
+    /// shared elapsed seconds — each factor routes to its own clock ([`KeyAnim::clock`]: a gseq
+    /// loop reads the shared clock, a band loop the sequence time).
+    pub fn sample(&self, elapsed: f32, shared_now: f64) -> f32 {
+        let at = |a: &ScalarAnim| a.sample(a.clock(elapsed, shared_now));
+        let c = self.color.as_ref().map_or(1.0, at);
+        let w = self.weight.as_ref().map_or(1.0, at);
         c * w
     }
 
@@ -104,9 +107,10 @@ impl AlphaAnim {
             .unwrap_or(IDENTITY)
     }
 
-    /// The combined factor `elapsed` seconds into sequence slot `seq`.
-    pub fn sample(&self, seq: Option<usize>, elapsed: f32) -> f32 {
-        self.seq(seq).sample(elapsed)
+    /// The combined factor `elapsed` seconds into sequence slot `seq` (`shared_now` = the world's
+    /// shared elapsed seconds, for the gseq-clocked factors).
+    pub fn sample(&self, seq: Option<usize>, elapsed: f32, shared_now: f64) -> f32 {
+        self.seq(seq).sample(elapsed, shared_now)
     }
 
     /// Whether ANY sequence can drive this batch's alpha to zero — i.e. whether the batch is ever
@@ -296,21 +300,21 @@ mod tests {
             for step in 0..16u16 {
                 let t = 2.667 * f32::from(step) / 16.0;
                 assert_eq!(
-                    a.sample(Some(STAND), t),
+                    a.sample(Some(STAND), t, 0.0),
                     0.0,
                     "batch {batch} is hidden {t}s into Stand"
                 );
             }
             for slot in [1, 2, 7, 8, 9, 11] {
                 assert_eq!(
-                    a.sample(Some(slot), 0.3),
+                    a.sample(Some(slot), 0.3, 0.0),
                     0.0,
                     "batch {batch}, sequence {slot}"
                 );
             }
             // Death brings it in — the authored reason the geometry exists at all.
             let peak = (0..32u16)
-                .map(|s| a.sample(Some(DEATH), 3.0 * f32::from(s) / 32.0))
+                .map(|s| a.sample(Some(DEATH), 3.0 * f32::from(s) / 32.0, 0.0))
                 .fold(0.0f32, f32::max);
             assert!(
                 peak > 0.9,
@@ -322,7 +326,7 @@ mod tests {
             let drawn = subs[batch]
                 .alpha_anim
                 .as_ref()
-                .is_none_or(|a| a.sample(Some(STAND), 0.5) > 0.0);
+                .is_none_or(|a| a.sample(Some(STAND), 0.5, 0.0) > 0.0);
             assert!(drawn, "batch {batch} draws in Stand");
         }
         // **The nearest-key trap.** Batch 2 (the 271-vertex body) keys 1.0 at 3333 ms and 0.0 at
@@ -333,7 +337,7 @@ mod tests {
         // "nearest".
         let body = subs[2].alpha_anim.as_ref();
         for slot in [5, 6, 7, 8, 9, 12] {
-            let v = body.map_or(1.0, |a| a.sample(Some(slot), 0.5));
+            let v = body.map_or(1.0, |a| a.sample(Some(slot), 0.5, 0.0));
             assert!(
                 v > 0.0,
                 "the voidwalker body draws in sequence {slot} (got {v})"
@@ -378,14 +382,14 @@ mod tests {
                 for step in 0..8u16 {
                     let t = f32::from(step) * 0.4;
                     assert_eq!(
-                        a.sample(Some(slot), t),
+                        a.sample(Some(slot), t, 0.0),
                         0.0,
                         "batch {batch} is hidden {t}s into sequence {slot}"
                     );
                 }
             }
             let peak = (0..64u16)
-                .map(|k| a.sample(Some(DEATH), 4.167 * f32::from(k) / 64.0))
+                .map(|k| a.sample(Some(DEATH), 4.167 * f32::from(k) / 64.0, 0.0))
                 .fold(0.0f32, f32::max);
             assert!(peak > 0.3, "batch {batch} appears on death (peak {peak})");
         }
@@ -397,7 +401,7 @@ mod tests {
             let v = sub
                 .alpha_anim
                 .as_ref()
-                .map_or(1.0, |a| a.sample(Some(0), 0.5));
+                .map_or(1.0, |a| a.sample(Some(0), 0.5, 0.0));
             assert!(v > 0.0, "batch {i} draws while standing (got {v})");
         }
         let face = subs[8]
@@ -405,12 +409,12 @@ mod tests {
             .as_ref()
             .expect("the face batch is alpha-keyed");
         assert_eq!(
-            face.sample(Some(0), 0.5),
+            face.sample(Some(0), 0.5, 0.0),
             0.0,
             "the scream face hides while standing"
         );
         let scream = (0..64u16)
-            .map(|k| face.sample(Some(1), f32::from(k) / 64.0))
+            .map(|k| face.sample(Some(1), f32::from(k) / 64.0, 0.0))
             .fold(0.0f32, f32::max);
         assert!(
             scream > 0.5,
@@ -500,6 +504,32 @@ mod tests {
         assert!((a.sample(1.5 + 0.375) - 0.6).abs() < 1e-4); // wraps
     }
 
+    /// The clock router (decision 0855): a gseq loop reads the SHARED world clock — the
+    /// reference's free-running Phase B cursor, no per-instance arming — pre-wrapped in f64 so a
+    /// long-uptime `shared_now` keeps precision; a band loop keeps the host's clip time. Sampling
+    /// a gseq loop on a spawn-anchored clock is the Arcane Intellect sparkle bug: every cast's
+    /// twinkles land at phase 0.
+    #[test]
+    fn gseq_loops_read_the_shared_clock() {
+        let g = bake_scalar_anim(
+            &track(1, 1, &[(0, 0.2), (750, 1.0), (1500, 0.2)]),
+            &[9999, 1500],
+            None,
+        )
+        .unwrap();
+        assert!(g.gseq);
+        // band_t (first arg) is ignored; the shared clock decides the phase (mid-ramp → 0.6).
+        assert!((g.sample(g.clock(0.0, 1500.375)) - 0.6).abs() < 1e-3);
+        let b = ranged(1, &[(1000, 0.0), (1500, 1.0)], &[(0, 1)]);
+        let b = bake_at(&b, 0, (1000, 2000)).unwrap();
+        assert!(!b.gseq);
+        assert_eq!(
+            b.clock(0.25, 999.0),
+            0.25,
+            "a band loop keeps its own clock"
+        );
+    }
+
     /// A sequence-timeline track keeps only the first sequence's band, rebased to seconds — keys
     /// belonging to other sequences (outside the band) don't bleed in.
     #[test]
@@ -660,7 +690,7 @@ mod tests {
             .filter(|(_, s)| {
                 s.alpha_anim
                     .as_ref()
-                    .is_some_and(|a| a.sample(Some(DEATH), 2.999) <= 0.0)
+                    .is_some_and(|a| a.sample(Some(DEATH), 2.999, 0.0) <= 0.0)
             })
             .map(|(i, _)| i)
             .collect();
@@ -673,7 +703,7 @@ mod tests {
             let a = subs[i].alpha_anim.as_ref().unwrap();
             for t in [3.0f32, 3.008, 10.0, 600.0] {
                 assert_eq!(
-                    a.sample(Some(DEATH), t),
+                    a.sample(Some(DEATH), t, 0.0),
                     0.0,
                     "batch {i} came back at t={t} — the parked clock aliased to the band head"
                 );
@@ -695,6 +725,7 @@ mod tests {
             period: 0.0,
             step: false,
             wrap: true,
+            gseq: false,
             keys: vec![(0.0, v)],
         })
     }
@@ -708,7 +739,7 @@ mod tests {
             weight: dim(0.5),
         }])
         .expect("a dimming pair is worth carrying");
-        assert!((both.sample(None, 7.0) - 0.25).abs() < 1e-6);
+        assert!((both.sample(None, 7.0, 0.0) - 0.25).abs() < 1e-6);
         assert_eq!(AlphaAnim::new(vec![AlphaSeq::default()]), None);
     }
 
@@ -729,11 +760,11 @@ mod tests {
             },
         ])
         .unwrap();
-        assert_eq!(a.sample(Some(0), 0.0), 0.0);
-        assert_eq!(a.sample(Some(1), 0.0), 1.0);
-        assert_eq!(a.sample(Some(2), 0.0), 0.5);
-        assert_eq!(a.sample(Some(99), 0.0), 0.0, "out of range ⇒ slot 0");
-        assert_eq!(a.sample(None, 0.0), 0.0, "unknown sequence ⇒ slot 0");
+        assert_eq!(a.sample(Some(0), 0.0, 0.0), 0.0);
+        assert_eq!(a.sample(Some(1), 0.0, 0.0), 1.0);
+        assert_eq!(a.sample(Some(2), 0.0, 0.0), 0.5);
+        assert_eq!(a.sample(Some(99), 0.0, 0.0), 0.0, "out of range ⇒ slot 0");
+        assert_eq!(a.sample(None, 0.0, 0.0), 0.0, "unknown sequence ⇒ slot 0");
         assert!(a.ever_hides());
         let never = AlphaAnim::new(vec![AlphaSeq {
             color: None,
diff --git a/crates/benilla-formats/src/models/types.rs b/crates/benilla-formats/src/models/types.rs
index 51e26b16..8dde96a9 100644
--- a/crates/benilla-formats/src/models/types.rs
+++ b/crates/benilla-formats/src/models/types.rs
@@ -364,6 +364,45 @@ const GROUND_FLAT_EPS: f32 = 0.01;
 /// the gap.
 const GROUND_HOVER_MAX: f32 = 1.0;
 
+/// The empty batch — test scaffolding (a picker or dress test wants *a* `RenderSubmesh`, not a
+/// meaningful one). No geometry, `Opaque`, WMO-style repeat sampling; every flag at its
+/// nothing-authored value.
+impl Default for RenderSubmesh {
+    fn default() -> Self {
+        Self {
+            positions: Vec::new(),
+            normals: Vec::new(),
+            uvs: Vec::new(),
+            indices: Vec::new(),
+            texture: None,
+            skin_slot: None,
+            geoset_id: 0,
+            char_slot: None,
+            blend: ModelBlend::Opaque,
+            wrap_x: true,
+            wrap_y: true,
+            two_sided: false,
+            joints: Vec::new(),
+            weights: Vec::new(),
+            vertex_colors: Vec::new(),
+            interior: false,
+            emissive: false,
+            sidn: None,
+            window: false,
+            additive: false,
+            no_depth_write: false,
+            no_depth_test: false,
+            fog_policy: FogPolicy::Scene,
+            billboard: None,
+            welded_billboard: false,
+            alpha_anim: None,
+            uv_anim: None,
+            rgb_anim: None,
+            wmo_batch: None,
+        }
+    }
+}
+
 impl RenderSubmesh {
     /// Is this a **billboard card authored back-to-front** — one flat plane whose normal sits in the
     /// −X half-space the billboard law points *away* from the camera?
diff --git a/crates/benilla-formats/src/particles.rs b/crates/benilla-formats/src/particles.rs
index 8689ec9e..80ce6d77 100644
--- a/crates/benilla-formats/src/particles.rs
+++ b/crates/benilla-formats/src/particles.rs
@@ -872,7 +872,7 @@ mod tests {
         let defs = parse_m2_particle_emitters(&bytes).expect("parse emitters");
         assert_eq!(defs.len(), 4);
         // Emitter 0 — the red spray: starts hot (100/s at t=0), the old bake's one working case.
-        assert_eq!(defs[0].timing.rate(None, 0.0), 100.0);
+        assert_eq!(defs[0].timing.rate(None, 0.0, 0.0), 100.0);
         // Emitter 3 — the starflash: additive, STARFLASH texture, burst-keyed (first key 0,
         // peak 20/s inside the 67–100 ms window, dead again by 133 ms).
         let flash = &defs[3];
@@ -881,17 +881,17 @@ mod tests {
             .as_deref()
             .is_some_and(|t| t.to_ascii_uppercase().contains("STARFLASH")));
         assert_eq!(flash.blend, ParticleBlend::Add);
-        assert_eq!(flash.timing.rate(None, 0.0), 0.0, "silent at t=0");
+        assert_eq!(flash.timing.rate(None, 0.0, 0.0), 0.0, "silent at t=0");
         assert_eq!(flash.timing.peak_rate(), 20.0);
-        assert_eq!(flash.timing.rate(None, 0.080), 20.0);
-        assert_eq!(flash.timing.rate(None, 0.200), 0.0);
+        assert_eq!(flash.timing.rate(None, 0.080, 0.0), 20.0);
+        assert_eq!(flash.timing.rate(None, 0.200, 0.0), 0.0);
         // Emitters 1/2 — the glowball droplets, same burst shape, peaks 200.
         assert_eq!(defs[1].timing.peak_rate(), 200.0);
         assert_eq!(defs[2].timing.peak_rate(), 200.0);
         // The spray's enabled track cuts emission at 500 ms — exactly where its rate track goes
         // negative (the authored tail the old always-on read let the floor-at-0 hide).
-        assert!(defs[0].timing.emitting(None, 0.4));
-        assert!(!defs[0].timing.emitting(None, 0.6));
+        assert!(defs[0].timing.emitting(None, 0.4, 0.0));
+        assert!(!defs[0].timing.emitting(None, 0.6, 0.0));
     }
 
     /// The real `Feint_Impact_Chest.m2` (the Eviscerate/Feint impact) — the BURST-flag split
@@ -921,9 +921,9 @@ mod tests {
         assert!(impact[3].burst(), "crescents are a one-shot burst");
         // The STEP rate law that arms the burst count: silent before the 67 ms key, the full
         // value at it, held past it (where the burst latch keeps it from ever mattering).
-        assert_eq!(impact[0].timing.rate(None, 0.050), 0.0);
-        assert_eq!(impact[0].timing.rate(None, 0.067), 30.0);
-        assert_eq!(impact[0].timing.rate(None, 1.500), 30.0);
+        assert_eq!(impact[0].timing.rate(None, 0.050, 0.0), 0.0);
+        assert_eq!(impact[0].timing.rate(None, 0.067, 0.0), 30.0);
+        assert_eq!(impact[0].timing.rate(None, 1.500, 0.0), 30.0);
         let cast = parse_m2_particle_emitters(
             &chain
                 .read_file("Spells\\Eviscerate_Cast_Hands.m2")
@@ -964,7 +964,7 @@ mod tests {
             let s = d.spline.as_ref().expect("chain parses");
             assert_eq!(s.points.len() % 3, 1, "3K+1 control points");
             assert!(s.points.len() >= 16);
-            let now = d.params.sample(None, 0.0);
+            let now = d.params.sample(None, 0.0, 0.0);
             assert_eq!(now.area_length, 0.0, "tMin");
             assert_eq!(now.area_width, 1.0, "tMax");
             assert_eq!(now.vertical_range, 0.0, "no tangent spin");
@@ -1001,11 +1001,11 @@ mod tests {
         assert_eq!(cast.len(), 3);
         for em in &cast {
             assert!(
-                em.timing.emitting(None, 0.1),
+                em.timing.emitting(None, 0.1, 0.0),
                 "the flash is ON at its start"
             );
             assert!(
-                !em.timing.emitting(None, 0.25),
+                !em.timing.emitting(None, 0.25, 0.0),
                 "and OFF from 200 ms — the 1.0 s clip does not burn through"
             );
         }
@@ -1016,22 +1016,25 @@ mod tests {
         )
         .expect("parse emitters");
         assert_eq!(impact.len(), 6);
-        assert_eq!(impact[0].timing.rate(None, 0.0), 0.0);
+        assert_eq!(impact[0].timing.rate(None, 0.0, 0.0), 0.0);
         assert_eq!(
-            impact[0].timing.rate(None, 0.133),
+            impact[0].timing.rate(None, 0.133, 0.0),
             60.0,
             "the plume bursts at impact"
         );
-        assert!(impact[1].timing.emitting(None, 0.1));
+        assert!(impact[1].timing.emitting(None, 0.1, 0.0));
         assert!(
-            !impact[1].timing.emitting(None, 0.4),
+            !impact[1].timing.emitting(None, 0.4, 0.0),
             "shockwave window is 300 ms"
         );
         assert!(
-            !impact[4].timing.emitting(None, 0.05),
+            !impact[4].timing.emitting(None, 0.05, 0.0),
             "smoke starts staggered…"
         );
-        assert!(impact[4].timing.emitting(None, 0.2));
-        assert!(!impact[4].timing.emitting(None, 0.7), "…and ends by 567 ms");
+        assert!(impact[4].timing.emitting(None, 0.2, 0.0));
+        assert!(
+            !impact[4].timing.emitting(None, 0.7, 0.0),
+            "…and ends by 567 ms"
+        );
     }
 }
diff --git a/crates/benilla-formats/tests/particles.rs b/crates/benilla-formats/tests/particles.rs
index 41631fee..8a7722f3 100644
--- a/crates/benilla-formats/tests/particles.rs
+++ b/crates/benilla-formats/tests/particles.rs
@@ -32,7 +32,7 @@ fn campfire_emitters_match_real_bytes() {
     for e in &emitters {
         assert_eq!(e.shape, ParticleShape::Plane);
         assert_eq!(e.blend, ParticleBlend::Add);
-        let now = e.params.sample(None, 0.0);
+        let now = e.params.sample(None, 0.0, 0.0);
         assert!(now.lifespan > 0.0 && now.lifespan.is_finite());
         let rate = e
             .timing
@@ -50,7 +50,7 @@ fn campfire_emitters_match_real_bytes() {
 
     // Glow/smoke plume: wide 20° cone, long life, low rate, single cell.
     let glow = &emitters[0];
-    let glow_now = glow.params.sample(None, 0.0);
+    let glow_now = glow.params.sample(None, 0.0, 0.0);
     assert!(
         (glow_now.lifespan - 4.0).abs() < 1e-3,
         "glow lifespan ~4.0, got {}",
@@ -66,7 +66,7 @@ fn campfire_emitters_match_real_bytes() {
 
     // Flame: short life, high rate, narrow cone, 4×4 cell animation.
     let flame = &emitters[1];
-    let flame_now = flame.params.sample(None, 0.0);
+    let flame_now = flame.params.sample(None, 0.0, 0.0);
     assert!(
         (flame_now.lifespan - 1.5).abs() < 1e-3,
         "flame lifespan ~1.5, got {}",
@@ -113,9 +113,9 @@ fn campfire_emitters_match_real_bytes() {
             e.shape,
             e.blend,
             e.texture,
-            e.params.sample(None, 0.0).lifespan,
+            e.params.sample(None, 0.0, 0.0).lifespan,
             e.timing.constant_rate(),
-            e.params.sample(None, 0.0).vertical_range,
+            e.params.sample(None, 0.0, 0.0).vertical_range,
             e.tile_rows,
             e.tile_cols
         );
@@ -461,29 +461,29 @@ fn barrel_explode_emitters_are_off_at_rest_and_fire_in_their_clips() {
         for slot in [1usize, 2] {
             for t in [0.0f32, 0.1, 0.3, 5.0] {
                 assert!(
-                    !e.timing.emitting(Some(slot), t),
+                    !e.timing.emitting(Some(slot), t, 0.0),
                     "emitter {i} must be OFF at rest (slot {slot}, t {t})"
                 );
             }
         }
         // The one-shot explode clip (slot 0, anim 157, 1 s clamped): the choreography fires
         // somewhere inside it…
-        let fires = (0..100).any(|k| e.timing.emitting(Some(0), k as f32 * 0.01));
+        let fires = (0..100).any(|k| e.timing.emitting(Some(0), k as f32 * 0.01, 0.0));
         assert!(fires, "emitter {i} fires inside the explode clip");
         // …and the clamped clock PARKS OFF at/after the clip end — the exact end state the old
         // rebase got wrong (it clamped a later clip's ON key onto the band end).
         assert!(
-            !e.timing.emitting(Some(0), 1.0),
+            !e.timing.emitting(Some(0), 1.0, 0.0),
             "emitter {i} must be off at the clip end"
         );
         assert!(
-            !e.timing.emitting(Some(0), 30.0),
+            !e.timing.emitting(Some(0), 30.0, 0.0),
             "emitter {i} must stay off parked past the clip"
         );
     }
     // The Destroy clip (slot 3, anim 150) fires the explosion too — the quest's actual payoff.
     let destroy_fires = emitters
         .iter()
-        .any(|e| (0..100).any(|k| e.timing.emitting(Some(3), k as f32 * 0.01)));
+        .any(|e| (0..100).any(|k| e.timing.emitting(Some(3), k as f32 * 0.01, 0.0)));
     assert!(destroy_fires, "the Destroy clip plays the explosion");
 }
diff --git a/crates/benilla/src/aura_visual/tests.rs b/crates/benilla/src/aura_visual/tests.rs
index 830edb59..0dc904b9 100644
--- a/crates/benilla/src/aura_visual/tests.rs
+++ b/crates/benilla/src/aura_visual/tests.rs
@@ -227,6 +227,7 @@ fn app_with_chains() -> App {
     let mut app = App::new();
     app.add_plugins(MinimalPlugins);
     app.add_message::<crate::creature_anim::SpellKitFx>();
+    app.add_message::<crate::creature_anim::SpellKitSound>();
     app.add_message::<AuraProc>();
     app.insert_resource(SpellVisuals(SpellVisualCatalog::from_tables(
         HashMap::from([
diff --git a/crates/benilla/src/billboard.rs b/crates/benilla/src/billboard.rs
index e41f2f4e..ab228e1a 100644
--- a/crates/benilla/src/billboard.rs
+++ b/crates/benilla/src/billboard.rs
@@ -49,10 +49,20 @@ pub struct BillboardCard {
     /// The billboard bone's looping scale animation (the lamppost glow "breathe"), sampled each frame
     /// and multiplied into [`Self::scale`]. `None` for a static card (no global-sequence scale track).
     scale_anim: Option<BoneScaleAnim>,
-    /// Per-instance phase offset (ms) into the global sequence, hashed from the world position — so a
-    /// row of identical lampposts breathes out of lockstep (each prop instance arms its own clock) rather
-    /// than blinking in unison. No-op when there's no `scale_anim`.
-    phase_ms: u32,
+    /// The armed-sequence cursor offset (ms, negated so a wrapping ADD subtracts): sampling the
+    /// [`Self::seq_translation`] loop runs on `elapsed − arm_ms` — the reference's per-play
+    /// phase for SEQUENCE tracks (`cursor = clock − startOffset`, re-baked at every arm). `0`
+    /// until [`Self::arm_seq_translation`] arms a loop.
+    arm_neg_ms: u32,
+    /// The gseq [`Self::scale_anim`]'s ATTACH anchor (ms): `None` until the first placement pass
+    /// stamps it — the reference snapshots the scene clock once per model instance at attach
+    /// (`CM2Model+0x68`, wow-re `gseq-anchor.md`; decision 0856), so a row of lampposts streamed
+    /// in on different frames breathes at per-instance phases, while same-frame spawns share
+    /// one. Distinct from [`Self::arm_neg_ms`]: the gseq anchor is stamped once per instance,
+    /// the sequence cursor re-arms per play. (An earlier position-hash de-sync here emulated
+    /// the per-instance spread with an invented mechanism; 0855 briefly removed phase entirely —
+    /// both superseded by the byte law.)
+    gseq_attach_ms: Option<u32>,
     /// The bone's armed first-sequence **translation** loop (the questgiver `?` marker's bob, keys in
     /// Bevy axes) — sampled each frame on the same clock/phase and added at the pivot, rotated by
     /// [`Self::placement_rot`]. `None` (every doodad card today) = the static pivot; only the marker
@@ -78,16 +88,13 @@ impl BillboardCard {
     /// regardless of how the prop is turned).
     pub fn new(info: &BillboardInfo, placement: Transform) -> Self {
         let world_pivot = placement.transform_point(info.pivot);
-        // A stable per-instance phase from the world position (same hashing as the particle RNG seed).
-        let phase_ms = world_pivot.x.to_bits().wrapping_mul(0x9E37_79B9)
-            ^ world_pivot.y.to_bits().rotate_left(11)
-            ^ world_pivot.z.to_bits().rotate_left(22);
         Self {
             world_pivot,
             scale: placement.scale.x,
             kind: info.kind,
             scale_anim: info.scale_anim.clone(),
-            phase_ms,
+            arm_neg_ms: 0,
+            gseq_attach_ms: None,
             seq_translation: None,
             placement_rot: placement.rotation,
             follow: None,
@@ -142,7 +149,8 @@ impl BillboardCard {
             scale: 1.0,
             kind,
             scale_anim: None,
-            phase_ms: 0,
+            arm_neg_ms: 0,
+            gseq_attach_ms: None,
             seq_translation: None,
             placement_rot: Quat::IDENTITY,
             follow: Some(owner),
@@ -152,8 +160,7 @@ impl BillboardCard {
 
     /// Arm the card's first-sequence translation loop (the questgiver `?` bob) with the client's
     /// arm-time cursor: sampling runs on `elapsed − arm_ms` (the loop starts at its first key the
-    /// moment the marker attaches, like the real arm at status receive). Overrides the position-hash
-    /// phase — markers of one NPC swap in place and must not inherit a doodad-flavored phase.
+    /// moment the marker attaches, like the real arm at status receive).
     pub(crate) fn with_seq_translation(mut self, anim: Option<BoneScaleAnim>, arm_ms: u32) -> Self {
         self.arm_seq_translation(anim, arm_ms);
         self
@@ -164,7 +171,7 @@ impl BillboardCard {
     /// [`Self::with_seq_translation`].
     pub(crate) fn arm_seq_translation(&mut self, anim: Option<BoneScaleAnim>, arm_ms: u32) {
         if anim.is_some() {
-            self.phase_ms = arm_ms.wrapping_neg();
+            self.arm_neg_ms = arm_ms.wrapping_neg();
         }
         self.seq_translation = anim;
     }
@@ -519,18 +526,25 @@ pub(crate) fn face_billboards(
                 }
             }
         }
+        // The gseq attach anchor: stamped on the card's first placement pass — the reference's
+        // once-per-instance scene-clock snapshot (decision 0856).
+        let attach_ms = *card.gseq_attach_ms.get_or_insert(elapsed_ms);
         let card = &*card;
         let rotation = billboard_basis(card.kind, card.placement_rot, fwd, right, up);
-        // The bone's global-sequence scale pulse (the lamppost glow "breathe"), sampled at this prop's
-        // own phase into the loop. `Vec3::ONE` (no-op) when the card has no scale track.
+        // The bone's global-sequence scale pulse (the lamppost glow "breathe"), on the instance's
+        // anchored cursor (`sceneNow − attach`): instances stamped on different frames pulse at
+        // per-instance phases, same-frame spawns in phase — the reference's anchor law.
+        // `Vec3::ONE` (no-op) when the card has no scale track.
         let pulse = card.scale_anim.as_ref().map_or(Vec3::ONE, |a| {
-            Vec3::from_array(a.sample(elapsed_ms.wrapping_add(card.phase_ms)))
+            Vec3::from_array(a.sample(elapsed_ms.wrapping_sub(attach_ms)))
         });
         // The armed first-sequence translation loop (the questgiver `?` bob): a model-local offset
-        // at the pivot, pointed by the placement rotation and sized by its scale.
+        // at the pivot, pointed by the placement rotation and sized by its scale — on the ARM
+        // cursor (`elapsed − arm_ms`), the sequence-track half of the clock law.
         let bob = card.seq_translation.as_ref().map_or(Vec3::ZERO, |a| {
             card.placement_rot
-                * (Vec3::from_array(a.sample(elapsed_ms.wrapping_add(card.phase_ms))) * card.scale)
+                * (Vec3::from_array(a.sample(elapsed_ms.wrapping_add(card.arm_neg_ms)))
+                    * card.scale)
         });
         *tf = Transform {
             translation: card.world_pivot + bob,
@@ -577,6 +591,56 @@ mod tests {
     use super::*;
     use benilla_assets::BillboardInfo;
 
+    /// **Geometry lying along a bone's own axis does not sweep** — the fact decision 0847 got wrong
+    /// and 0853 restored, pinned here in our own basis rather than trusted to algebra.
+    ///
+    /// The R14 pauldron's spikes run along WoW **−Z** (`seamswing`: mean |z| 0.284/0.291 against
+    /// ≤0.06 on x and y, worst vertex 12° off axis), which is Bevy local **−Y**. A spherical
+    /// billboard maps WoW Z to the camera's up, so that direction must come out as **−up — screen
+    /// DOWN — from every camera orientation**, never tracing an arc. 0847 read the spikes' 0.29 yd
+    /// length as a 0.29 yd arc through the plate and withdrew a correct change on it; if that arc
+    /// were real, this test is where it would show up as a direction that moves with the camera.
+    ///
+    /// The `kept_rot` argument is swept too: the spherical arm discards the pre-billboard rotation
+    /// outright (wow-re `billboard-bone-law.md` §1), so the wearer's shoulder yaw must not reach
+    /// the result — which is *also* why the spike stops following the shoulder, the real visible
+    /// difference the arm makes (§6.3).
+    #[test]
+    fn a_spike_along_its_bone_axis_points_screen_down_from_every_angle() {
+        // Bevy local −Y is the pauldron spike's run axis (WoW −Z through coords.rs' X→−Z, Y→−X,
+        // Z→+Y).
+        let spike_local = Vec3::NEG_Y;
+        for (yaw, pitch) in [
+            (0.0, 0.0),
+            (0.7, 0.0),
+            (2.4, 0.0),
+            (-1.9, 0.0),
+            (std::f32::consts::PI, 0.0),
+            (0.0, 0.5),
+            (1.2, -0.6),
+            (-2.8, 0.9),
+        ] {
+            let cam =
+                Transform::from_rotation(Quat::from_rotation_y(yaw) * Quat::from_rotation_x(pitch));
+            let (fwd, right, up) = (*cam.forward(), *cam.right(), *cam.up());
+            for kept in [
+                Quat::IDENTITY,
+                Quat::from_rotation_y(1.1),
+                Quat::from_rotation_x(-0.8),
+                Quat::from_rotation_z(2.2),
+            ] {
+                let got =
+                    billboard_basis(BillboardKind::Spherical, kept, fwd, right, up) * spike_local;
+                assert!(
+                    got.distance(-up) < 1e-5,
+                    "spike must point screen-down, not sweep: cam yaw {yaw} pitch {pitch}, \
+                     kept {kept:?} → {got:?}, expected {:?}",
+                    -up
+                );
+            }
+        }
+    }
+
     /// A FOLLOWING card (decision 0153 — the entity-path glow cards) re-seats from its owner's
     /// live global transform each frame and despawns with it: the brazier glow burns at the bowl
     /// (owner translation + authored pivot), never the model origin — and dies when the owner
diff --git a/crates/benilla/src/capture/pick_probe.rs b/crates/benilla/src/capture/pick_probe.rs
index 5feb93b3..b7776020 100644
--- a/crates/benilla/src/capture/pick_probe.rs
+++ b/crates/benilla/src/capture/pick_probe.rs
@@ -37,13 +37,12 @@
 //! `viewport_to_world` works in logical units and a Retina capture is 2× the logical window.
 
 use bevy::mesh::MeshTag;
-use bevy::picking::mesh_picking::ray_cast::{MeshRayCast, MeshRayCastSettings, RayCastVisibility};
 use bevy::platform::collections::HashSet;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
 
 use super::probes::ProbeClock;
-use crate::interact::WorldObject;
+use crate::interact::{cast_pick_ray, PickParts, WorldObject};
 use crate::player::WorldCamera;
 use crate::terrain::WowModelMaterial;
 
@@ -190,7 +189,7 @@ fn fire_pick(
     // the probe keys on it too and stays a pure instrument: nothing outside this file reads it.
     objects: Query<Entity, Pickable>,
     names: HitNames,
-    mut ray_cast: MeshRayCast,
+    parts: PickParts,
 ) {
     if probe.taken >= probe.count || probe.pixels.is_empty() || time.elapsed_secs() < probe.next_at
     {
@@ -210,14 +209,11 @@ fn fire_pick(
             warn!("pick ({}, {}): outside the viewport", pixel.x, pixel.y);
             continue;
         };
-        let filter = |e: Entity| pickable.contains(&e);
-        // `never_early_exit` is the whole reason this exists: the default stops at the first hit,
-        // and the rival surface behind it is exactly what we came for.
-        let settings = MeshRayCastSettings::default()
-            .with_visibility(RayCastVisibility::VisibleInView)
-            .with_filter(&filter)
-            .never_early_exit();
-        let hits = ray_cast.cast_ray(ray, &settings);
+        // `all_hits` is the whole reason this exists: the nearest hit alone cannot name the rival
+        // surface behind it, which is exactly what we came for. The cast reads each part's
+        // RESIDENT geometry (decision 0857) — the render meshes are `RENDER_WORLD`-only since
+        // 0834, so a `MeshRayCast` here reports nothing for any static model.
+        let hits = cast_pick_ray(ray, &pickable, &parts, true);
         // The camera's GLOBAL transform, bit-exact, on the line that carries the cast index — so
         // "did the camera move on this frame?" is answerable against "was this frame dim?" without
         // aligning two logs by hand. It is deliberately *this* transform: it is the one
diff --git a/crates/benilla/src/capture/probes.rs b/crates/benilla/src/capture/probes.rs
index e5a2f4e5..b1bda145 100644
--- a/crates/benilla/src/capture/probes.rs
+++ b/crates/benilla/src/capture/probes.rs
@@ -1131,7 +1131,7 @@ fn fire_particle_census(
             d.blend,
             d.flags,
             rate_keys.join(","),
-            d.params.sample(None, 0.0).lifespan,
+            d.params.sample(None, 0.0, 0.0).lifespan,
             d.texture.as_deref().unwrap_or("-"),
             e.live(),
             // The frame's composed MODEL alpha (decision 0827/0833) — the number that answers
diff --git a/crates/benilla/src/creature_anim/global_seq.rs b/crates/benilla/src/creature_anim/global_seq.rs
index dabd6a80..7e519058 100644
--- a/crates/benilla/src/creature_anim/global_seq.rs
+++ b/crates/benilla/src/creature_anim/global_seq.rs
@@ -1,15 +1,25 @@
 //! Global-sequence bone channels — free-clock loops *independent* of the playing animation (the
-//! character eye-blink eyelid scale; resting fidget pulses). benilla's per-sequence reader deliberately
-//! drops them: they key off their own global-sequence timer, not the playing sequence's time band
-//! (`benilla_formats::parse_m2_animations`). This samples them on a per-instance clock and writes the
-//! driven joint components *after* the [`AnimationPlayer`] posed the skeleton.
+//! character eye-blink eyelid scale; resting fidget pulses; a spell effect's star twinkles).
+//! benilla's per-sequence reader deliberately drops them: they key off their own global-sequence
+//! timer, not the playing sequence's time band (`benilla_formats::parse_m2_animations`). This
+//! samples them on the instance's global-sequence clock and writes the driven joint components
+//! *after* the [`AnimationPlayer`] posed the skeleton.
 //!
-//! Ground truth (wow-5875-re `animation.md` / `doodad-anim-host.md`): global sequences loop with **zero
-//! arming**, clock-driven off the model's own time field, wrapped modulo each sequence's duration —
-//! `globalSequences[gseq]`. There is no per-frame re-arm; the default-animation op4 and the global
-//! sequences coexist, the latter purely clock-driven. The canonical consumer is the eyelid: its scale is
-//! `0` (lid retracted, eye open) for ~96% of the loop and `1` (lid full, eye shut) for ~100 ms — the
-//! blink. Without this pass the eyelid sits at its default identity scale (full size) forever: eyes shut.
+//! Ground truth (wow-5875-re `gseq-anchor.md`, byte-verified): the cursor is
+//! `(sceneClock − instanceAttachTime) % duration` — ONE free-running per-scene ms clock
+//! (`[scene+0xc]`, advanced once per scene update), snapshotted ONCE per model instance at attach
+//! (`CM2Model+0x68`, written unconditionally at `0x70eae1`). So a fresh instance starts its
+//! global sequences at phase 0, and two instances attached on different frames run at different
+//! phases — per-INSTANCE anchoring, not per-play arming (sequence tracks re-arm per play; the
+//! gseq anchor is stamped once). Spell effects are NOT an exception: the lifecycle is
+//! byte-verified fresh-per-play (wow-re `gseq-instance-lifecycle.md`: CreateModel always
+//! alloc→ctor→attach, teardown is a hard free, no pooling), and the director's own 3-cast
+//! apitrace shows the impact flash at the same +16-frame offset every cast — the apparent
+//! cast-to-cast scatter is particle randomness plus the moving cast-anim hands, not clock
+//! phase (decisions 0855/0856/0858). The canonical creature consumer is the eyelid:
+//! its scale is `0` (lid retracted, eye open) for ~96% of the loop and `1` (lid full, eye shut)
+//! for ~100 ms — the blink. Without this pass the eyelid sits at its default identity scale
+//! (full size) forever: eyes shut.
 
 use bevy::prelude::*;
 
@@ -23,17 +33,21 @@ enum SeqTarget {
 }
 
 /// Per-instance driver for a model's global-sequence bone channels: each channel's write target
-/// paired with its baked channels, plus the free-running clock they wrap on. Attached beside the
+/// paired with its baked channels, plus the instance's clock **anchor** — the attach-time
+/// snapshot of the shared scene clock (`CM2Model+0x68`, module docs). Attached beside the
 /// [`AnimationPlayer`] on a skinned instance whose model carries any global-sequence track.
 #[derive(Component)]
 pub(crate) struct GlobalSeqDrive {
     /// `(write target, its baked global-sequence channels)`.
     bones: Vec<(SeqTarget, GlobalBone)>,
-    /// Seconds since spawn — the model clock each channel wraps (`t mod period`).
-    elapsed: f32,
-    /// Paused: skip sampling entirely (the doodad host gates animation to drawn instances — wow-re
-    /// `doodad-anim-host.md`: the ref's kernel ticks at draw time, so a culled model isn't evaluated).
-    /// Creatures never pause. A resume re-syncs the clock via [`Self::sync`], so pausing is drift-free.
+    /// The attach snapshot of the shared clock (secs): `None` until the first animate tick stamps
+    /// it (the instance's attach — the ref writes `+0x68` once, at attach).
+    anchor: Option<f64>,
+    /// Paused: skip the joint writes (the doodad host gates animation to drawn instances — wow-re
+    /// `doodad-anim-host.md`: the ref's kernel ticks at draw time, so a culled model isn't
+    /// evaluated). Creatures never pause. Resuming needs no re-seek: the cursor is a pure
+    /// function of the shared clock and the attach anchor, so a re-appearing doodad shows the
+    /// pose the clock dictates.
     paused: bool,
 }
 
@@ -52,7 +66,7 @@ impl GlobalSeqDrive {
             .collect();
         (!bones.is_empty()).then_some(Self {
             bones,
-            elapsed: 0.0,
+            anchor: None,
             paused: false,
         })
     }
@@ -67,48 +81,41 @@ impl GlobalSeqDrive {
             .collect();
         (!bones.is_empty()).then_some(Self {
             bones,
-            elapsed: 0.0,
+            anchor: None,
             paused: false,
         })
     }
 
-    /// Pause/resume sampling (the doodad draw gate). While paused the joints hold their last pose.
+    /// Pause/resume the joint writes (the doodad draw gate). While paused the joints hold their
+    /// last pose; resume lands on the anchored cursor with nothing to catch up.
     pub(crate) fn set_paused(&mut self, paused: bool) {
         self.paused = paused;
     }
-
-    /// Re-seat the clock at `elapsed` seconds since spawn — the resume-from-pause seek that keeps the
-    /// channel clock-indexed like the ref's (`cursor = clock − startOffset`): a re-appearing doodad
-    /// shows the pose the shared clock dictates, and same-frame spawns stay in phase across pauses.
-    pub(crate) fn sync(&mut self, elapsed: f32) {
-        self.elapsed = elapsed;
-    }
 }
 
-/// Sample each instance's global-sequence channels on its own clock and write the driven bone —
-/// in the pose post-pass window ([`super::PosePost`], the same as the body twist), so the model
-/// compose folds it. A channel overwrites only its own component; a bone the playing animation
-/// never keyed (the eyelid) keeps its rest translation/rotation and takes only the global scale,
-/// so the eye opens and blinks over whatever gait is playing.
+/// Sample every drive's channels at its anchored cursor (`sharedNow − anchor`, stamping the
+/// anchor on the first tick — the attach) and write the driven bone — in the pose post-pass
+/// window ([`super::PosePost`], the same as the body twist), so the model compose folds it. A
+/// channel overwrites only its own component; a bone the playing animation never keyed (the
+/// eyelid) keeps its rest translation/rotation and takes only the global scale, so the eye opens
+/// and blinks over whatever gait is playing. The cursor wraps per channel in f64 (`t % period`)
+/// so a long-uptime clock keeps millisecond precision through the f32 sampler.
 fn apply_global_sequences(
     time: Res<Time>,
     mut drives: Query<(Entity, &mut GlobalSeqDrive, Has<super::AnimParked>)>,
     mut joints: Query<&mut Transform>,
     mut rigs: Query<&mut super::RigPose>,
 ) {
-    let dt = time.delta_secs();
+    let now = time.elapsed_secs_f64();
     for (host, mut drive, parked) in &mut drives {
-        if drive.paused {
+        // The attach stamp happens even while parked/paused — the ref stamps +0x68 at attach,
+        // not at first draw.
+        let t = now - *drive.anchor.get_or_insert(now);
+        // A parked or paused instance skips only the WRITES — the cursor is absolute
+        // (decision 0448's absolute-clock ruling, now literal: nothing per-instance advances).
+        if drive.paused || parked {
             continue;
         }
-        // A parked unit's channel clock keeps running — only the bone writes stop (decision
-        // 0448: units are absolute-clock, never freeze-and-resume; the doodad lane pauses via
-        // [`GlobalSeqDrive::set_paused`] + [`GlobalSeqDrive::sync`] instead and never parks).
-        drive.elapsed += dt;
-        if parked {
-            continue;
-        }
-        let t = drive.elapsed;
         let mut rig = rigs.get_mut(host).ok();
         for (target, bone) in &drive.bones {
             let tf: &mut Transform = match target {
@@ -127,14 +134,15 @@ fn apply_global_sequences(
                     tf
                 }
             };
+            let at = |period: f32| (t % f64::from(period.max(1e-3))) as f32;
             if let Some(c) = &bone.translation {
-                tf.translation = c.sample(t);
+                tf.translation = c.sample(at(c.period));
             }
             if let Some(c) = &bone.rotation {
-                tf.rotation = c.sample(t);
+                tf.rotation = c.sample(at(c.period));
             }
             if let Some(c) = &bone.scale {
-                tf.scale = c.sample(t);
+                tf.scale = c.sample(at(c.period));
             }
         }
     }
@@ -168,40 +176,77 @@ mod tests {
         }
     }
 
-    /// The driver writes the sampled global-sequence scale onto the mapped joint each tick — the eyelid
-    /// reads `1` (shut) when the clock sits in the blink window and `0` (open) the rest of the loop, so a
-    /// skinned character actually opens and blinks instead of freezing lid-down. Time advances by real
-    /// dt; both clocks sit on a constant plateau of the channel, so the assert is jitter-proof.
+    /// A linear-ramp channel (`scale = t`, long period) — phase differences are visible at any
+    /// absolute elapsed.
+    fn ramp() -> GlobalBone {
+        GlobalBone {
+            bone: 0,
+            translation: None,
+            rotation: None,
+            scale: Some(GlobalSeqChannel {
+                period: 100.0,
+                keys: vec![(0.0, Vec3::ZERO), (100.0, Vec3::splat(100.0))],
+            }),
+        }
+    }
+
+    /// The anchor law (0856): a FRESH drive stamps its attach on its first tick, so a drive
+    /// spawned later reads a SMALLER cursor than one spawned earlier (per-instance phase — two
+    /// creatures attached on different frames blink at different times). Ticks are
+    /// deterministic via `TimeUpdateStrategy::ManualDuration`.
     #[test]
-    fn driver_writes_eyelid_scale_from_the_clock() {
+    fn fresh_drives_anchor_at_attach() {
         let mut app = App::new();
-        app.add_plugins(MinimalPlugins); // Time
+        app.add_plugins(MinimalPlugins);
+        app.insert_resource(bevy::time::TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_millis(60),
+        ));
         app.add_systems(Update, apply_global_sequences);
 
-        // Two instances: one clock parked mid-blink (shut), one parked in the open tail.
-        let shut_joint = app.world_mut().spawn(Transform::default()).id();
-        app.world_mut().spawn(GlobalSeqDrive {
-            bones: vec![(SeqTarget::Joint(shut_joint), eyelid_bone())],
-            elapsed: 0.06, // inside [0.033, 0.100] → scale 1
-            paused: false,
-        });
-        let open_joint = app.world_mut().spawn(Transform::default()).id();
-        app.world_mut().spawn(GlobalSeqDrive {
-            bones: vec![(SeqTarget::Joint(open_joint), eyelid_bone())],
-            elapsed: 3.0, // inside [0.133, 6.633] → scale 0
-            paused: false,
-        });
-
+        let early_joint = app.world_mut().spawn(Transform::default()).id();
+        app.world_mut()
+            .spawn(GlobalSeqDrive::new(&[ramp()], &[early_joint]).expect("a keyed channel maps"));
+        app.update();
+        app.update();
+        // A drive attached two ticks later.
+        let late_joint = app.world_mut().spawn(Transform::default()).id();
+        app.world_mut()
+            .spawn(GlobalSeqDrive::new(&[ramp()], &[late_joint]).expect("a keyed channel maps"));
+        app.update();
         app.update();
 
-        let scale = |e: Entity| app.world().entity(e).get::<Transform>().unwrap().scale;
+        let s = |e: Entity| app.world().entity(e).get::<Transform>().unwrap().scale.x;
         assert!(
-            scale(shut_joint).abs_diff_eq(Vec3::ONE, 1e-3),
-            "eyelid shut mid-blink"
+            s(early_joint) > s(late_joint),
+            "the later attach reads a smaller cursor (per-instance anchor): early {} vs late {}",
+            s(early_joint),
+            s(late_joint)
         );
         assert!(
-            scale(open_joint).abs_diff_eq(Vec3::ZERO, 1e-3),
-            "eyelid open the rest of the loop"
+            s(late_joint) > 0.0,
+            "the late drive did tick from its own anchor (got {})",
+            s(late_joint)
+        );
+    }
+
+    /// The eyelid channel itself still samples correctly at a given cursor — the blink window
+    /// reads shut, the long tail reads open (the channel sampler is untouched by the anchor
+    /// work; only who supplies `t` changed).
+    #[test]
+    fn eyelid_channel_samples_by_clock_value() {
+        let bone = eyelid_bone();
+        let c = bone.scale.as_ref().unwrap();
+        assert!(
+            c.sample(0.06).abs_diff_eq(Vec3::ONE, 1e-3),
+            "shut mid-blink"
+        );
+        assert!(
+            c.sample(3.0).abs_diff_eq(Vec3::ZERO, 1e-3),
+            "open in the tail"
+        );
+        assert!(
+            c.sample(3.0 + 2.0 * 6.633).abs_diff_eq(Vec3::ZERO, 1e-3),
+            "wraps on its period"
         );
     }
 }
diff --git a/crates/benilla/src/creature_anim/spell_visual.rs b/crates/benilla/src/creature_anim/spell_visual.rs
index 0f5ad28c..2468bfbf 100644
--- a/crates/benilla/src/creature_anim/spell_visual.rs
+++ b/crates/benilla/src/creature_anim/spell_visual.rs
@@ -62,6 +62,12 @@ pub(crate) enum SpellKitSound {
     /// The cast/channel hold ended (GO / fail / channel-clear / a replacing cast) — reap the
     /// unit's tracked hold loop, if any (the client kills the effect's sound at `0x614150`).
     StopHold { entity: Entity },
+    /// Stop exactly `kit_sound`'s channels on this unit — the aura-drop reap of a LOOPING
+    /// **state**-kit sound (wow-re `kit-sound-leg.md`: a looping kit sound rides a tracked,
+    /// spell-id-tagged CEffect on the unit's list, and `0x614150` stops it with a 0.15 s fade
+    /// when the aura leaves). Kit-scoped so an unrelated hold loop on the same unit survives;
+    /// a one-shot kit is never tracked, so for it this is a no-op.
+    StopKit { entity: Entity, kit_sound: u32 },
 }
 
 /// A persistent effect instance's **lifetime class** — which owner's reap can kill it.
@@ -317,9 +323,11 @@ struct KitOut<'a, 'w1, 'w2, 'w3, 'w4> {
 /// - `persistent`: the effect models' lifetime (the precast/channel hold vs self-terminating).
 /// - `effects`: whether the models spawn here at all. `false` for the impact hand-off's STATE
 ///   stage — its models belong to the aura's life and [`arm_aura_state_fx`] owns them.
-/// - `sound`: whether the kit's sound rings. The STATE stage's sound is SELF-ONLY
-///   (byte-verified: the stage-2 play's sound leg is gated on IsActivePlayer, `0x5fa6d0` —
-///   wow-re `state-kit-aura-lifecycle.md`), so observers never hear another unit's buff kit.
+/// - `sound`: whether the kit's sound rings — **ungated and positional at the unit, every
+///   stage** (wow-re `kit-sound-leg.md`, decision 0852: `0x60edf0`'s sound leg carries no self
+///   test; the old "state sound is self-only" reading was `0x5ff43e`'s gate on a *different*
+///   aura-apply cue, and `0x5fa6d0` appears nowhere in the kit play). The flag exists for
+///   plays that deliberately hand the sound to another owner (none today).
 #[derive(Clone, Copy)]
 struct KitPlay {
     persistent: bool,
@@ -380,16 +388,17 @@ fn play_kit(
 /// kit plays its anim + sound only: its **effect models live for the aura's life**, owned by
 /// [`arm_aura_state_fx`]'s slot watcher (a single instance, begun when the aura lands in the
 /// slots and reaped when it leaves — the same packet burst as the GO, so there is no visible
-/// gap). Named approximation: the client's small stage-2 gate `0x61dc20` (37 B, content
-/// unpinned) is not modeled. `weapon_visual` = the CASTER's ranged fallback visual (already
-/// resolved — the caster may be gone by a missile arrival), through which a basic shot's impact
-/// kit resolves. `is_self` gates the state stage's sound (self-only, see [`play_kit`]).
-#[allow(clippy::too_many_arguments)] // one hand-off's full input set
+/// gap). The state sound rings **ungated and positional** (wow-re `kit-sound-leg.md`, decision
+/// 0852: `0x60edf0`'s sound leg has no self test — the old self-only reading belonged to a
+/// different aura-apply cue); the same-frame duplicate against the aura watcher's ADD-edge play
+/// collapses in the sound router. Named approximation: the client's small stage-2 gate
+/// `0x61dc20` (37 B, content unpinned) is not modeled. `weapon_visual` = the CASTER's ranged
+/// fallback visual (already resolved — the caster may be gone by a missile arrival), through
+/// which a basic shot's impact kit resolves.
 fn play_impact(
     entity: Entity,
     spell_id: u32,
     weapon_visual: Option<u32>,
-    is_self: bool,
     seq: u64,
     spells: &crate::ui_action::Spells,
     visuals: &SpellVisualCatalog,
@@ -404,7 +413,6 @@ fn play_impact(
             |s: &VisualStages| s.state,
             KitPlay {
                 effects: false,
-                sound: is_self,
                 ..KitPlay::DISCRETE
             },
         ),
@@ -452,7 +460,7 @@ pub(super) fn route_cast_visuals(
     visuals: Option<Res<SpellVisuals>>,
     spells: Option<Res<crate::ui_action::Spells>>,
     mut weapon_src: WeaponVisualSrc,
-    units: Query<(Entity, &ObjectStore, Has<crate::net::SelfPlayer>)>,
+    units: Query<(Entity, &ObjectStore)>,
     holds: Query<&CastHold>,
     mut channel_cache: Local<EntityHashMap<u32>>,
 ) {
@@ -675,7 +683,6 @@ pub(super) fn route_cast_visuals(
                     ev.entity,
                     ev.spell_id,
                     weapon_visual,
-                    units.get(ev.entity).is_ok_and(|(.., is_self)| is_self),
                     ev.seq,
                     spells,
                     &visuals.0,
@@ -733,7 +740,6 @@ pub(super) fn route_cast_visuals(
                     target,
                     go.spell_id,
                     wv,
-                    units.get(target).is_ok_and(|(.., is_self)| is_self),
                     go.seq,
                     spells,
                     &visuals.0,
@@ -796,7 +802,7 @@ pub(super) fn route_cast_visuals(
     // unit's channel loop (the self-only MSG_CHANNEL_* never carry this — decision 0099). Only
     // *edges* act, so a held channel's clip is started once (the client's dedup guard) and a
     // cleared field releases the hold even when the interrupt had no other wire trace.
-    for (entity, store, _) in &units {
+    for (entity, store) in &units {
         let cur = store.0.unit_channel_spell();
         let prev = channel_cache.get(&entity).copied().unwrap_or(0);
         if cur == prev {
@@ -877,12 +883,14 @@ pub(super) fn route_cast_visuals(
 /// The trigger and reap are byte-verified (wow-re `state-kit-aura-lifecycle.md`, §5 2026-07-14):
 /// the aura watcher `0x604d00 → 0x6123f0 → 0x5ff350` reads `SpellVisual` field 4 and plays the
 /// kit at stage 2 (`0x5ff4c2: push 2`); the remove path `0x612320 → 0x5ff290` reaps with
-/// `0x614150(spellId, force=1)`. The ADD edge's sound is SELF-gated (`0x5fa6d0` IsActivePlayer),
-/// so observers hear nothing — and its body anim is NOT code-suppressed (`0x60edf0`'s tail plays
-/// `kit+0x08` unconditionally). This watcher plays effects only — correct for every state kit
-/// whose anim column is the none-sentinel (food's 409 is), and a **named residual** for a state
-/// kit that carries a real anim: that ADD-edge replay isn't built (no live kit demonstrates it;
-/// build it from the verdict when one shows).
+/// `0x614150(spellId, force=1)`. The ADD edge's kit sound rings **ungated and positional** (wow-re
+/// `kit-sound-leg.md`, decision 0852 — its §5 corrected the earlier "SELF-gated" reading: the
+/// `0x5fa6d0` gate at `0x5ff43e` covers only a separate spellRec-driven aura-apply cue, and both
+/// branches fall through to the ungated kit play at `0x5ff4c6`); a looping kit sound is tracked
+/// and stops with the aura ([`SpellKitSound::StopKit`]). The body anim is NOT code-suppressed
+/// (`0x60edf0`'s tail plays `kit+0x08` unconditionally) — this watcher plays effects + sound,
+/// with a **named residual** for a state kit carrying a real anim: that ADD-edge replay isn't
+/// built (no live kit demonstrates it; build it from the verdict when one shows).
 ///
 /// `armed` tracks exactly the (unit, spell) pairs this watcher began, so the REMOVE edge never
 /// reaps another owner's persistent instances (a channel hold whose spell also rides an aura).
@@ -905,6 +913,7 @@ pub(crate) fn arm_aura_state_fx(
     spells: Option<Res<crate::ui_action::Spells>>,
     mut fx: MessageWriter<SpellKitFx>,
     mut procs: MessageWriter<AuraProc>,
+    mut sounds: MessageWriter<SpellKitSound>,
     mut armed: Local<EntityHashMap<Vec<u32>>>,
 ) {
     let (Some(visuals), Some(spells)) = (visuals.as_deref(), spells.as_deref()) else {
@@ -925,6 +934,14 @@ pub(crate) fn arm_aura_state_fx(
                     class: FxClass::AuraState,
                 });
                 procs.write(AuraProc::Reap { entity, spell_id });
+                // A LOOPING state-kit sound is a tracked hold that dies with the aura
+                // (`0x614150`'s 0.15 s fade — 0852); kit-scoped, a no-op for one-shots.
+                if let Some(kit_sound) =
+                    resolve_kit(spells, &visuals.0, spell_id, |s| s.state, || None)
+                        .and_then(|k| k.sound)
+                {
+                    sounds.write(SpellKitSound::StopKit { entity, kit_sound });
+                }
             }
         }
         let mut next = Vec::with_capacity(prev.len());
@@ -941,7 +958,7 @@ pub(crate) fn arm_aura_state_fx(
                 .char_procs()
                 .filter_map(crate::aura_visual::node_for)
                 .collect();
-            if effects.is_empty() && nodes.is_empty() {
+            if effects.is_empty() && nodes.is_empty() && kit.sound.is_none() {
                 continue; // a state kit that does nothing we model — nothing to arm or reap
             }
             if !effects.is_empty() {
@@ -960,6 +977,14 @@ pub(crate) fn arm_aura_state_fx(
                     nodes,
                 });
             }
+            // The ADD edge rings the kit sound — ungated and positional (0852: the kit play's
+            // sound leg has no self test; the old self-only reading belonged to a different
+            // aura-apply cue). Covers the streamed-in-mid-aura unit no impact play can; the
+            // same-frame duplicate against the impact hand-off's state flash collapses in the
+            // sound router.
+            if let Some(kit_sound) = kit.sound {
+                sounds.write(SpellKitSound::Play { entity, kit_sound });
+            }
             next.push(spell_id);
         }
         *prev = next;
diff --git a/crates/benilla/src/creature_anim/spell_visual/tests.rs b/crates/benilla/src/creature_anim/spell_visual/tests.rs
index aa5d1a84..a22af0ea 100644
--- a/crates/benilla/src/creature_anim/spell_visual/tests.rs
+++ b/crates/benilla/src/creature_anim/spell_visual/tests.rs
@@ -438,9 +438,11 @@ fn aura_state_kit_arms_persistent_and_reaps_on_aura_end() {
     let mut app = App::new();
     app.add_plugins(MinimalPlugins);
     app.add_message::<SpellKitFx>();
-    // The watcher's other fan-out: the kit's CharProc edges (`crate::aura_visual`). Food's kit 409
-    // carries none, so nothing is asserted here — the message just has to exist for the writer.
+    // The watcher's other fan-outs: the kit's CharProc edges (`crate::aura_visual`) and its
+    // sound leg (0852). Food's kit 409 carries neither, so nothing is asserted here — the
+    // messages just have to exist for the writers.
     app.add_message::<crate::aura_visual::AuraProc>();
+    app.add_message::<SpellKitSound>();
     app.init_resource::<FxLog>();
     app.insert_resource(SpellVisuals(SpellVisualCatalog::from_tables_with_paths(
         HashMap::from([(
diff --git a/crates/benilla/src/doodad_anim.rs b/crates/benilla/src/doodad_anim.rs
index e30a00a4..f0116733 100644
--- a/crates/benilla/src/doodad_anim.rs
+++ b/crates/benilla/src/doodad_anim.rs
@@ -258,14 +258,11 @@ pub(crate) struct DoodadAnimHost {
     pub fade: (f32, Vec3),
     /// The looping first-sequence graph node + its duration (secs); `None` on the gseq-only tier.
     pub clip: Option<(AnimationNodeIndex, f32)>,
-    /// `Time::elapsed_secs` at spawn — the [`GlobalSeqDrive`]'s clock origin. Global sequences run
-    /// on the free shared clock with no arm at all, so a resume re-seats them from this and phase
-    /// stays a pure function of the shared clock, never of pause history.
-    pub spawned_at: f32,
-    /// `Time::elapsed_secs` at the current **arm** — the player's clock origin, which is NOT
-    /// `spawned_at` any more: the variation re-arms every play-window, and a resume must seek to
-    /// `(now − armed_at) mod duration` or it lands at the phase of a clip this host stopped playing
-    /// several windows ago.
+    /// `Time::elapsed_secs` at the current **arm** — the player's clock origin: the variation
+    /// re-arms every play-window, and a resume must seek to `(now − armed_at) mod duration` or it
+    /// lands at the phase of a clip this host stopped playing several windows ago. (The
+    /// [`GlobalSeqDrive`] needs no origin at all — global sequences sample the shared world clock
+    /// directly, decision 0855.)
     pub armed_at: f32,
     /// When the armed play-window ends, on the shared clock — the reference's `windowHi`
     /// (`[model+0xac]`), rewritten by every arm. `now ≥ window_hi` ⇒ re-roll. A host is born with
@@ -421,7 +418,6 @@ fn gate_doodad_anim(
             continue;
         }
         host.active = drawn;
-        let t = now - host.spawned_at;
         if let Some(mut p) = player {
             if drawn {
                 if let Some((node, duration)) = host.clip {
@@ -442,10 +438,9 @@ fn gate_doodad_anim(
             }
         }
         if let Some(mut d) = drive {
+            // No re-seek on resume: the drive samples the shared world clock (decision 0855), so
+            // a re-appearing doodad lands on the phase the clock dictates by construction.
             d.set_paused(!drawn);
-            if drawn {
-                d.sync(t);
-            }
         }
     }
 }
@@ -493,6 +488,10 @@ pub(crate) struct MatAnim {
     /// the wearer's appear-fade and interior classifier rather than the world-model visibility
     /// authority's. See [`Self::resting`].
     unit_lane: bool,
+    /// The gseq factors' ATTACH anchor (secs on the shared clock): `None` until the first
+    /// [`sample_mat_anim`] pass stamps it — the reference snapshots the scene clock once per
+    /// model instance at attach (`CM2Model+0x68`, wow-re `gseq-anchor.md`; decisions 0856/0858).
+    gseq_attach: Option<f64>,
     /// The last sampled combined factor (colour-alpha × weight), read by the visibility authority.
     pub current: f32,
 }
@@ -503,7 +502,9 @@ impl MatAnim {
         now: f32,
         frozen: bool,
     ) -> Self {
-        let current = anim.sample(None, 0.0);
+        // The seed sample: both clocks at 0 — nothing armed, and the attach anchor (stamped on
+        // the first live pass) makes the gseq cursor open at 0 too.
+        let current = anim.sample(None, 0.0, 0.0);
         Self {
             anim,
             host: None,
@@ -512,6 +513,7 @@ impl MatAnim {
             frozen,
             drives_tag: false,
             unit_lane: false,
+            gseq_attach: None,
             current,
         }
     }
@@ -528,7 +530,7 @@ impl MatAnim {
         let mut m = Self::new(anim, now, false);
         m.drives_tag = true;
         m.seq = seq;
-        m.current = m.anim.sample(seq, 0.0);
+        m.current = m.anim.sample(seq, 0.0, 0.0);
         m
     }
 
@@ -606,6 +608,10 @@ pub(crate) fn sample_mat_anim(
     mut q: Query<&mut MatAnim>,
 ) {
     let now = time.elapsed_secs();
+    // The scene clock, full-precision (a long-uptime f32 elapsed drifts whole milliseconds,
+    // which a 433 ms twinkle shows): the base the per-instance gseq attach anchor subtracts
+    // from (0856).
+    let shared = time.elapsed_secs_f64();
     for mut m in &mut q {
         if m.frozen {
             continue;
@@ -625,7 +631,10 @@ pub(crate) fn sample_mat_anim(
             None if m.host.is_some() => (m.seq, 0.0),
             None => (m.seq, now - m.spawned_at),
         };
-        m.current = m.anim.sample(seq, elapsed);
+        // The instance's gseq cursor: sceneNow − attach, the anchor stamped on this first pass
+        // (decisions 0856/0858 — every lane, spell effects included: fresh instance per play).
+        let attach = *m.gseq_attach.get_or_insert(shared);
+        m.current = m.anim.sample(seq, elapsed, shared - attach);
     }
 }
 
@@ -633,9 +642,10 @@ pub(crate) fn sample_mat_anim(
 /// batch material carrying a texture-transform translation loop, keyed by material asset id.
 /// [`tick_anim_materials`] re-samples a *drawn* entry's offset into the material's `sun_scale.zw`
 /// each frame — one shared uniform per material, so every instance of a model batch scrolls in
-/// phase. Exactly faithful for gseq loops (the reference's free-running shared clock); a recorded,
-/// invisible divergence for seq-band loops (the reference phases those per instance at arm time —
-/// meaningless for a seamless scroll). Entries drop when the material asset does.
+/// phase. A recorded, invisible divergence for BOTH clock laws (0856): the reference phases a
+/// seq-band loop per play (arm cursor) and a gseq loop per instance (attach anchor,
+/// `gseq-anchor.md`), but one uniform per material cannot phase per instance — meaningless for a
+/// seamless scroll either way. Entries drop when the material asset does.
 #[derive(Resource, Default)]
 pub(crate) struct UvAnimMaterials(
     pub  std::collections::HashMap<
@@ -860,6 +870,7 @@ mod tests {
             period: 0.0,
             step: true,
             wrap: true, // period 0: a constant has no clock
+            gseq: false,
             keys: vec![(0.0, 0.0)],
         };
         std::sync::Arc::new(
@@ -1066,7 +1077,6 @@ mod tests {
                     meshes: Vec::new(),
                     fade: (1.0, Vec3::ZERO),
                     clip: None,
-                    spawned_at: 0.0,
                     armed_at: 0.0,
                     window_hi: f32::NEG_INFINITY,
                     anim_id: Some(0),
@@ -1154,7 +1164,6 @@ mod tests {
                     meshes: Vec::new(),
                     fade: (1.0, Vec3::ZERO),
                     clip: None,
-                    spawned_at: 0.0,
                     armed_at: 0.0,
                     window_hi: f32::NEG_INFINITY,
                     anim_id: None,
@@ -1225,7 +1234,7 @@ mod tests {
     }
 
     /// The draw gate stops the player + pauses the gseq drive when every submesh is hidden, and on
-    /// re-appearing re-arms at the shared-clock position (`(now − spawned_at) mod duration`) — the
+    /// re-appearing re-arms at the shared-clock position (`(now − armed_at) mod duration`) — the
     /// ref's clock-indexed pose, so pause history never desyncs phase.
     #[test]
     fn gate_pauses_hidden_and_resumes_on_the_shared_clock() {
@@ -1258,7 +1267,6 @@ mod tests {
                     meshes: vec![mesh],
                     fade: (1.0, Vec3::ZERO),
                     clip: Some((node, 2.0)),
-                    spawned_at: 0.0,
                     armed_at: 0.0,
                     // Far future: this test exercises the DRAW gate, so no window may expire
                     // under it and change the armed clip mid-assertion.
diff --git a/crates/benilla/src/entities/attach/dress.rs b/crates/benilla/src/entities/attach/dress.rs
index b44e4886..98314ab3 100644
--- a/crates/benilla/src/entities/attach/dress.rs
+++ b/crates/benilla/src/entities/attach/dress.rs
@@ -204,6 +204,9 @@ pub(super) fn spawn_part(
             material: mats.steady.clone(),
         },
         dress.object.clone(),
+        // The picker's triangles (decision 0857): the render meshes are `RENDER_WORLD`-only, so
+        // the ray pickers read the model's resident geometry instead.
+        crate::interact::PickMesh(part.geometry.clone()),
         DressedPart {
             index: index as u32,
             card: None,
@@ -332,6 +335,9 @@ fn spawn_billboard_part(
             blend: part.blend,
         },
         dress.object.clone(),
+        // The picker's triangles (decision 0857) — the caster centres a card at its pivot, the
+        // same bake the render form draws with.
+        crate::interact::PickMesh(part.geometry.clone()),
         card_follow,
     ));
     // A card takes its MODEL's indoor law through the same constructor as the sibling meshes it was
@@ -385,8 +391,10 @@ mod tests {
     fn part(char_slot: Option<CharSkinSlot>, two_sided: bool) -> EntityPart {
         EntityPart {
             mesh: Handle::default(),
+            geometry: std::sync::Arc::new(benilla_formats::RenderSubmesh::default()),
             aabb: None,
             skinned_mesh: None,
+            welded_billboard: false,
             material: mat(0),
             material_interior: None,
             material_interior_bake: None,
diff --git a/crates/benilla/src/entities/attach/redress.rs b/crates/benilla/src/entities/attach/redress.rs
index d16d7e0e..c1a99160 100644
--- a/crates/benilla/src/entities/attach/redress.rs
+++ b/crates/benilla/src/entities/attach/redress.rs
@@ -326,8 +326,10 @@ mod tests {
     fn part(geoset: u16) -> EntityPart {
         EntityPart {
             mesh: Handle::default(),
+            geometry: std::sync::Arc::new(benilla_formats::RenderSubmesh::default()),
             aabb: None,
             skinned_mesh: None,
+            welded_billboard: false,
             material: Handle::default(),
             material_interior: None,
             material_interior_bake: None,
diff --git a/crates/benilla/src/entities/display.rs b/crates/benilla/src/entities/display.rs
index f0997ef7..6d31015d 100644
--- a/crates/benilla/src/entities/display.rs
+++ b/crates/benilla/src/entities/display.rs
@@ -33,6 +33,11 @@ pub(super) enum ModelHandle {
 /// loader).
 pub(super) struct EntityPart {
     pub(super) mesh: Handle<Mesh>,
+    /// The batch's decoded geometry — the model's resident CPU copy (`ModelSubmesh::geometry`),
+    /// cloned onto every spawned part/card as [`crate::interact::PickMesh`] so the ray pickers read
+    /// triangles from here: the static render form is `RENDER_WORLD`-only (decision 0834), so no
+    /// main-world mesh data exists to ray-cast (decision 0857).
+    pub(super) geometry: std::sync::Arc<benilla_formats::RenderSubmesh>,
     /// The static form's build-time `Aabb` (decision 0834): the static mesh is `RENDER_WORLD`-only,
     /// so a consumer that used to compute a bound from its main-world data (the attach path's
     /// picker-volume fallback) reads this instead. `None` for degenerate geometry.
@@ -104,6 +109,12 @@ pub(super) struct EntityPart {
     /// owned by the billboard system (a following [`crate::billboard::BillboardCard`], decision
     /// 0153: the brazier/torch "glow on the ground" family). `None` for ordinary geometry.
     pub(super) billboard: Option<benilla_assets::BillboardInfo>,
+    /// This part's geometry is **welded** to a billboard bone the card split refused
+    /// ([`benilla_formats::RenderSubmesh::welded_billboard`], decision 0839): a shoulder flap whose
+    /// root ring is half-weighted to the plate and whose tip swings to the camera. It draws right
+    /// only through a joint palette, which is why a display carrying one makes even the **item**
+    /// lane rig ([`DisplayModel::welds_billboard`], decision 0841). `false` for every ordinary part.
+    pub(super) welded_billboard: bool,
     /// The part's animated material-alpha loops (colour-alpha × transparency-weight, decision 0130
     /// phase 2, per-sequence since 0641). The **effect lane** ([`super::spell_fx`]) samples them
     /// per instance on its armed slot; the unit/GameObject lane follows the host's live playing
@@ -223,6 +234,20 @@ pub(super) struct DisplayModel {
     pub(super) is_character_body: bool,
 }
 
+impl DisplayModel {
+    /// Does any built part weld geometry to a billboard bone
+    /// ([`EntityPart::welded_billboard`], decision 0839)? Such a part has no correct rigid
+    /// placement — the reference blends it per vertex — so the lane that draws it must run a joint
+    /// palette even where it otherwise wouldn't. The rigged lanes always do; this is the gate that
+    /// makes the **item** lane rig for the seven shoulder models that need it (decision 0841).
+    /// `false` while the model is still loading, and for the other 9684 models in the game.
+    pub(super) fn welds_billboard(&self) -> bool {
+        self.parts
+            .as_ref()
+            .is_some_and(|p| p.iter().any(|part| part.welded_billboard))
+    }
+}
+
 /// Resolve a creature display id to a [`DisplayModel`]: load its M2 (no skins — the slots are filled at
 /// build time from `textures`). A missing/zero-scale display gets an empty model → cube fallback.
 pub(super) fn new_creature_display(
@@ -421,6 +446,11 @@ pub(super) fn build_parts(
                         dm.object_texture.as_deref(),
                         asset_server,
                     );
+                    // The authored batch order (index + 1), into every variant's transparent sort
+                    // bias — one model's coplanar transparent batches (the Naxx items' Mod2x
+                    // sheen + Blend overlay) draw in file order instead of re-flipping a sort tie
+                    // every frame (`model_render::BATCH_ORDER_SORT_EPS`).
+                    let order = u16::try_from(pi + 1).unwrap_or(u16::MAX);
                     let exterior = model_material(
                         cache,
                         materials,
@@ -440,7 +470,7 @@ pub(super) fn build_parts(
                         // (the MCSH sample at their feet) rides the per-instance MeshTag shade byte
                         // (`entity_shade`), not the shared material.
                         ShadeSel::Lit,
-                        0,
+                        order,
                         None, // entities/portrait paths: UV anim deferred (0130 scope = placed doodads)
                         sub.rgb_anim.as_ref(), // animated M2Color tint, seeded at its first key
                         None, // entity M2: light selection anchors at the instance origin
@@ -496,7 +526,7 @@ pub(super) fn build_parts(
                             sub.no_depth_test,
                             sub.fog_policy,
                             ShadeSel::Lit, // matches the exterior variant above
-                            0,
+                            order,
                             None, // entities/portrait paths: UV anim deferred (0130 scope = placed doodads)
                             sub.rgb_anim.as_ref(),
                             None, // entity M2 fade twin: same instance-origin anchor
@@ -526,7 +556,7 @@ pub(super) fn build_parts(
                         sub.no_depth_test,
                         sub.fog_policy,
                         ShadeSel::Matte, // unread on the probe lane
-                        0,
+                        order,
                         None,
                         sub.rgb_anim.as_ref(),
                         None,
@@ -560,7 +590,7 @@ pub(super) fn build_parts(
                                 sub.no_depth_test,
                                 sub.fog_policy,
                                 ShadeSel::Matte, // unread on the probe lane
-                                0,
+                                order,
                                 None,
                                 sub.rgb_anim.as_ref(),
                                 None,
@@ -589,7 +619,7 @@ pub(super) fn build_parts(
                         sub.no_depth_test,
                         sub.fog_policy,
                         ShadeSel::Matte, // sun ×1.0, the forced indoor intensity — const so it dedups
-                        0,
+                        order,
                         None, // entities/portrait paths: UV anim deferred (0130 scope = placed doodads)
                         sub.rgb_anim.as_ref(),
                         None, // entity M2 interior variant: same instance-origin anchor
@@ -604,6 +634,7 @@ pub(super) fn build_parts(
                             .get(pi)
                             .map(|(h, _)| h.clone())
                             .unwrap_or_default(),
+                        geometry: sub.geometry.clone(),
                         aabb: stat_forms.get(pi).and_then(|(_, a)| *a),
                         skinned_mesh: skin_forms.get(pi).cloned(),
                         material: exterior,
@@ -618,6 +649,7 @@ pub(super) fn build_parts(
                         geoset_id: sub.geoset_id,
                         char_slot: sub.char_slot,
                         billboard: sub.billboard.clone(),
+                        welded_billboard: sub.geometry.welded_billboard,
                         alpha_anim: sub.alpha_anim.clone(),
                         rgb_anim: sub.rgb_anim.clone(),
                         ground_quad: sub.ground_quad,
@@ -647,6 +679,7 @@ pub(super) fn build_parts(
                         .get(pi)
                         .map(|(h, _)| h.clone())
                         .unwrap_or_default(),
+                    geometry: sub.geometry.clone(),
                     aabb: stat_forms.get(pi).and_then(|(_, a)| *a),
                     geoset_id: sub.geoset_id, // 0 for WMO — no geoset selection
                     char_slot: None,          // WMO is never a character body
@@ -682,8 +715,9 @@ pub(super) fn build_parts(
                     blend: sub.blend,
                     additive: false, // WMO MOMT carries no additive mode (`RenderSubmesh::additive`)
                     two_sided: sub.two_sided,
-                    billboard: None,  // WMO groups have no billboard bones
-                    alpha_anim: None, // …nor colour/weight loops
+                    billboard: None,         // WMO groups have no billboard bones
+                    welded_billboard: false, // …so nothing can be welded to one
+                    alpha_anim: None,        // …nor colour/weight loops
                     rgb_anim: None,
                     ground_quad: None, // the fx decal lane is M2-only
                 })
diff --git a/crates/benilla/src/entities/equipment/spawn.rs b/crates/benilla/src/entities/equipment/spawn.rs
index 26c22abc..6e951c7e 100644
--- a/crates/benilla/src/entities/equipment/spawn.rs
+++ b/crates/benilla/src/entities/equipment/spawn.rs
@@ -131,12 +131,16 @@ pub(in crate::entities) fn attach_held_items(
         // wearer's body tint reaches its helm, shoulders and held items (decision 0812 — the
         // reference's attached models inherit the parent CM2's computed colours, `0x714000`). Never
         // used to SKIN those parts: they draw the static mesh, and the vertex stage's slot read is
-        // gated on the mesh's own joint attributes — an item model spawns no rig at all (0847).
+        // gated on the mesh's own joint attributes. The one exception is an item that rigs itself
+        // (0841) — it carries its own slot instead, and inherits the tint up the `ParentModel` chain.
         Option<&crate::rig_palette::RigSkin>,
     )>,
     held: Option<Res<ItemDisplays>>,
     time: Res<Time>,
     mut seats: SeatWriters,
+    // An item model normally spawns no rig — but a display that welds geometry to a billboard bone
+    // has no correct rigid placement, so its spawn allocates a palette slot of its own (0841).
+    mut palettes: ResMut<crate::rig_palette::RigPalettes>,
 ) {
     let Some(held) = held else {
         return;
@@ -223,7 +227,9 @@ pub(in crate::entities) fn attach_held_items(
             if let Some(old) = root.take() {
                 commands.entity(old).despawn();
             }
-            *root = wants.and_then(|hs| spawn_slot(&mut commands, &ctx, &held, slot_idx, &hs));
+            *root = wants.and_then(|hs| {
+                spawn_slot(&mut commands, &mut palettes, &ctx, &held, slot_idx, &hs)
+            });
         }
         let applied = HeldAttached {
             applied: next,
@@ -243,6 +249,7 @@ pub(in crate::entities) fn attach_held_items(
 /// the ribbons. `None` when the display has no built parts or the body has no such attach point.
 fn spawn_slot(
     commands: &mut Commands,
+    palettes: &mut crate::rig_palette::RigPalettes,
     ctx: &WearerCtx,
     held: &ItemDisplays,
     slot_idx: usize,
@@ -301,15 +308,58 @@ fn spawn_slot(
             });
         }
     }
-    // **An item model spawns no rig** — including the seven displays whose geometry is welded to a
-    // billboard bone. 0841 gave those a joint palette so the reference's per-vertex blend would
-    // bend them; the director reported the result and the measurement backed them, so it was
-    // WITHDRAWN (decision 0847). The welded flap is a 0.29 yd spike hinged on a pivot that sits in
-    // the plate, and a spherical billboard re-orients it outright — so for a wide band of camera
-    // angles it sweeps *through* the plate it is welded to, and the two opaque surfaces z-fight
-    // along a seam that moves with every step. Whole and still is the shipped look; the open
-    // question is 0847's, not a knob here.
-    let rig_tag = ctx.rig_tag;
+    // **The item rig** (decisions 0841, withdrawn by 0847, RESTORED by 0854) — the one case an
+    // attach model runs a joint palette. 0847 pulled it believing a spherical billboard swept the
+    // spikes through the plate; that was wrong (0853: the spikes run ALONG their bone, worst vertex
+    // 12° off axis, so the arc never existed), and the byte answer is that the reference billboards
+    // an attached model exactly as it does a standalone one (wow-re `billboard-bone-law.md` §6).
+    // A
+    // display whose geometry is WELDED to a billboard bone (`welds_billboard`: the R14 pauldron's
+    // two spikes, whose root rings are 50/50 with the plate) has no correct rigid placement at all;
+    // 0839 stopped tearing it into a card, which left it whole and *still*. The reference bends it
+    // by blending the billboard bone's camera-replaced palette row per vertex (`m2_vertex_skin`,
+    // `0x71a460`) — so we build exactly that: the joint hierarchy, a palette slot, and the
+    // [`crate::billboard::BillboardJointRig`] that rewrites the billboard joints' world rotations.
+    //
+    // Nothing else about the item lane's "rests at bind pose" law moves: no `AnimationPlayer`, no
+    // global-sequence drive — all seven affected models are **keyless** (`m2bones`: not one
+    // T/R/S key between them), so every non-billboard joint's palette row is the identity the
+    // static mesh already drew, and the emitters/lights/ribbons below keep riding `root`.
+    let item_rig = dm
+        .inverse_bindposes
+        .as_ref()
+        .filter(|_| dm.welds_billboard() && !dm.skeleton.joints.is_empty())
+        .and_then(|ibp| {
+            let joints = super::super::spawn_joints(commands, root, root, &dm.skeleton);
+            if let Some(bb) = crate::billboard::BillboardJointRig::new(&dm.skeleton, &joints, root)
+            {
+                commands.entity(root).insert(bb);
+            }
+            // Slot 0 (table full, warned once) ⇒ no rig: the parts below fall back to the static
+            // mesh and the wearer's slot, i.e. exactly the pre-0841 look. Never a crash, never a
+            // missing shoulder.
+            let rig = crate::rig_palette::RigSkin::allocate(palettes, joints, ibp.clone())?;
+            let slot = rig.slot;
+            commands.entity(root).insert(rig);
+            // The lane is otherwise invisible from outside the renderer — seven models in 9691 take
+            // it, and a run where the gate silently stopped firing looks exactly like a run where
+            // nothing was equipped. Naming the slot is what lets a probe say which it was.
+            debug!(
+                "item rig: display {} welds a billboard bone → palette slot {slot} ({} bones)",
+                hs.display,
+                dm.skeleton.joints.len()
+            );
+            Some(slot)
+        });
+    // The instance slot every part below carries in its `MeshTag`. Normally the WEARER's — that is
+    // what puts a tinted body's colour on its helm, shoulders and held items (decision 0812). A
+    // rigged item must carry its OWN, because the vertex stage indexes the palette with the same
+    // field; the wearer's tint reaches it through the `ParentModel` chain instead, which is the
+    // reference's own route for an attached model's colours (`0x714000`, `aura_visual`).
+    let rig_tag = match item_rig {
+        Some(slot) => crate::mesh_tag::rig_bits(slot),
+        None => ctx.rig_tag,
+    };
     // Billboard batches (the torch's glow card) collected for the world-root card spawn
     // below — as plain children they'd render at the item root (the grip), not the
     // authored pivot (the torch head). Decision 0153.
@@ -326,17 +376,27 @@ fn spawn_slot(
             let set = item_fade_set(part);
             let effective = PartFade::resolve(joined, &set);
             let (init_mat, tag_alpha) = effective.seed(&set, now);
+            // A rigged item draws the SKINNED twin — every part of it, not only the welded batch:
+            // the model rests at bind pose, so each non-billboard bone's palette row is the
+            // identity and the other batches land pixel-for-pixel where the static mesh had them.
+            // The rig's absence (or a form that never built one) falls straight back to `mesh`.
+            let skinned = item_rig.and(part.skinned_mesh.as_ref());
             let mut child = parent.spawn((
-                Mesh3d(part.mesh.clone()),
+                Mesh3d(skinned.unwrap_or(&part.mesh).clone()),
                 MeshMaterial3d(init_mat),
                 Transform::default(),
                 ModelPart {
                     kind: ModelKind::Creature,
                     blend: part.blend,
                 },
+                // The picker's triangles (decision 0857): the `WOW_PICK` probe names worn gear
+                // through `ModelPart`, and the render meshes are `RENDER_WORLD`-only.
+                crate::interact::PickMesh(part.geometry.clone()),
                 // The portrait booth mirrors this rider ([`crate::portrait`]): steady
                 // material (not the fade twin) + where it sits, so the bake can seat it at
-                // the bone's bind-pose global (the booth spawns no skeleton).
+                // the bone's bind-pose global (the booth spawns no skeleton). It stays the
+                // STATIC mesh even for a rigged item — the booth has no palette to skin
+                // through, and bind pose is what it wants to bake anyway.
                 crate::portrait::PortraitRider {
                     static_mesh: part.mesh.clone(),
                     material: part.material.clone(),
@@ -344,6 +404,15 @@ fn spawn_slot(
                     offset,
                 },
             ));
+            if skinned.is_some() {
+                // The palette replaces this part's world matrix outright, so its model-local
+                // `Aabb` below is not the volume it draws in — the same reason the effect lane's
+                // skinned parts opt out (`spell_fx`). Seven models' worth of always-drawn parts.
+                child.insert((
+                    crate::rig_palette::RigPart(root),
+                    bevy::camera::visibility::NoFrustumCulling,
+                ));
+            }
             // Interior-light parity with the body: both material variants + a MeshTag, so the
             // classifier relights the weapon inside a WMO room like it does its wielder. While
             // joining the unit's appear-fade the tag carries its alpha instead — the classifier
@@ -365,8 +434,10 @@ fn spawn_slot(
             // is the same light-collector aliasing the comment above describes.
             child.insert(MeshTag(rig_tag | crate::mesh_tag::alpha_bits(tag_alpha)));
             // The item part's build-time bound (decision 0834): `calculate_bounds` can no longer
-            // derive one from the `RENDER_WORLD`-only static form's data.
-            if let Some(aabb) = part.aabb {
+            // derive one from the `RENDER_WORLD`-only static form's data. Skipped for a skinned
+            // part — it opted out of the frustum cull above, and a stale bound would only mislead
+            // the picker volume that reads it.
+            if let (None, Some(aabb)) = (skinned, part.aabb) {
                 child.insert(aabb);
             }
             if let Some(lit) = part_interior_lit(
@@ -430,6 +501,8 @@ fn spawn_slot(
                 kind: ModelKind::Creature,
                 blend: part.blend,
             },
+            // The picker's triangles (decision 0857), pivot-centred by the caster like the bake.
+            crate::interact::PickMesh(part.geometry.clone()),
             BillboardCard::following(&info, root),
         ));
         // The card's build-time bound (decision 0834) — same rule as its mesh siblings above.
@@ -592,8 +665,10 @@ mod tests {
     fn part(interior: bool) -> EntityPart {
         EntityPart {
             mesh: Handle::default(),
+            geometry: std::sync::Arc::new(benilla_formats::RenderSubmesh::default()),
             aabb: None,
             skinned_mesh: None,
+            welded_billboard: false,
             material: Handle::default(),
             material_interior: interior.then(Handle::default),
             material_interior_bake: None,
@@ -621,11 +696,11 @@ mod tests {
         )
     }
 
-    /// Spawn a wearer with one SHOULDER slot whose display carries **everything a rig would need** —
-    /// a billboard-bearing skeleton, bind poses, and a skinned mesh form distinct from the static one
-    /// — and run the attach. Returns the part tags, the wearer's own instance slot, the item root's
-    /// palette slot (`None` when it spawned no rig, which is the law), and the mesh the part drew.
-    fn attach_a_shoulder() -> (Vec<u32>, u16, Option<u16>, Option<Handle<Mesh>>) {
+    /// Spawn a wearer with one SHOULDER slot whose display optionally welds geometry to a billboard
+    /// bone (decision 0841), and run the attach. Returns the part tags, the wearer's own instance
+    /// slot, the item root's palette slot (`None` when it spawned no rig), and the mesh the part
+    /// actually drew with.
+    fn attach_a_shoulder(welded: bool) -> (Vec<u32>, u16, Option<u16>, Option<Handle<Mesh>>) {
         const KIND: ItemModelKind = ItemModelKind::ShoulderLeft;
         let mut app = App::new();
         app.add_plugins(MinimalPlugins);
@@ -635,6 +710,7 @@ mod tests {
         );
         let mut dm = empty_display();
         let mut p = part(false);
+        p.welded_billboard = welded;
         p.skinned_mesh = Some(skinned_handle());
         dm.parts = Some(vec![p]);
         // The shoulder's own skeleton: a root plus one spherical-billboard spike, the shape
@@ -711,6 +787,11 @@ mod tests {
         (tags, wearer_slot, item_rig, mesh)
     }
 
+    /// The welded case, named for the assertion that reads it.
+    fn attach_a_welded_shoulder() -> (Vec<u32>, u16, Option<u16>, Option<Handle<Mesh>>) {
+        attach_a_shoulder(true)
+    }
+
     /// Spawn a wearer with one helm slot and run the attach. Returns the spawned parts' tags plus the
     /// wearer's own instance slot (`0` when `rigged` is false — a boneless wearer).
     fn attach_a_helm(rigged: bool, interior: bool) -> (Vec<u32>, u16) {
@@ -807,33 +888,47 @@ mod tests {
         assert_eq!(crate::mesh_tag::rig_of(tags[0]), 0);
     }
 
-    /// **The item lane spawns no rig (decision 0847).** 0841 gave the seven displays that weld
-    /// geometry to a billboard bone a joint palette, so the reference's per-vertex blend would bend
-    /// the flap; the director reported the result and the measurement backed them — the flap is a
-    /// 0.29 yd spike hinged on a pivot inside the plate, so a spherical billboard sweeps it *through*
-    /// the plate and the two opaque surfaces z-fight along a seam that moves with every step. It was
-    /// withdrawn, and the lane no longer consults weldedness at all.
+    /// **The item rig (decision 0841, restored by 0854).** A display whose geometry is welded to a
+    /// billboard bone has no correct rigid placement — 0839 stopped tearing it into a card, leaving
+    /// it whole and still. Such an item spawns a rig of its own, and the three things that makes
+    /// true are asserted together because any one of them alone is a silent no-op: the part draws
+    /// the **skinned** twin (a static mesh is never skinned — `WOW_RIG_SKIN` compiles off the vertex
+    /// layout, not the tag), it carries its OWN palette slot rather than the wearer's, and the root
+    /// really holds the `RigSkin` that slot belongs to.
     ///
-    /// Pinned on the input that used to trip it: a display carrying a billboard-bearing skeleton,
-    /// bind poses and a skinned mesh form still allocates **no** palette slot, keeps its WEARER's
-    /// instance slot (0812's tint route) and draws the **static** mesh. A re-land has to delete this
-    /// test, which is the point — 0847's open fidelity question gets answered first, rather than
-    /// rediscovered from a bug report.
+    /// 0847 withdrew this and pinned the withdrawal with the mirror of this test; both are gone
+    /// again. The withdrawal's premise — a spherical billboard sweeping the spikes through the
+    /// plate — was refuted at the geometry (0853) and at the bytes (wow-re
+    /// `billboard-bone-law.md` §6), and
+    /// [`crate::billboard::tests::a_spike_along_its_bone_axis_points_screen_down_from_every_angle`]
+    /// is the standing guard that the arc stays absent in our own basis.
     #[test]
-    fn an_item_spawns_no_rig_even_with_everything_one_would_need() {
-        let (tags, wearer_slot, item_rig, mesh) = attach_a_shoulder();
+    fn a_welded_billboard_item_spawns_its_own_rig() {
+        let (tags, wearer_slot, item_rig, mesh) = attach_a_welded_shoulder();
+        let item_slot = item_rig.expect("the welded display allocates a palette slot");
         assert!(wearer_slot >= 1, "the wearer really has a rig of its own");
-        assert!(
-            item_rig.is_none(),
-            "no palette slot is allocated for an item"
+        assert_ne!(
+            item_slot, wearer_slot,
+            "the item's palette is not the wearer's"
         );
         assert_eq!(tags.len(), 1);
         assert_eq!(
             crate::mesh_tag::rig_of(tags[0]),
-            wearer_slot,
-            "the part indexes the WEARER's slot"
+            item_slot,
+            "the part indexes the ITEM's palette, not the body's"
         );
-        assert_eq!(mesh, Some(Handle::default()), "…and draws the static mesh");
+        assert_eq!(mesh, Some(skinned_handle()), "…and draws the skinned twin");
+    }
+
+    /// The counter-anchor, on the same harness: an ordinary item — the 9684 models that weld
+    /// nothing — spawns no rig, keeps the wearer's slot (0812's tint route) and keeps the static
+    /// mesh. If the gate ever widened, this is what would start allocating a palette per torch.
+    #[test]
+    fn an_ordinary_item_still_spawns_no_rig() {
+        let (tags, wearer_slot, item_rig, mesh) = attach_a_shoulder(false);
+        assert!(item_rig.is_none(), "no palette slot for a rigid item");
+        assert_eq!(crate::mesh_tag::rig_of(tags[0]), wearer_slot);
+        assert_eq!(mesh, Some(Handle::default()), "the static mesh, as before");
     }
 
     /// **What a booth can see of an equipped item** (decision 0822, `#bugs` B118's paper-doll half).
@@ -956,6 +1051,7 @@ mod tests {
                 period: 0.0,
                 step: false,
                 wrap: true,
+                gseq: false,
                 keys: vec![(0.0, 0.3)],
             }),
         }])
diff --git a/crates/benilla/src/entities/spell_fx.rs b/crates/benilla/src/entities/spell_fx.rs
index 266ea48a..641e4c51 100644
--- a/crates/benilla/src/entities/spell_fx.rs
+++ b/crates/benilla/src/entities/spell_fx.rs
@@ -436,6 +436,9 @@ pub(super) fn attach_effect_visuals(
                     kind: ModelKind::Creature,
                     blend: part.blend,
                 },
+                // The picker's triangles (decision 0857): the probe names fx batches through
+                // `ModelPart`, and the render meshes are `RENDER_WORLD`-only.
+                crate::interact::PickMesh(part.geometry.clone()),
             ));
             if let (true, Some(_)) = (rigged, &part.skinned_mesh) {
                 child.insert((
@@ -479,6 +482,8 @@ pub(super) fn attach_effect_visuals(
                 kind: ModelKind::Creature,
                 blend: part.blend,
             },
+            // The picker's triangles (decision 0857), pivot-centred by the caster like the bake.
+            crate::interact::PickMesh(part.geometry.clone()),
             card,
         ));
         // The card's build-time bound (decision 0834): `calculate_bounds` can no longer derive
@@ -564,11 +569,9 @@ pub(super) fn attach_effect_visuals(
                 alpha: Some(root),
             },
             // The effect's rig arms ONE clip; the emitters' rate/enabled windows ride that slot
-            // (a missile's InFlight is not file-order-first), on the instance's own spawn clock.
-            played_seq.map_or(
-                particles::EmitClock::Pinned,
-                particles::EmitClock::PinnedSeq,
-            ),
+            // (a missile's InFlight is not file-order-first) on the spawn clock, and gseq loops
+            // ride the pooled scene clock (0856).
+            particles::EmitClock::Effect(played_seq),
         );
     }
     // The same pick, as an `AnimationData` id — the ribbons' per-sequence visibility keys off it,
@@ -643,6 +646,9 @@ pub(super) fn arm_effect_rig(
         }
         if let Some(drive) = crate::creature_anim::GlobalSeqDrive::new(&anims.global_bones, &joints)
         {
+            // Fresh anchor per play — the byte-verified effect lifecycle (0858): CreateModel
+            // always allocates+attaches, so every cast's gseq loops open at phase 0, exactly
+            // like the ref (the director's 3-cast trace: the flash at +16 frames every time).
             commands.entity(root).insert(drive);
         }
     }
diff --git a/crates/benilla/src/interact.rs b/crates/benilla/src/interact.rs
index 3755f91a..fee192ad 100644
--- a/crates/benilla/src/interact.rs
+++ b/crates/benilla/src/interact.rs
@@ -24,7 +24,8 @@
 //! Picking only runs while [`InspectMode`] is on (today's sole consumer, driven by the inspector
 //! chord); when real player-facing consumers arrive it simply runs whenever any of them is active.
 
-use bevy::picking::mesh_picking::ray_cast::{MeshRayCast, MeshRayCastSettings, RayCastVisibility};
+use benilla_assets::coords::wow_to_bevy;
+use bevy::camera::primitives::Aabb;
 use bevy::platform::collections::HashSet;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
@@ -37,6 +38,40 @@ use crate::ui_script::PointerOverUi;
 
 mod journal;
 
+/// The resident **pick geometry** of one drawn batch: the model's decoded `RenderSubmesh`, `Arc`-shared
+/// with the model asset itself (decision 0857). The render forms are `RENDER_WORLD`-only since 0834 —
+/// their main-world vertex data is gone after extract, which is why Bevy's `MeshRayCast` silently
+/// stopped hitting every static model (the GO hover, the inspector, `WOW_PICK`). So the pickers read
+/// triangles from THIS instead, through the same WoW→Bevy bake the render form was built with
+/// (`submesh_to_static_mesh`: `wow_to_bevy` per vertex, billboard cards centred at their pivot).
+/// Attached beside `Mesh3d` at every spawn site that also attaches a pick key ([`WorldObject`] /
+/// `ModelPart`); a keyed entity without one (the model-less cube fallback) is picked by its `Aabb`.
+#[derive(Component, Clone)]
+pub struct PickMesh(pub std::sync::Arc<benilla_formats::RenderSubmesh>);
+
+/// One triangle-accurate hit from [`cast_pick_ray`]: the world-space point, the hit triangle's
+/// geometric normal (two-sided — the orientation is the authored winding's), and the distance along
+/// the ray.
+pub struct RayHit {
+    pub point: Vec3,
+    pub normal: Vec3,
+    pub distance: f32,
+}
+
+/// The one query every mesh picker casts against: a part's resident geometry, its world pose, the
+/// render world's own visibility verdict (the cast honours it, as `RayCastVisibility::VisibleInView`
+/// did), and its bound for the broad phase.
+pub type PickParts<'w, 's> = Query<
+    'w,
+    's,
+    (
+        Option<&'static PickMesh>,
+        &'static GlobalTransform,
+        &'static ViewVisibility,
+        Option<&'static Aabb>,
+    ),
+>;
+
 /// The identity of a pickable world thing, read by the inspector now and by tooltips/cursor/targeting
 /// later. Attached to a thing's renderable mesh entities at spawn.
 #[derive(Component, Clone)]
@@ -100,7 +135,7 @@ fn update_mouseover(
     window: Query<&Window, With<PrimaryWindow>>,
     camera: Query<(&Camera, &GlobalTransform), With<WorldCamera>>,
     objects: Query<Entity, With<WorldObject>>,
-    mut ray_cast: MeshRayCast,
+    parts: PickParts,
 ) {
     if !inspect.enabled {
         if target.entity.is_some() {
@@ -126,7 +161,7 @@ fn update_mouseover(
     };
     let identified: HashSet<Entity> = objects.iter().collect();
     if let Some((entity, point, distance)) =
-        pick_at_cursor(cursor, camera, cam_tf, &identified, &mut ray_cast)
+        pick_at_cursor(cursor, camera, cam_tf, &identified, &parts)
     {
         target.entity = Some(entity);
         target.point = point;
@@ -144,17 +179,179 @@ pub fn pick_at_cursor(
     camera: &Camera,
     cam_tf: &GlobalTransform,
     pickable: &HashSet<Entity>,
-    ray_cast: &mut MeshRayCast,
+    parts: &PickParts,
 ) -> Option<(Entity, Vec3, f32)> {
     let ray = camera.viewport_to_world(cam_tf, cursor).ok()?;
-    let filter = |e: Entity| pickable.contains(&e);
-    let settings = MeshRayCastSettings::default()
-        .with_visibility(RayCastVisibility::VisibleInView)
-        .with_filter(&filter);
-    ray_cast
-        .cast_ray(ray, &settings)
-        .first()
-        .map(|(e, hit)| (*e, hit.point, hit.distance))
+    cast_pick_ray(ray, pickable, parts, false)
+        .into_iter()
+        .next()
+        .map(|(e, hit)| (e, hit.point, hit.distance))
+}
+
+/// Cast `ray` against `pickable`'s **resident geometry** ([`PickMesh`] — decision 0857: the render
+/// meshes are `RENDER_WORLD`-only, so there is no main-world mesh data to cast against) and return
+/// the hits nearest-first: one per entity (its nearest triangle), the whole list with `all_hits`
+/// (the `WOW_PICK` probe's everything-along-the-ray reading) or just the front entity without.
+///
+/// Broad phase: a world-space slab test on each candidate's `Aabb` (entry distance), nearest entry
+/// first, so the narrow walk stops as soon as a confirmed hit is closer than every remaining box. A
+/// part with no bound (a `NoFrustumCulling` fx part) is narrow-tested unconditionally; a keyed
+/// entity with a bound but no [`PickMesh`] (the model-less cube fallback, whose cuboid *is* its
+/// box) takes its box entry as the hit. Triangles test **two-sided**, like the unit picker's narrow
+/// phase — a generous pick beats a strict one at silhouette edges.
+pub fn cast_pick_ray(
+    ray: Ray3d,
+    pickable: &HashSet<Entity>,
+    parts: &PickParts,
+    all_hits: bool,
+) -> Vec<(Entity, RayHit)> {
+    let (origin, dir) = (ray.origin, *ray.direction);
+    let mut candidates: Vec<(f32, Entity)> = Vec::new();
+    for &entity in pickable {
+        let Ok((mesh, gt, vis, aabb)) = parts.get(entity) else {
+            continue;
+        };
+        if !vis.get() {
+            continue; // not drawn in any view this frame — the old cast's VisibleInView rule
+        }
+        let entry = match (aabb, mesh) {
+            (Some(aabb), _) => {
+                let (min, max) = world_aabb(aabb, gt);
+                match ray_aabb(origin, dir, min, max) {
+                    Some(t) => t,
+                    None => continue,
+                }
+            }
+            (None, Some(_)) => 0.0,
+            (None, None) => continue,
+        };
+        candidates.push((entry, entity));
+    }
+    candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
+    let mut hits: Vec<(Entity, RayHit)> = Vec::new();
+    let mut best = f32::INFINITY;
+    for (entry, entity) in candidates {
+        if !all_hits && best < entry {
+            break; // every remaining box starts beyond the confirmed nearest hit
+        }
+        let Ok((mesh, gt, _, _)) = parts.get(entity) else {
+            continue;
+        };
+        let hit = match mesh {
+            Some(m) => ray_pick_mesh(m, gt, origin, dir),
+            // The cube fallback: its box entry is exactly its surface (the cuboid IS its Aabb).
+            None => Some(RayHit {
+                point: origin + dir * entry,
+                normal: -dir,
+                distance: entry,
+            }),
+        };
+        if let Some(h) = hit {
+            best = best.min(h.distance);
+            hits.push((entity, h));
+        }
+    }
+    hits.sort_unstable_by(|a, b| a.1.distance.total_cmp(&b.1.distance));
+    if !all_hits {
+        hits.truncate(1);
+    }
+    hits
+}
+
+/// The narrow phase for one part: ray-test every triangle of its resident geometry, in **model-local
+/// space** — the world ray mapped through the part's inverse affine, under which the ray parameter is
+/// unchanged, so a local `t` (against the world-normalized direction's image) *is* the world distance.
+/// Vertices go through the render form's own bake (`build_submesh_mesh`): `wow_to_bevy` per vertex,
+/// a billboard card centred at its pivot — so the pick tests exactly the surface the part draws
+/// (a card's live camera-facing rotation rides its `GlobalTransform`, shared here too).
+fn ray_pick_mesh(mesh: &PickMesh, gt: &GlobalTransform, origin: Vec3, dir: Vec3) -> Option<RayHit> {
+    let geo = &*mesh.0;
+    let inv = gt.affine().inverse();
+    let local_origin = inv.transform_point3(origin);
+    let local_dir = inv.transform_vector3(dir);
+    let center = geo
+        .billboard
+        .as_ref()
+        .map_or(Vec3::ZERO, |b| wow_to_bevy(b.pivot));
+    let pos = |i: u32| Some(wow_to_bevy(*geo.positions.get(i as usize)?) - center);
+    let mut nearest: Option<(f32, [Vec3; 3])> = None;
+    for t in geo.indices.chunks_exact(3) {
+        let (Some(a), Some(b), Some(c)) = (pos(t[0]), pos(t[1]), pos(t[2])) else {
+            continue; // an out-of-range index — corrupt authoring; skip the triangle, not the model
+        };
+        let tri = [a, b, c];
+        if let Some(d) = ray_triangle(local_origin, local_dir, &tri) {
+            if nearest.is_none_or(|(nd, _)| d < nd) {
+                nearest = Some((d, tri));
+            }
+        }
+    }
+    let (t, tri) = nearest?;
+    let world = tri.map(|v| gt.transform_point(v));
+    let normal = (world[1] - world[0])
+        .cross(world[2] - world[0])
+        .normalize_or_zero();
+    Some(RayHit {
+        point: origin + dir * t,
+        normal,
+        distance: t,
+    })
+}
+
+/// Ray–triangle intersection (Möller–Trumbore), **two-sided**, returning `t ≥ 0` along `dir`
+/// (unnormalized is fine — `t` is in `dir` lengths) or `None` on miss/parallel. Two-sided because a
+/// posed mesh can present back faces at silhouette edges and a generous pick beats a strict one.
+pub(crate) fn ray_triangle(origin: Vec3, dir: Vec3, tri: &[Vec3; 3]) -> Option<f32> {
+    let (e1, e2) = (tri[1] - tri[0], tri[2] - tri[0]);
+    let p = dir.cross(e2);
+    let det = e1.dot(p);
+    if det.abs() < 1e-8 {
+        return None;
+    }
+    let inv = 1.0 / det;
+    let s = origin - tri[0];
+    let u = s.dot(p) * inv;
+    if !(0.0..=1.0).contains(&u) {
+        return None;
+    }
+    let q = s.cross(e1);
+    let v = dir.dot(q) * inv;
+    if v < 0.0 || u + v > 1.0 {
+        return None;
+    }
+    let t = e2.dot(q) * inv;
+    (t >= 0.0).then_some(t)
+}
+
+/// A mesh's model-local [`Aabb`] transformed into a world-space axis-aligned box `(min, max)` — its 8
+/// corners run through the entity's world transform, then min/max'd. (An AABB of the rotated box: a hair
+/// larger than the true oriented box, which only makes the hover more forgiving.)
+pub(crate) fn world_aabb(aabb: &Aabb, gt: &GlobalTransform) -> (Vec3, Vec3) {
+    let center = Vec3::from(aabb.center);
+    let he = Vec3::from(aabb.half_extents);
+    let mut min = Vec3::splat(f32::INFINITY);
+    let mut max = Vec3::splat(f32::NEG_INFINITY);
+    for sx in [-1.0, 1.0] {
+        for sy in [-1.0, 1.0] {
+            for sz in [-1.0, 1.0] {
+                let world = gt.transform_point(center + he * Vec3::new(sx, sy, sz));
+                min = min.min(world);
+                max = max.max(world);
+            }
+        }
+    }
+    (min, max)
+}
+
+/// Ray vs axis-aligned box (the slab test): the entry distance along `dir` if the ray hits, else `None`.
+/// `dir` need not be normalized; a zero component is handled by the infinities `recip` produces.
+pub(crate) fn ray_aabb(origin: Vec3, dir: Vec3, min: Vec3, max: Vec3) -> Option<f32> {
+    let inv = dir.recip();
+    let t1 = (min - origin) * inv;
+    let t2 = (max - origin) * inv;
+    let tmin = t1.min(t2).max_element();
+    let tmax = t1.max(t2).min_element();
+    (tmax >= tmin.max(0.0)).then_some(tmin.max(0.0))
 }
 
 /// **Ctrl+Cmd+I** (for *inspect*) arms/disarms the inspector — the dev-instrument chord, off the
@@ -541,3 +738,92 @@ impl Plugin for InteractPlugin {
             .add_systems(EguiPrimaryContextPass, (inspect_ui, journal::journal_ui));
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use benilla_formats::RenderSubmesh;
+
+    const TRI: [Vec3; 3] = [
+        Vec3::new(-1.0, 0.0, -1.0),
+        Vec3::new(1.0, 0.0, -1.0),
+        Vec3::new(0.0, 0.0, 1.0),
+    ];
+
+    #[test]
+    fn ray_triangle_hits_at_the_right_distance() {
+        let t = ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::NEG_Y, &TRI).expect("hit");
+        assert!((t - 5.0).abs() < 1e-5);
+    }
+
+    #[test]
+    fn ray_triangle_is_two_sided() {
+        // Same triangle hit from below (reversed winding relative to the ray) still connects.
+        assert!(ray_triangle(Vec3::new(0.0, -5.0, 0.0), Vec3::Y, &TRI).is_some());
+    }
+
+    #[test]
+    fn ray_triangle_misses_outside_and_behind() {
+        // Outside the triangle's extent.
+        assert!(ray_triangle(Vec3::new(3.0, 5.0, 0.0), Vec3::NEG_Y, &TRI).is_none());
+        // Triangle behind the ray origin (t < 0).
+        assert!(ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::Y, &TRI).is_none());
+        // Parallel to the plane.
+        assert!(ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::X, &TRI).is_none());
+    }
+
+    /// [`TRI`]'s pre-image under `wow_to_bevy` (`bevy = (−y, z, −x)` ⇒ `wow = (−bz, −bx, by)`):
+    /// a submesh authored with THESE WoW-space positions must be picked exactly where the render
+    /// form draws it, i.e. at [`TRI`] in model-local Bevy space.
+    fn wow_tri() -> RenderSubmesh {
+        RenderSubmesh {
+            positions: vec![[1.0, 1.0, 0.0], [1.0, -1.0, 0.0], [-1.0, 0.0, 0.0]],
+            indices: vec![0, 1, 2],
+            ..Default::default()
+        }
+    }
+
+    /// The picker ↔ render-form bake contract (decision 0857): [`ray_pick_mesh`] must test the
+    /// resident WoW-axes geometry through the SAME `wow_to_bevy` bake `submesh_to_static_mesh`
+    /// builds the drawn mesh with, under the part's world transform — the render mesh itself is
+    /// `RENDER_WORLD`-only (0834), so this path is the only thing keeping static models pickable.
+    #[test]
+    fn resident_geometry_picks_where_the_render_form_draws() {
+        let mesh = PickMesh(std::sync::Arc::new(wow_tri()));
+        // A translated + uniformly scaled part: the triangle spans x∈[8,12], z∈[-2,2] at y=1.
+        let gt =
+            GlobalTransform::from(Transform::from_xyz(10.0, 1.0, 0.0).with_scale(Vec3::splat(2.0)));
+        let hit = ray_pick_mesh(&mesh, &gt, Vec3::new(10.0, 6.0, 0.0), Vec3::NEG_Y)
+            .expect("the baked triangle must be hit under its world transform");
+        assert!((hit.distance - 5.0).abs() < 1e-4);
+        assert!(hit.point.abs_diff_eq(Vec3::new(10.0, 1.0, 0.0), 1e-4));
+        assert!(hit.normal.abs_diff_eq(Vec3::Y, 1e-4) || hit.normal.abs_diff_eq(-Vec3::Y, 1e-4));
+        // …and a miss stays a miss.
+        assert!(ray_pick_mesh(&mesh, &gt, Vec3::new(20.0, 6.0, 0.0), Vec3::NEG_Y).is_none());
+    }
+
+    /// A billboard card's render form is centred at its pivot (`build_submesh_mesh`); the pick must
+    /// subtract the same pivot or it tests the card a whole pivot-offset away from where it draws.
+    #[test]
+    fn billboard_card_picks_pivot_centred() {
+        let mut sub = wow_tri();
+        // Pivot at WoW (0, 0, 3) → Bevy (0, 3, 0): the baked card shifts down 3 in model-local y.
+        sub.billboard = Some(benilla_formats::Billboard {
+            pivot: [0.0, 0.0, 3.0],
+            bone: 0,
+            kind: benilla_formats::BillboardKind::Spherical,
+            scale_anim: None,
+            seq_translations: Vec::new(),
+        });
+        let mesh = PickMesh(std::sync::Arc::new(sub));
+        // The card entity sits AT the pivot's world spot (the spawn sites bake
+        // `transform_point(pivot)` into its translation), so the authored triangle — 3 below the
+        // pivot in model-local Bevy y — draws at world y = 0: a straight-down ray from y = 8 hits
+        // at distance 8. Without the pivot subtraction it would (wrongly) hit at y = 3.
+        let gt = GlobalTransform::from(Transform::from_xyz(0.0, 3.0, 0.0));
+        let hit = ray_pick_mesh(&mesh, &gt, Vec3::new(0.0, 8.0, 0.0), Vec3::NEG_Y)
+            .expect("the pivot-centred card must be hit where it draws");
+        assert!((hit.distance - 8.0).abs() < 1e-4);
+        assert!(hit.point.abs_diff_eq(Vec3::ZERO, 1e-4));
+    }
+}
diff --git a/crates/benilla/src/model_render.rs b/crates/benilla/src/model_render.rs
index 9cc192d0..1de9a151 100644
--- a/crates/benilla/src/model_render.rs
+++ b/crates/benilla/src/model_render.rs
@@ -20,6 +20,22 @@ use crate::terrain::{WowModelExt, WowModelMaterial};
 /// Source: <https://wowdev.wiki/M2/Rendering> § Alpha Testing.
 pub const VANILLA_ALPHA_KEY_REF: f32 = 224.0 / 255.0;
 
+/// 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
+/// distance; positive = drawn later, the `sky_order` sign law). **Why it exists:** one model's
+/// coplanar transparent batches (the Naxx items' Opaque + Mod2x sheen + Blend overlay triples)
+/// share one mesh centre, so their sort distances TIE, and a tie is re-resolved every frame by
+/// whatever order the queue happens to iterate — in a churning scene (a city) the coplanar layers
+/// swap draw order frame to frame and the composite strobes (Mod2x-then-Blend ≠ Blend-then-Mod2x).
+/// The reference cannot express the bug: it ties every draw command of one instance to a single
+/// sort key and keeps the *authored command order* inside the tie (wow-re
+/// `m2-blend-promotion-zfill.md` §4/§6; MOBA file order for WMO). This epsilon reproduces that
+/// order through bevy's sort. Sized well under [`benilla_formats::owner_last_rung`]'s 1-yd floor
+/// (an effect still draws after every batch of its owner) and far over f32 noise on a ~500 yd
+/// sort distance (~4e-5). Not a pipeline axis: `depth_bias` participates in sorting only
+/// (`WowModelKey` deliberately excludes it — decision 0837).
+pub(crate) const BATCH_ORDER_SORT_EPS: f32 = 1e-3;
+
 /// Material-dedup key: same texture + blend + sidedness + kind + fade-variant → one shared material.
 #[derive(PartialEq, Eq, Hash)]
 pub(crate) struct MatKey {
@@ -40,10 +56,11 @@ pub(crate) struct MatKey {
     /// The batch's static terrain-shade selector ([`ShadeSel`]). Static per placement, so it dedups a
     /// lit / matte / shaded material variant.
     shade: ShadeSel,
-    /// WMO authored batch index + 1 (0 = non-WMO). Per-batch, so each biased batch is its own
-    /// pipeline variant — see `terrain::WowModelKey::wmo_batch_order` for the why (the byte-verified
-    /// MOBA draw-order determinism, wow-5875-re models/scratch/wmo-batch-blend-depth-state.md).
-    wmo_batch_order: u16,
+    /// Authored batch index + 1 (0 = a legacy/unordered caller). Every ordered batch (M2 and WMO)
+    /// folds it into the material's transparent SORT bias ([`BATCH_ORDER_SORT_EPS`]); WMO batches
+    /// additionally ride it into the vertex-stage clip-z nudge (the byte-verified MOBA draw-order
+    /// determinism, wow-5875-re models/scratch/wmo-batch-blend-depth-state.md).
+    batch_order: u16,
     /// The batch's UV-animation identity (decision 0130 phase 3): the `Arc<UvAnim>` pointer, so
     /// batches scrolling on different loops never share a material (their `sun_scale.zw` offsets
     /// diverge every frame) while every instance of the same model batch does. Sound because the
@@ -152,7 +169,9 @@ pub(crate) fn model_material(
     no_depth_test: bool,
     fog_policy: benilla_formats::FogPolicy,
     shade: ShadeSel,
-    wmo_batch_order: u16,
+    // Authored batch index + 1 (0 = unordered): the transparent-pass ORDER of this batch among its
+    // model's other batches — see [`MatKey::batch_order`] and [`BATCH_ORDER_SORT_EPS`].
+    batch_order: u16,
     uv_anim: Option<&std::sync::Arc<benilla_formats::UvAnim>>,
     rgb_anim: Option<&std::sync::Arc<benilla_formats::RgbAnim>>,
     // The WMO batch's MOBA section (`None` for M2 batches) — with `is_interior`, it picks the
@@ -177,7 +196,7 @@ pub(crate) fn model_material(
         no_depth_test,
         fog_policy,
         shade,
-        wmo_batch_order,
+        batch_order,
         uv_anim: uv_anim.map(|a| std::sync::Arc::as_ptr(a) as usize),
         rgb_anim: rgb_anim.map(|a| std::sync::Arc::as_ptr(a) as usize),
         wmo_class,
@@ -220,12 +239,16 @@ pub(crate) fn model_material(
     };
     // Single-sided unless the M2's 0x04 flag is set (many canopy planes are one-directional).
     let cull_mode = if two_sided { None } else { Some(Face::Back) };
+    // The authored batch order as a transparent sort bias ([`BATCH_ORDER_SORT_EPS`]): one model's
+    // coplanar batches draw in file order instead of re-flipping a sort tie every frame.
+    let depth_bias = f32::from(batch_order) * BATCH_ORDER_SORT_EPS;
     let base = match texture {
         Some(image) => StandardMaterial {
             base_color_texture: Some(image),
             alpha_mode,
             double_sided: two_sided,
             cull_mode,
+            depth_bias,
             ..default()
         },
         // No resolved texture → the reference DISABLES the texture stage and draws the batch in
@@ -239,6 +262,7 @@ pub(crate) fn model_material(
             alpha_mode,
             double_sided: two_sided,
             cull_mode,
+            depth_bias,
             ..default()
         },
     };
@@ -325,11 +349,15 @@ pub(crate) fn model_material(
             // shared clock (frozen in captures).
             sun_scale: {
                 let uv0 = uv_anim.map_or([0.0, 0.0], |a| a.sample(0.0));
-                let order = if matches!(std::env::var("WOW_WMO_BIAS").as_deref(), Ok("0")) {
-                    0.0
-                } else {
-                    f32::from(wmo_batch_order)
-                };
+                // The clip-z nudge stays WMO-only: M2 coplanar layers pass GreaterEqual at exactly
+                // equal depth (same mesh, same transform, same vertex path), and their ORDER is
+                // the sort bias above — nudging their depth would be an unverified extra.
+                let order =
+                    if !is_wmo || matches!(std::env::var("WOW_WMO_BIAS").as_deref(), Ok("0")) {
+                        0.0
+                    } else {
+                        f32::from(batch_order)
+                    };
                 Vec4::new(shade.selector(), order, uv0[0], uv0[1])
             },
             // The animated M2Color tint's first key (identity white for static batches — their
@@ -431,7 +459,7 @@ pub(crate) fn zfill_material(
         no_depth_test: false,
         fog_policy: benilla_formats::FogPolicy::Scene,
         shade: ShadeSel::Lit,
-        wmo_batch_order: 0,
+        batch_order: 0,
         uv_anim: None,
         rgb_anim: None,
         wmo_class: None,
@@ -534,4 +562,29 @@ mod tests {
         let out2 = replace_fog_policy(f32::from(0u16), FogPolicy::Grey) as u16;
         assert_eq!(out2, (FogPolicy::Grey as u16) << 4);
     }
+
+    /// The authored-batch-order sort epsilon sits in its working band: any realistic model's
+    /// last batch still biases UNDER the effect lane's owner-last rung floor (an item's glow
+    /// particles must draw after every batch of the item — 0719/0721), and one step is far above
+    /// f32 noise on a far-scene sort distance (~4e-5 at 500 yd), so the tie actually breaks.
+    /// Pins the constant against a careless resize in either direction — either end failing is
+    /// the Naxx-item strobe (coplanar layers re-flipping a sort tie every frame) or its dual
+    /// (effects interleaving into their owner's batches).
+    #[test]
+    fn batch_order_sort_eps_sits_between_f32_noise_and_the_effect_rung() {
+        // 512 batches is comfortably past any shipped model's batch table.
+        let deepest = super::BATCH_ORDER_SORT_EPS * 512.0;
+        assert!(
+            deepest < benilla_formats::owner_last_rung(0.0),
+            "a model's last batch must still sort before its own effects' rung"
+        );
+        let far_noise = 500.0_f32 * f32::EPSILON;
+        assert!(
+            super::BATCH_ORDER_SORT_EPS > 8.0 * far_noise,
+            "one order step must dominate f32 noise on a far sort distance"
+        );
+        // And bevy's pipeline key truncates it to 0 — the bias may never mint pipelines (0837):
+        // sub-1.0 biases all cast to the same i32 constant.
+        assert_eq!(deepest as i32, 0);
+    }
 }
diff --git a/crates/benilla/src/particles.rs b/crates/benilla/src/particles.rs
index 90ee980e..04b81805 100644
--- a/crates/benilla/src/particles.rs
+++ b/crates/benilla/src/particles.rs
@@ -549,7 +549,7 @@ pub fn spawn_emitter(
     }
     let (host, seq) = match clock {
         EmitClock::Pinned => (None, None),
-        EmitClock::PinnedSeq(s) => (None, Some(s)),
+        EmitClock::Effect(s) => (None, s),
         EmitClock::Host(h) => (Some(h), None),
     };
     // The owner's reach is model-local; the rung is a view-space distance, so it takes the
@@ -688,9 +688,10 @@ pub enum EmitClock {
     /// still correct there), the portrait booths, and any lane with no rig to ask.
     #[default]
     Pinned,
-    /// A fixed armed slot on the spawn-age clock — a spell effect's rig arms one clip at spawn
-    /// and the emitters ride it (a missile's InFlight is not file-order-first).
-    PinnedSeq(usize),
+    /// The SPELL-FX lane: the rig's armed slot (a missile's InFlight is not file-order-first;
+    /// `None` = slot 0) on the spawn-age clock, like every pinned lane — the effect instance is
+    /// byte-verified fresh per play (decision 0858), so its gseq loops open at phase 0 with it.
+    Effect(Option<usize>),
     /// A live host's `AnimationPlayer` decides the slot **and the clip time** each frame — units
     /// and GameObjects, whose playing sequence changes; the reference's `m2_animate` emitter
     /// phase samples the CURRENT sequence record (wow-re `part-emission-rate-animated.md` §2).
diff --git a/crates/benilla/src/particles/sim.rs b/crates/benilla/src/particles/sim.rs
index 3e15776f..a3a946f2 100644
--- a/crates/benilla/src/particles/sim.rs
+++ b/crates/benilla/src/particles/sim.rs
@@ -588,7 +588,10 @@ pub(super) fn simulate_particles(
         // wow-re `part-emission-rate-animated.md` §1). Frost Nova rides its emission radius
         // 0.19 → 13.2 yd out with the ring; Arcane Explosion 0 → 7.2 yd with the dome — births
         // MUST read the frame's values, not `value[0]` (decision 0844).
-        let now = def.params.sample(clock_seq, elapsed_s);
+        // The instance's gseq cursor (0856/0858): the spawn age IS `sceneNow − attach` — the
+        // emitter spawns with its instance, and every lane's instance is fresh per play.
+        let gseq_now = f64::from(*age);
+        let now = def.params.sample(clock_seq, elapsed_s, gseq_now);
 
         // 1. Age + integrate the live pool. The verified vanilla integrator (`particle_integrate`
         //    @ 0x7b2680): pos += dt·v with the gravity term on the UP axis (up += dt·v_up − ½·g·dt²;
@@ -643,8 +646,8 @@ pub(super) fn simulate_particles(
         //    one-shot effects' choreography (a 200 ms hand flash inside a 1.0 s clip; the impact
         //    model's six staggered windows). Live particles are untouched — they finish their
         //    lifespans exactly like the drain above.
-        let emitting = !*draining && def.timing.emitting(clock_seq, elapsed_s);
-        let rate = def.timing.rate(clock_seq, elapsed_s);
+        let emitting = !*draining && def.timing.emitting(clock_seq, elapsed_s, gseq_now);
+        let rate = def.timing.rate(clock_seq, elapsed_s, gseq_now);
         let dist_lod =
             (1.0 - (placement.translation.distance(e_cam_pos) - 50.0) * 0.02).clamp(0.25, 1.0);
         let burst = accumulate_emission(
@@ -759,9 +762,10 @@ pub(super) fn simulate_particles(
         //     A draining parent stops driving; child pools live out their spans (the despawn
         //     above waits for them).
         for child in children.iter_mut() {
-            let c_emitting = !*draining && child.def.timing.emitting(None, *age);
-            let c_rate = child.def.timing.rate(None, *age);
-            let c_now = child.def.params.sample(None, *age);
+            // A child cloud is its own fresh instance: its gseq cursor is its own age (0856).
+            let c_emitting = !*draining && child.def.timing.emitting(None, *age, f64::from(*age));
+            let c_rate = child.def.timing.rate(None, *age, f64::from(*age));
+            let c_now = child.def.params.sample(None, *age, f64::from(*age));
             drive_child(
                 child,
                 &c_now,
diff --git a/crates/benilla/src/portrait/booth.rs b/crates/benilla/src/portrait/booth.rs
index e6cb56cf..d76482cc 100644
--- a/crates/benilla/src/portrait/booth.rs
+++ b/crates/benilla/src/portrait/booth.rs
@@ -504,6 +504,7 @@ mod tests {
                     period: 0.0,
                     step: true,
                     wrap: true, // period 0: a constant has no clock
+                    gseq: false,
                     keys: vec![(0.0, v)],
                 }),
             }])
diff --git a/crates/benilla/src/sound/spell.rs b/crates/benilla/src/sound/spell.rs
index c79c1e61..6b2ffbce 100644
--- a/crates/benilla/src/sound/spell.rs
+++ b/crates/benilla/src/sound/spell.rs
@@ -43,9 +43,19 @@ fn route_spell_kit_sounds(
         return;
     };
     let listener = listener.pos;
+    // Same-drain dedup: the client rings a kit's sound once per PlaySpellVisualKit call, and a
+    // state kit is legitimately played twice in one packet burst (the impact hand-off's flash +
+    // the aura watcher's ADD edge — both real reference callers, 0852). One frame, one ring;
+    // plays in different frames (a missile impact preceding the aura by a beat) both ring, as
+    // the reference's two calls would.
+    let mut played_now: Vec<(Entity, u32)> = Vec::new();
     for ev in events.read() {
         match *ev {
             SpellKitSound::Play { entity, kit_sound } => {
+                if played_now.contains(&(entity, kit_sound)) {
+                    continue;
+                }
+                played_now.push((entity, kit_sound));
                 let pos = transforms.get(entity).map(|t| t.translation).ok();
                 let looping = kit_looping(&kits, kit_sound);
                 // The kit player is otherwise invisible in logs — this line is what a headless
@@ -90,6 +100,14 @@ fn route_spell_kit_sounds(
                     super::kit::stop_source_kit(&mut out, entity, kit_sound);
                 }
             }
+            SpellKitSound::StopKit { entity, kit_sound } => {
+                // Kit-scoped (an aura-drop reap, 0852): stop exactly this kit's channels; the
+                // ledger entry goes only if it is this kit, so an unrelated hold loop survives.
+                if hold_loops.get(&entity) == Some(&kit_sound) {
+                    hold_loops.remove(&entity);
+                }
+                super::kit::stop_source_kit(&mut out, entity, kit_sound);
+            }
         }
     }
 }
diff --git a/crates/benilla/src/target/hover.rs b/crates/benilla/src/target/hover.rs
index d3eb3fbc..31429256 100644
--- a/crates/benilla/src/target/hover.rs
+++ b/crates/benilla/src/target/hover.rs
@@ -11,14 +11,13 @@ use benilla_assets::ModelAnimations;
 use benilla_protocol::EntityKind;
 use bevy::camera::primitives::Aabb;
 use bevy::mesh::{Indices, VertexAttributeValues};
-use bevy::picking::mesh_picking::ray_cast::MeshRayCast;
 use bevy::prelude::*;
 use bevy::window::PrimaryWindow;
 
 use crate::collision::PickOccluder;
 use crate::creature_anim::AnimDriver;
 use crate::debug_panel::ModelKind;
-use crate::interact::WorldObject;
+use crate::interact::{ray_aabb, ray_triangle, world_aabb, PickParts, WorldObject};
 use crate::net::{Guid, NetEntity, ObjectStore, SelfPlayer};
 use crate::player::{CameraControl, WorldCamera};
 use crate::ui_script::PointerOverUi;
@@ -302,8 +301,9 @@ pub(super) fn update_hover(
 
 /// Recompute the **GameObject** under the cursor each frame into [`HoveredObject`] (decision 0236):
 /// a mesh-accurate ray pick against GameObject parts *only*, reusing the inspector's picker
-/// ([`crate::interact::pick_at_cursor`] — bevy `MeshRayCast`, which hits the colliderless props a
-/// physics ray misses). Kept separate from [`update_hover`]'s unit pick because a GameObject is
+/// ([`crate::interact::pick_at_cursor`] — the resident-geometry caster of decision 0857, which hits
+/// the colliderless props a physics ray misses and the `RENDER_WORLD`-only static forms Bevy's
+/// `MeshRayCast` lost at 0834). Kept separate from [`update_hover`]'s unit pick because a GameObject is
 /// usable-but-not-*selected*: this drives the Interact cursor and the right-click USE, never
 /// selection. Inert while mouse-looking (cursor hidden) or over the dev UI, exactly like the unit
 /// pick. Cheap — only the handful of GO parts on screen are in the pick set.
@@ -326,7 +326,7 @@ pub(super) fn update_hovered_object(
     // The faction term of eligibility (decision 0764): the GO's own template reaction toward us.
     factions: Option<Res<super::ring::Factions>>,
     self_q: Query<&ObjectStore, With<crate::net::SelfPlayer>>,
-    mut ray_cast: MeshRayCast,
+    parts: PickParts,
 ) {
     hovered.target = None;
     hovered.guid = None;
@@ -362,7 +362,7 @@ pub(super) fn update_hovered_object(
         return;
     }
     let Some((hit, _point, distance)) =
-        crate::interact::pick_at_cursor(cursor, camera, cam_tf, &pickable, &mut ray_cast)
+        crate::interact::pick_at_cursor(cursor, camera, cam_tf, &pickable, &parts)
     else {
         return;
     };
@@ -497,62 +497,6 @@ fn ray_posed_mesh(
     hits
 }
 
-/// Ray–triangle intersection (Möller–Trumbore), **two-sided**, returning `t ≥ 0` along `dir`
-/// (unnormalized is fine — `t` is in `dir` lengths) or `None` on miss/parallel. Two-sided because a
-/// posed mesh can present back faces at silhouette edges and a generous pick beats a strict one.
-fn ray_triangle(origin: Vec3, dir: Vec3, tri: &[Vec3; 3]) -> Option<f32> {
-    let (e1, e2) = (tri[1] - tri[0], tri[2] - tri[0]);
-    let p = dir.cross(e2);
-    let det = e1.dot(p);
-    if det.abs() < 1e-8 {
-        return None;
-    }
-    let inv = 1.0 / det;
-    let s = origin - tri[0];
-    let u = s.dot(p) * inv;
-    if !(0.0..=1.0).contains(&u) {
-        return None;
-    }
-    let q = s.cross(e1);
-    let v = dir.dot(q) * inv;
-    if v < 0.0 || u + v > 1.0 {
-        return None;
-    }
-    let t = e2.dot(q) * inv;
-    (t >= 0.0).then_some(t)
-}
-
-/// A mesh's model-local [`Aabb`] transformed into a world-space axis-aligned box `(min, max)` — its 8
-/// corners run through the entity's world transform, then min/max'd. (An AABB of the rotated box: a hair
-/// larger than the true oriented box, which only makes the hover more forgiving.)
-fn world_aabb(aabb: &Aabb, gt: &GlobalTransform) -> (Vec3, Vec3) {
-    let center = Vec3::from(aabb.center);
-    let he = Vec3::from(aabb.half_extents);
-    let mut min = Vec3::splat(f32::INFINITY);
-    let mut max = Vec3::splat(f32::NEG_INFINITY);
-    for sx in [-1.0, 1.0] {
-        for sy in [-1.0, 1.0] {
-            for sz in [-1.0, 1.0] {
-                let world = gt.transform_point(center + he * Vec3::new(sx, sy, sz));
-                min = min.min(world);
-                max = max.max(world);
-            }
-        }
-    }
-    (min, max)
-}
-
-/// Ray vs axis-aligned box (the slab test): the entry distance along `dir` if the ray hits, else `None`.
-/// `dir` need not be normalized; a zero component is handled by the infinities `recip` produces.
-fn ray_aabb(origin: Vec3, dir: Vec3, min: Vec3, max: Vec3) -> Option<f32> {
-    let inv = dir.recip();
-    let t1 = (min - origin) * inv;
-    let t2 = (max - origin) * inv;
-    let tmin = t1.min(t2).max_element();
-    let tmax = t1.max(t2).min_element();
-    (tmax >= tmin.max(0.0)).then_some(tmin.max(0.0))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -563,18 +507,6 @@ mod tests {
         Vec3::new(0.0, 0.0, 1.0),
     ];
 
-    #[test]
-    fn ray_triangle_hits_at_the_right_distance() {
-        let t = ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::NEG_Y, &TRI).expect("hit");
-        assert!((t - 5.0).abs() < 1e-5);
-    }
-
-    #[test]
-    fn ray_triangle_is_two_sided() {
-        // Same triangle hit from below (reversed winding relative to the ray) still connects.
-        assert!(ray_triangle(Vec3::new(0.0, -5.0, 0.0), Vec3::Y, &TRI).is_some());
-    }
-
     /// The picker ↔ mesh-builder attribute contract: `ray_posed_mesh` must read the WOW joint
     /// attributes the skinned twin is authored with ([`benilla_assets::ATTRIBUTE_WOW_JOINT_INDEX`],
     /// decision 0720) — reading Bevy's standard skin attributes made every unit silently
@@ -616,14 +548,4 @@ mod tests {
         .expect("the posed pick must hit the WOW-attributed mesh");
         assert!((t - 3.0).abs() < 1e-5);
     }
-
-    #[test]
-    fn ray_triangle_misses_outside_and_behind() {
-        // Outside the triangle's extent.
-        assert!(ray_triangle(Vec3::new(3.0, 5.0, 0.0), Vec3::NEG_Y, &TRI).is_none());
-        // Triangle behind the ray origin (t < 0).
-        assert!(ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::Y, &TRI).is_none());
-        // Parallel to the plane.
-        assert!(ray_triangle(Vec3::new(0.0, 5.0, 0.0), Vec3::X, &TRI).is_none());
-    }
 }
diff --git a/crates/benilla/src/terrain_stream/spawn/assemble.rs b/crates/benilla/src/terrain_stream/spawn/assemble.rs
index 426d1c5c..b83c7324 100644
--- a/crates/benilla/src/terrain_stream/spawn/assemble.rs
+++ b/crates/benilla/src/terrain_stream/spawn/assemble.rs
@@ -131,21 +131,20 @@ pub(crate) fn spawn_model_entities(
         out.push(h.root);
     }
     let mut skinned_meshes: Vec<Entity> = Vec::new();
-    for (wmo_batch_idx, sub) in submeshes.iter().enumerate() {
+    for (batch_idx, sub) in submeshes.iter().enumerate() {
         // The batch's app-built render form (decision 0834). Callers gate spawning on the forms
         // being complete, so a miss here is a broken contract — skip the batch rather than panic.
-        let Some((stat_mesh, stat_aabb)) = forms.stat.get(wmo_batch_idx) else {
+        let Some((stat_mesh, stat_aabb)) = forms.stat.get(batch_idx) else {
             continue;
         };
-        // WMO batches carry their authored order (index + 1; 0 = non-WMO) into the material so the
-        // pipeline can bias coplanar layers to resolve in MOBA file order — the byte-verified client
-        // behaviour (wow-5875-re models/scratch/wmo-batch-blend-depth-state.md). Every WMO batch gets
-        // it (the filmed farmhouse layers are OPAQUE batches, not blends). Doodads/M2 pass 0.
-        let wmo_batch_order = if is_wmo {
-            u16::try_from(wmo_batch_idx + 1).unwrap_or(u16::MAX)
-        } else {
-            0
-        };
+        // Every batch (WMO and M2) carries its authored order (index + 1) into the material's
+        // transparent sort bias, so one model's coplanar layers draw in file order instead of
+        // re-flipping a sort tie every frame (`model_render::BATCH_ORDER_SORT_EPS`). WMO batches
+        // additionally ride it into the clip-z nudge that resolves coplanar layers in MOBA file
+        // order — the byte-verified client behaviour (wow-5875-re
+        // models/scratch/wmo-batch-blend-depth-state.md); `model_material` gates that half on
+        // `is_wmo`.
+        let batch_order = u16::try_from(batch_idx + 1).unwrap_or(u16::MAX);
         let interior = sub.interior || interior_slot.is_some();
         // A billboard card is culled by the SAME rule as any other batch — its material's `0x04`
         // flag, nothing else. This site used to force `|| sub.billboard.is_some()`, on the reasoning
@@ -187,7 +186,7 @@ pub(crate) fn spawn_model_entities(
             sub.no_depth_test,
             sub.fog_policy,
             shade,
-            wmo_batch_order,
+            batch_order,
             sub.uv_anim.as_ref(),
             sub.rgb_anim.as_ref(),
             sub.wmo_batch,
@@ -224,7 +223,7 @@ pub(crate) fn spawn_model_entities(
                 sub.no_depth_test,
                 sub.fog_policy,
                 shade,
-                wmo_batch_order,
+                batch_order,
                 sub.uv_anim.as_ref(),
                 sub.rgb_anim.as_ref(),
                 sub.wmo_batch,
@@ -286,6 +285,10 @@ pub(crate) fn spawn_model_entities(
                     kind,
                     blend: sub.blend,
                 },
+                // The picker's triangles (decision 0857): the render forms are `RENDER_WORLD`-only,
+                // so the inspector/probe rays read the model's resident geometry. The caster
+                // centres a card at its pivot, the same bake the render form draws with.
+                crate::interact::PickMesh(sub.geometry.clone()),
                 mesh_tag,
                 card,
             ));
@@ -305,7 +308,7 @@ pub(crate) fn spawn_model_entities(
             // (or a contract break) falls back to the static form, un-rigged, rather than warn
             // the picker with a joint-less "skinned" mesh.
             let skinned_mesh = (skin.is_some() && rig_slot != 0)
-                .then(|| forms.skin.and_then(|s| s.get(wmo_batch_idx)).cloned())
+                .then(|| forms.skin.and_then(|s| s.get(batch_idx)).cloned())
                 .flatten();
             let use_rig = skinned_mesh.is_some();
             let part_tag = if use_rig {
@@ -321,6 +324,8 @@ pub(crate) fn spawn_model_entities(
                     kind,
                     blend: sub.blend,
                 },
+                // The picker's triangles (decision 0857) — same rule as the card above.
+                crate::interact::PickMesh(sub.geometry.clone()),
                 part_tag,
             ));
             // Static parts carry the build-time Aabb (the RENDER_WORLD rule above); a rigged
@@ -386,7 +391,6 @@ pub(crate) fn spawn_model_entities(
             meshes: skinned_meshes,
             fade: (radius, transform.transform_point(local_center)),
             clip: h.clip,
-            spawned_at: now,
             armed_at: now,
             // Born already expired, so the first frame runs the holder setup's `variationIdx = -1`
             // arm over the loader's var-0 seed — the reference's own two-stage load (decision 0768).