From d961d0bc06ba42d6ebf1da9c2a7bb648b71752b4 Mon Sep 17 00:00:00 2001
From: Sam <samuv.eth@gmail.com>
Date: Wed, 2 Sep 2026 17:00:01 +0700
Subject: [PATCH] Shadowfang's far rooms lose their cyan, and the street lamps
 hum
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Shadowfang Keep's far doorways no longer fill with flat blue-cyan at distance: it was never a hole — the room behind the arches is in the visible set at every camera distance — it was the building's own MFOG record (rgb 40,68,79 at end 106.9 yd, ~95% saturated at 70 yd) painted over a room the reference shows under the scene fog, because benilla picked the fog lane STATICALLY per batch (`flags & 0x48`) where the client's `[0xca7f00]` gate decides it per frame per group along the portal walk; the flood publishes that bit now and all three lanes (entity, retained, WMO liquid) read it, and the wow-re carve confirmed the predicate verbatim and added the conjunct we lacked — the MFOG target exists only when one of the camera's own containing groups is a true interior, so in a courtyard the interior triple decays to the scene triple, which is what a unit standing in the keep reads
- every world-placed M2 was silent — the street lamp's hum, the campfire, the waterfall, the windmill: no doodad ever wrote into the anim-event stream (three producers, none a terrain placement), and the sound clock was gated on the RIG, which is rightly never built for a model whose idle is the static mesh — `KalidarStreetLamp01.m2` is one looping 3.3 s Stand keying no bone at all, carrying one `$DSL`; the census (`benilla-extract soundeventscan`) counts 273 carrier models, 108 on tiers no rig gate arms; a sound-carrying placement now gets a clock-only host, `$DSL` is a sustained emitter, and the RE foldback settled three laws: `$DSL` ALWAYS loops and consults no flag (the kit's 0x200 bit is a lane select and 0x400 is random pitch — a neat four-row correlation of ours refuted), `$DSE` is the stop token, and a doodad holds ONE registration slot, which is why `bellows.m2`'s two loops alternate rather than drone
- the reference voices sound IDS, not doodads: `$DSL` registers the doodad's position as one record in a 32-entry pool keyed by SoundEntries id (`0x461d80`), each entry runs one channel at whichever of its records is nearest the listener — moved, not restarted (`0x7a5b10`), so one hum follows you down a row of lamps — the pump admits the first four entries by claim order and fades the rest over 3.0 s; the per-id duplicate suppressors turn out to be the one-shot lane's and were being applied to every lane (a three-second dropout every time a loop came back under the cap); three 76 yd hops between two Darnassus lamps now produce ONE play, and Darnassus runs 12 entitled ambiences with 8 withheld by the cap
- the selection ring joins the decal band too, and it draws UNDER the shadow: the RE found the ring emitted from inside PHASE 1's own M2 node drain (`[node+0xb4] = 0x481540` → the `+0x38` tick → `0x608e00`), the same iteration that then draws that node's blob shadow — the reverse of the tie-break this ladder had asserted since both rungs existed, a rule invented here and never read anywhere; `WOW_EFFECT_TRACE` names every rung of the band and prints its index in the sorted transparent phase, which is the ladder read straight off a live frame

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 crates/benilla-app/src/blob_shadow.rs         |   6 +-
 crates/benilla-app/src/capture/mod.rs         |   6 +
 crates/benilla-app/src/creature_anim/lod.rs   |   1 +
 crates/benilla-app/src/doodad_events.rs       |  71 ++
 crates/benilla-app/src/lib.rs                 |   2 +
 crates/benilla-app/src/pipe_warm/mod.rs       |   2 +-
 crates/benilla-app/src/sound/anim_events.rs   |  83 +-
 crates/benilla-app/src/sound/doodad_pool.rs   | 714 ++++++++++++++++++
 crates/benilla-app/src/sound/kit.rs           |  83 +-
 crates/benilla-app/src/sound/missile.rs       |   4 +-
 crates/benilla-app/src/sound/mod.rs           |   2 +
 crates/benilla-app/src/target/reticle.rs      |  15 +-
 crates/benilla-app/src/target/ring.rs         |   2 +-
 crates/benilla-assets/src/shaders/liquid.wgsl |  28 +-
 .../benilla-assets/src/shaders/wow_model.wgsl |  21 +-
 .../src/bin/benilla-extract/main.rs           |  12 +
 .../src/bin/benilla-extract/scan/mod.rs       |   5 +-
 .../src/bin/benilla-extract/scan/sequence.rs  | 148 ++++
 crates/benilla-formats/src/models/anim.rs     |  87 +++
 crates/benilla-world/src/doodad_anim/mod.rs   | 133 +++-
 crates/benilla-world/src/exterior_cull.rs     |   1 +
 crates/benilla-world/src/liquid/surface.rs    |   5 +
 crates/benilla-world/src/mesh_tag.rs          |  20 +-
 .../src/model_render/visibility.rs            |  62 +-
 crates/benilla-world/src/particles.rs         |   1 +
 crates/benilla-world/src/particles/render.rs  |  37 +-
 .../benilla-world/src/shaders/static_gx.wgsl  |  12 +-
 crates/benilla-world/src/sky_order.rs         |  72 +-
 crates/benilla-world/src/static_gx/cull.rs    |  43 +-
 crates/benilla-world/src/static_gx/mod.rs     |   2 +-
 crates/benilla-world/src/static_gx/pick.rs    |  18 +-
 crates/benilla-world/src/static_gx/render.rs  |  68 +-
 .../src/terrain_stream/spawn/mod.rs           |   3 +
 .../benilla-world/src/wmo_portal/audit/mod.rs |  12 +
 .../benilla-world/src/wmo_portal/audit/pin.rs | 207 ++++-
 crates/benilla-world/src/wmo_portal/mod.rs    | 182 ++++-
 36 files changed, 2027 insertions(+), 143 deletions(-)
 create mode 100644 crates/benilla-app/src/doodad_events.rs
 create mode 100644 crates/benilla-app/src/sound/doodad_pool.rs

diff --git a/crates/benilla-app/src/blob_shadow.rs b/crates/benilla-app/src/blob_shadow.rs
index 821c6747..effa6501 100644
--- a/crates/benilla-app/src/blob_shadow.rs
+++ b/crates/benilla-app/src/blob_shadow.rs
@@ -11,7 +11,11 @@
 //!   [`GroundDecalSurface`] set yet — the shadow lands on terrain + WMO faces only).
 //! - **Frame slot**: PHASE 1, among the opaque drains — `0x6812c5 call 0x683dd0`, fifth of the
 //!   row `0x6812b1`–`0x6812ca` inside `0x681070`, which the driver `0x483460` calls at
-//!   `0x48361d` (wow-re `water-frame-straddle.md` §1 + `unit-blob-shadow.md` Q1). So the shadow
+//!   `0x48361d` (wow-re `water-frame-straddle.md` §1 + `unit-blob-shadow.md` Q1). `0x683dd0` is
+//!   the **M2 node drain**, and the same loop body ticks each node's object first
+//!   (`0x48160c call [obj vt+0x38]` → the selection ring) and gates its shadow second
+//!   (`0x683ec3`) — so per unit the additive ring goes down and this modulate darkens it, never
+//!   the other way round (wow-re `decal-frame-slot.md`). So the shadow
 //!   lands after terrain and WMO and **before** everything else: the footprint decals
 //!   (`0x483654`), the M2 opaque pass (`0x4836a6`), the water surfaces (phase 3, drawn *between*
 //!   the two M2 transparent passes) and both of those passes. Every transparent in the world
diff --git a/crates/benilla-app/src/capture/mod.rs b/crates/benilla-app/src/capture/mod.rs
index bcf5a423..9eaf2f91 100644
--- a/crates/benilla-app/src/capture/mod.rs
+++ b/crates/benilla-app/src/capture/mod.rs
@@ -36,6 +36,12 @@
 //! quiescence, or waiting for pixel stability cannot help. It is a renderer defect that the harness
 //! correctly *reports*; do not try to gate it away here. Read 0815 before touching this file's phases.
 //!
+//! **`creature-indoor-front` is one of them** (named 2026-09-01, while A/B-ing 1787's fog gate): two
+//! runs of ONE unchanged build land in the two states at MAE 4.518, the whole difference confined to
+//! the subject's own brightness with the room around it pixel-identical, and the settle counts differ
+//! (235 vs 211 frames). If a change you are A/B-ing shows exactly 4.518 here, re-run the baseline
+//! before believing it — the number is the flake's, not yours.
+//!
 //! ## Running one capture by hand
 //! **Run through Cargo — never the built binary directly:**
 //! ```text
diff --git a/crates/benilla-app/src/creature_anim/lod.rs b/crates/benilla-app/src/creature_anim/lod.rs
index 23220b20..2eab8a22 100644
--- a/crates/benilla-app/src/creature_anim/lod.rs
+++ b/crates/benilla-app/src/creature_anim/lod.rs
@@ -597,6 +597,7 @@ mod tests {
                 world_from_local: bevy::math::Affine3A::IDENTITY,
                 name_set: 0,
                 visible: vec![false, false],
+                interior_fog: vec![false, false],
                 liquid_visited: vec![false, false],
                 flooded: vec![None, None],
             })
diff --git a/crates/benilla-app/src/doodad_events.rs b/crates/benilla-app/src/doodad_events.rs
new file mode 100644
index 00000000..1b1a7786
--- /dev/null
+++ b/crates/benilla-app/src/doodad_events.rs
@@ -0,0 +1,71 @@
+//! The **placed-doodad** animation-event scanner — the third and last producer feeding the
+//! [`AnimSoundEvent`] stream, beside the creature scanner ([`crate::creature_anim`]) and the
+//! GameObject one ([`crate::go_anim`]).
+//!
+//! Bug B345 ("every world-placed M2 doodad is silent") was this hole: a lamp's hum, a campfire's
+//! crackle, a waterfall, a windmill and a gnome machine are all authored as `$DSL`/`$DSO`/`$SND`
+//! keys on the model's own idle sequence — and **nothing in benilla ever wrote a doodad's events
+//! into the stream**. The routing end ([`crate::sound::anim_events`]) has handled those tags since
+//! decision 0070 slice 3; it simply never received one from a doodad, because the only two
+//! scanners gate on `AnimDriver` (units) and `GoAnim` (server-sent GameObjects), neither of which a
+//! terrain-stream placement ever gets.
+//!
+//! **Why it is not enough to scan the hosts that already exist.** The corpus says 273 models author
+//! a doodad sound marker (`benilla-extract soundeventscan`); only 165 of them are the `FirstSeq`
+//! tier that carries an `AnimationPlayer`. The other 108 — including the reported lamp,
+//! `KalidarStreetLamp01.m2`, one looping 3.333 s Stand that keys no bone at all and carries exactly
+//! one `$DSL` → `NightElfStreetLampLoop` — are bind-posed, and decision 0130's content gate
+//! deliberately builds them no rig. That gate is right about pixels and was never a claim about the
+//! clock: the reference arms **every** placed doodad and cycles it (wow-re `doodad-anim-host.md`
+//! §1/§5). So `doodad_anim::spawn_anim_host` now gives a sound-carrying model a clock-only host —
+//! the arm bookkeeping, no player — and this scanner reads that arm.
+//!
+//! **The clock is the shared one, never the player** ([`DoodadAnimHost::arm_clock`]): the reference
+//! gates the cycle on *linkage* (residency), not on the draw, so a campfire behind you keeps
+//! crackling. Reading the draw-gated `AnimationPlayer` would silence it the moment you turned away.
+
+use bevy::prelude::*;
+
+use benilla_world::doodad_anim::DoodadAnimHost;
+use benilla_world::schedule::WorldStage;
+
+use crate::creature_anim::{advance_track, scan_events, AnimSoundEvent, TrackMemory};
+use benilla_assets::ModelAnimations;
+
+/// Fire the event keyframes each placed doodad's armed clip crossed this frame.
+///
+/// The arming rules are the shared [`advance_track`]/[`scan_events`] ones the other two scanners
+/// use — an arm frame fires nothing, the frame after it opens the clip's `t = 0` head (which is
+/// where essentially every doodad sound key sits), and a loop wrap fires tail-then-head. A
+/// variation re-roll ([`benilla_world::doodad_anim`]'s self-sustaining re-arm) changes the node, so
+/// [`advance_track`] sees a fresh arm and never scans across the seam.
+fn fire_doodad_anim_events(
+    time: Res<Time>,
+    hosts: Query<(Entity, &DoodadAnimHost, &ModelAnimations)>,
+    mut last: Local<TrackMemory>,
+    mut out: MessageWriter<AnimSoundEvent>,
+) {
+    let now = time.elapsed_secs();
+    for (entity, host, anims) in &hosts {
+        let Some((node, cur)) = host.arm_clock(now) else {
+            continue; // gseq-only host with no sound arm: nothing is armed, so nothing fires
+        };
+        let Some(clip) = anims.clips.iter().find(|c| c.node == node) else {
+            continue;
+        };
+        if let Some(prev) = advance_track(&mut last, entity, node, cur) {
+            scan_events(clip, entity, prev, cur, &mut out);
+        }
+    }
+    // Drop memory for hosts that no longer exist. The other two scanners leave their `Local` to
+    // grow — a unit or GameObject population churns with the session — but placements do not:
+    // crossing a continent streams tens of thousands of them in and out, and an unreaped entry per
+    // placement is an unbounded leak on the one lane where it actually bites. `Query::contains` is
+    // a lookup, so this is one pass over a map sized by the live sound-host count. It lives here
+    // rather than in its own system because a `Local` belongs to exactly one system.
+    last.retain(|e, _| hosts.contains(*e));
+}
+
+pub(crate) fn plugin(app: &mut App) {
+    app.add_systems(Update, fire_doodad_anim_events.in_set(WorldStage::Present));
+}
diff --git a/crates/benilla-app/src/lib.rs b/crates/benilla-app/src/lib.rs
index 7a85d34f..950353f3 100644
--- a/crates/benilla-app/src/lib.rs
+++ b/crates/benilla-app/src/lib.rs
@@ -60,6 +60,7 @@ mod debug_panel;
 /// **The dev/player seam** (decisions 0026/1173, built in 1174) — the group, and the boundary
 /// rule, in one file. Always compiled; what it *holds* is not.
 mod dev;
+mod doodad_events;
 mod entities;
 mod fishing_line;
 mod footprints;
@@ -523,6 +524,7 @@ pub fn run(build: BuildId) -> AppExit {
     // GameObject animation (decision 0242): net-streamed GObjects (doors/chests) play an M2 sequence
     // on GAMEOBJECT_STATE change — the state-machine sibling of the doodad idle loop above.
     .add_plugins(go_anim::plugin)
+    .add_plugins(doodad_events::plugin)
     // Avatar + camera + input.
     .add_plugins(PlayerPlugin)
     // Cinematic fly-bys (`SMSG_TRIGGER_CINEMATIC`): the race intro a first login plays, and the
diff --git a/crates/benilla-app/src/pipe_warm/mod.rs b/crates/benilla-app/src/pipe_warm/mod.rs
index 305b75a4..b6bca0b9 100644
--- a/crates/benilla-app/src/pipe_warm/mod.rs
+++ b/crates/benilla-app/src/pipe_warm/mod.rs
@@ -615,7 +615,7 @@ fn warm_effect_lane(
         ] {
             for raster_bias in [
                 0,
-                benilla_world::sky_order::Rung::GROUND_FX as i32,
+                benilla_world::sky_order::Rung::DECAL_RASTER,
                 benilla_world::sky_order::Rung::SHADOW_RASTER,
             ] {
                 // `lit` is a pipeline-key axis (a shader def), so BOTH arms are warmed — a hole
diff --git a/crates/benilla-app/src/sound/anim_events.rs b/crates/benilla-app/src/sound/anim_events.rs
index 1f3e181b..c789b1ff 100644
--- a/crates/benilla-app/src/sound/anim_events.rs
+++ b/crates/benilla-app/src/sound/anim_events.rs
@@ -1,8 +1,9 @@
 //! Route M2 animation event tags (`crate::creature_anim::AnimSoundEvent`) to audio — the
 //! anim-driven trigger surface (decision 0070 slice 3).
 //!
-//! Routed here: `$SND`/`$DSO` (one-shot kit `data` at the model), `$DSL` (doodad loop kit —
-//! played as a one-shot for now; looping-emitter lifecycle comes with doodad anim support),
+//! Routed here: `$SND`/`$DSO` (one-shot kit `data` at the model), `$DSL`/`$DSE` (a placed
+//! doodad's ambient loop — **registered into, and released from, the emitter pool**
+//! [`super::doodad_pool`], which owns everything about how it sounds),
 //! `$CSD` — the **character emote clips' embedded voice** (HumanMale EmoteLaugh 70 carries
 //! `$CSD 6923` = the SoundEntries kit literally named `HumanMaleEmoteLaugh`; Cry 77 → 6921,
 //! Chicken 78 → 6919, Applaud 80 → 4× `ClapSounds` 6576 — probe-verified on the real 5875 M2 +
@@ -38,12 +39,13 @@ use crate::net::ObjectStore;
 use benilla_assets::WorldAssets;
 use benilla_world::schedule::WorldStage;
 
+use super::doodad_pool::DoodadEmitterPool;
 use super::emote::EmoteSounds;
 use super::kit::{play_kit, KitRef, SoundCategory, SoundKits};
 use super::{AudioListener, SoundConfig, SoundOutput};
 
 #[allow(clippy::too_many_arguments)] // the standard sound-route param set + the two resolvers
-fn route_anim_events(
+pub(super) fn route_anim_events(
     mut events: MessageReader<AnimSoundEvent>,
     // GlobalTransform: `$SND` tags can fire from parented visuals (a mount child's model),
     // whose local Transform is not a world position (0441 fold-back).
@@ -57,6 +59,16 @@ fn route_anim_events(
     mut out: NonSendMut<SoundOutput>,
     config: Res<SoundConfig>,
     listener: Res<AudioListener>,
+    // Kit ids already complained about. A failing kit here is a PER-EVENT failure on a stream that
+    // fires at doodad rates, so warning every time is a log flood, not a diagnostic: one live run
+    // past Darnassus produced 420 identical lines for `NightElfLantern01`'s `$DSL(33764)`, an id
+    // that is simply not in 5875's `SoundEntries` (32401 is the corpus's only other one). The
+    // reference does nothing audible for an id it cannot resolve, so this is data, not an error —
+    // but it is still worth saying once, because a kit that goes missing for any OTHER reason is a
+    // real bug and silence would hide it.
+    mut complained: Local<std::collections::HashSet<u32>>,
+    // The ambient emitter pool — `$DSL`/`$DSE`'s whole destination.
+    mut pool: ResMut<DoodadEmitterPool>,
 ) {
     if events.is_empty() {
         return;
@@ -65,7 +77,11 @@ fn route_anim_events(
         return;
     };
     let listener = listener.pos;
-    let ring = |kits: &mut SoundKits, out: &mut SoundOutput, kit: u32, entity: Entity| {
+    let ring = |kits: &mut SoundKits,
+                out: &mut SoundOutput,
+                kit: u32,
+                entity: Entity,
+                complained: &mut std::collections::HashSet<u32>| {
         let pos = transforms.get(entity).map(|t| t.translation()).ok();
         if let Err(e) = play_kit(
             kits,
@@ -77,13 +93,62 @@ fn route_anim_events(
             pos,
             SoundCategory::Sfx,
         ) {
-            warn!("anim event kit {kit}: {e:#}");
+            if complained.insert(kit) {
+                warn!("anim event kit {kit}: {e:#} (further reports for this kit suppressed)");
+            }
         }
     };
     for ev in events.read() {
         match &ev.ident {
-            b"$SND" | b"$DSO" | b"$DSL" | b"$CSD" if ev.data != 0 => {
-                ring(&mut kits, &mut out, ev.data, ev.entity);
+            // `$DSL` — the DOODAD SOUND **LOOP** (`0x69521d`), VERIFIED (wow-re
+            // `sound/scratch/doodad-sound-emitters.md`, §5). A persistent handle with a lifecycle,
+            // one per doodad (`[CMapDoodadDef+0x168]`): crossing the marker again **repositions**
+            // the existing registration (`0x462000`) and never restarts it; a DIFFERENT id
+            // releases the old one (`0x461f80`) and registers the new (`0x461d80`). So there is no
+            // wrap retrigger at all — which the shipped audio already implied, since
+            // `NightElfStreetLampLoop` is 4.000 s on a 3.333 s sequence and `CampFireSmallLoop` is
+            // 2.967 s on the same, mismatched in both directions.
+            //
+            // **It always loops, and consults NO flag.** Looping is an entry-point constant on the
+            // reference's registration pool: `0x7a54d0` builds mode `0x1002` (`HW3D|LOOP_NORMAL`)
+            // and calls `SetLoopCount(stream, -1)`, against `0x7a5490`'s `0x1000` for the one-shot
+            // path. This corrects the interim that shipped with the first half of B345: the kit's
+            // 0x200 bit has exactly ONE reader image-wide (`0x458840`), whose two callers are the
+            // GameObject display-slot lane select and the spell-visual lane — it reaches neither
+            // mode word and is a LANE SELECT, not a loop flag. (0x400, which correlated perfectly
+            // with the four non-sustaining `$DSL` kits in the shipped data, is `random pitch`; the
+            // correlation was authoring practice — you do not detune a sustained hum.) `force_loop`
+            // here is therefore the faithful shape, not a workaround: 25 of the 60 kits a `$DSL`
+            // names omit 0x200 and every one of them loops in the real client.
+            // `$DSL` — the DOODAD SOUND **LOOP** (`0x69521d`), VERIFIED (wow-re
+            // `sound/scratch/doodad-sound-emitters.md`). It does not start a sound. It
+            // **registers this doodad's position** as one emitter of its SoundEntries id in the
+            // pool at `0xb06dd8` (`0x461d80`), and re-crossing the marker only *repositions* that
+            // registration (`0x462000`) — which is why there is no wrap retrigger, and why
+            // `NightElfStreetLampLoop` (4.000 s of sample on a 3.333 s sequence) is not chopped
+            // every cycle. Whether anything is audible, from where, and how many at once are the
+            // pool pump's questions, not this scanner's: see [`super::doodad_pool`].
+            b"$DSL" if ev.data != 0 => {
+                if let Ok(t) = transforms.get(ev.entity) {
+                    super::doodad_pool::register(
+                        &mut pool,
+                        ev.entity,
+                        ev.data,
+                        t.translation(),
+                        listener,
+                    );
+                }
+            }
+            // `$DSE` — the doodad sound **STOP** token (`0x45534424`), VERIFIED in the same note:
+            // it releases the doodad's registration (`0x461f80`), and its `data` is 0 on all 16
+            // shipped models. Without it a `$DSL` started at a keyframe never ends — which is
+            // exactly the elevator and machinery family (`GnomereganElevatorLoop`, `SubwayLoop`,
+            // the Undercity and Thunder Bluff lifts, the zeppelin), where the loop is authored to
+            // run for one leg of the animation and stop. Releasing a record is not stopping a
+            // sound: the id keeps sounding while any *other* doodad still names it.
+            b"$DSE" => super::doodad_pool::release(&mut pool, ev.entity),
+            b"$SND" | b"$DSO" | b"$CSD" if ev.data != 0 => {
+                ring(&mut kits, &mut out, ev.data, ev.entity, &mut complained);
             }
             b"$ESD" => {
                 let Some(emotes) = emotes.as_deref() else {
@@ -98,7 +163,7 @@ fn route_anim_events(
                     .then(|| emotes.state_event_sound(state))
                     .flatten()
                 {
-                    ring(&mut kits, &mut out, kit, ev.entity);
+                    ring(&mut kits, &mut out, kit, ev.entity, &mut complained);
                 }
             }
             b"$TRD" => {
@@ -108,7 +173,7 @@ fn route_anim_events(
                 let hold = units.get(ev.entity).ok().and_then(|(_, h)| h);
                 let kit = hold.and_then(|h| held_strike_sound(spells, &visuals.0, h.spell_id));
                 if let Some(kit) = kit {
-                    ring(&mut kits, &mut out, kit, ev.entity);
+                    ring(&mut kits, &mut out, kit, ev.entity, &mut complained);
                 }
             }
             other => {
diff --git a/crates/benilla-app/src/sound/doodad_pool.rs b/crates/benilla-app/src/sound/doodad_pool.rs
new file mode 100644
index 00000000..fd161eff
--- /dev/null
+++ b/crates/benilla-app/src/sound/doodad_pool.rs
@@ -0,0 +1,714 @@
+//! The **placed-doodad ambient emitter pool** — the reference's registration table at `0xb06dd8`
+//! and its per-frame pump `0x461990` (wow-re `sound/scratch/doodad-sound-emitters.md`, §7/§8/§17).
+//!
+//! B345's fix gave every world-placed doodad a clock and routed its `$DSL` key to audio, which is
+//! what made a lamp hum at all. It played that hum the obvious way — one channel per doodad, tagged
+//! to the doodad — and that is **not the shape the reference has**. The client does not voice
+//! doodads; it voices **sound ids**, and a doodad is only a *position* it can put one at:
+//!
+//! - `$DSL` registers the doodad's position as one **record** inside the pool entry that holds its
+//!   SoundEntries id (`0x461d80`, handle `((entry+1) << 16) | record` kept in
+//!   `[CMapDoodadDef+0x168]`). Every doodad naming the same id shares one entry.
+//! - Each entry runs **exactly one channel**, positioned at whichever of its records is **nearest
+//!   the listener** (`0x461ca0`'s 256-wide argmin), repositioned as that changes and **never
+//!   restarted** (`0x7a5b10`). One hum follows you down a row of thirty lamps.
+//! - The pump walks the 32 entries and lets the first **four** hold a channel (`0x4619c0 cmp
+//!   edi,4`). Arbitration is by **ascending entry index — claim order, not distance**: a fifth
+//!   distinct ambience is faded out over 3.0 s and does *not* take over when you walk toward it.
+//!
+//! So the three limits are structural, not a budget bolted on: **32 distinct ids**, **256 emitters
+//! per id**, **4 sounding at once**.
+//!
+//! **What we had instead**, measured rather than assumed (`benilla-extract soundeventscan`): a
+//! channel per doodad, parked on its own model and restarted every time you crossed its
+//! `DistanceCutoff`. The *count* was held down by two gates that were never about ambience —
+//! **45 of the 60** resolvable `$DSL` kits carry the reference's own `NO_DUPLICATES` bit (0x20),
+//! which benilla applied on every lane, so three-quarters of doodad ambience already played
+//! exactly one channel; the other 15 got up to two from `SAME_KIT_MAX`. One channel, yes — but at
+//! whichever doodad happened to fire first rather than the nearest, retriggering at every cutoff
+//! crossing, and with **nothing whatever** bounding the number of *distinct* ambiences, so a
+//! torch-and-campfire cluster could take a third of the 12-voice ceiling away from the sounds a
+//! player is actually listening for. Applying 0x20 here was itself wrong: it is the **one-shot**
+//! lane's suppressor (§15), and this lane is now exempt from it
+//! ([`super::kit::PlayExtras::dedupe_exempt`]).
+//!
+//! **What the pool is not.** It is not a cache and not an optimisation — it is the mechanism that
+//! decides *where* a doodad ambience comes from and *which* ones you hear. Sharing a channel is
+//! what makes the emitter track the nearest lamp; the cap is what makes the fifth one silent.
+//!
+//! **Deliberate divergences**, both documented at their site: a failed kit is flagged in place
+//! rather than by negating the entry's id, and a channel the frame pump culls past the kit's own
+//! `DistanceCutoff` is stopped rather than left running at zero gain. Neither changes what is
+//! audible; see the notes on [`Entry::failed`] and [`pump_doodad_emitters`].
+
+use std::collections::HashSet;
+
+use bevy::ecs::entity::EntityHashMap;
+use bevy::prelude::*;
+
+use benilla_assets::WorldAssets;
+use benilla_world::schedule::WorldStage;
+
+use super::kit::{
+    self, kit_name, play_kit_ext, set_source_kit_gain, source_kit_playing, stop_source, KitRef,
+    PlayExtras, SoundCategory, SoundKits,
+};
+use super::{math, AudioListener, SoundConfig, SoundOutput};
+
+/// `0x461eac cmp ecx,0x1c200` over the entry stride `0xe10` — **32** entries, one per distinct
+/// SoundEntries id. A 33rd distinct id finds no match and no free entry, `0x461d80` returns handle
+/// 0, and that doodad is simply untracked until an entry frees (§17).
+const POOL_ENTRIES: usize = 32;
+
+/// `[entry+0xC00..+0xCFF]` — **256** emitter records per entry.
+const RECORDS_PER_ENTRY: usize = 256;
+
+/// `0x4619c0 cmp edi,4` — at most **four** entries hold a channel at once.
+const PLAYING_CAP: usize = 4;
+
+/// `0x7a5a10(3.0f)` — the fade a released or cap-evicted channel gets, in seconds.
+const FADE_SECS: f32 = 3.0;
+
+/// The entity a pool entry's one channel rides. Its `Transform` is what [`kit::pump_channels`]'s
+/// tracked-follow reads, so moving it *is* the reference's reposition (`0x7a5b10`) — the same
+/// trick the liquid ambience loops use for their slewed emitter.
+#[derive(Component)]
+struct PoolEmitter;
+
+/// One registered emitter: the reference's `[entry + 12·rec]` position, with presence in the list
+/// standing in for its `[+0xC00+rec]` active byte.
+struct Record {
+    doodad: Entity,
+    pos: Vec3,
+}
+
+/// One pool entry — a SoundEntries id, its emitters, and the single channel they share.
+#[derive(Default)]
+struct Entry {
+    /// `[+0xE00]` — the SoundEntries id this entry holds; 0 = free.
+    id: u32,
+    /// **Divergence.** The reference marks a kit that failed to resolve by *negating* the id
+    /// (`[+0xE00] = -id`), which makes the entry stop matching its own id: the doodad's next
+    /// `$DSL` then releases and re-registers into a fresh entry, every cycle, for ever. A separate
+    /// flag keeps the doodad where it is. Both hold exactly one entry and both are silent, so
+    /// nothing observable turns on it — but ours does not churn.
+    failed: bool,
+    /// `[+0xC00]`'s active set, in claim order (which is what the 257th-record eviction rule
+    /// below reads as "first").
+    records: Vec<Record>,
+    /// `[+0xE04]`'s companion — the entity carrying this entry's channel, `None` when none is
+    /// live.
+    voice: Option<Entity>,
+}
+
+impl Entry {
+    /// `0x461b40` steps 1–3: is there a channel coming to this entry at all? (Occupied, its kit
+    /// resolvable, and at least one emitter registered.) Entitlement, not audibility — see
+    /// [`admitted`].
+    fn entitled(&self) -> bool {
+        self.id != 0 && !self.failed && !self.records.is_empty()
+    }
+
+    /// `0x461ca0` — the position of the **nearest** active record, ties keeping the first
+    /// (`0x461cf6` discards a candidate that is not *strictly* closer).
+    fn nearest(&self, listener: Vec3) -> Option<Vec3> {
+        self.records
+            .iter()
+            .map(|r| (math::dist_sq(listener, r.pos), r.pos))
+            .reduce(|best, cand| if cand.0 < best.0 { cand } else { best })
+            .map(|(_, pos)| pos)
+    }
+}
+
+/// A channel the pool has let go of and is fading out over [`FADE_SECS`].
+///
+/// It is an **orphan on purpose**: the reference starts the fade and clears `[+0xE04]` in the same
+/// breath (`0x461d20`, `0x4619c5`), so the entry is free to be reclaimed by another id — or to
+/// start a fresh channel of its own — while the old sound is still dying. Holding the fade on the
+/// entry would serialise those.
+struct Fading {
+    emitter: Entity,
+    kit: u32,
+    gain: f32,
+}
+
+/// The pool itself.
+#[derive(Resource)]
+pub(super) struct DoodadEmitterPool {
+    entries: [Entry; POOL_ENTRIES],
+    /// Which entry each doodad is registered in — the reference's per-doodad handle
+    /// `[CMapDoodadDef+0x168]`, minus the record half (a record *is* its doodad here).
+    handles: EntityHashMap<usize>,
+    fading: Vec<Fading>,
+    /// Kit ids already warned about. A `$DSL` re-fires every animation cycle, so an unresolvable
+    /// id is a per-cycle failure on a per-doodad stream: the same log flood B345's routing half
+    /// had to learn to avoid.
+    complained: HashSet<u32>,
+    /// The last logged census — `(kit id, is a channel actually live)` per admitted entry — so
+    /// the line below reports **edges**, not frames. Liveness is in the key on purpose: a channel
+    /// culled past its cutoff and restarted is exactly the churn a broken nearest-follow would
+    /// produce, and the census is where that has to be visible.
+    last_census: Vec<(u32, bool)>,
+}
+
+impl Default for DoodadEmitterPool {
+    fn default() -> Self {
+        Self {
+            entries: std::array::from_fn(|_| Entry::default()),
+            handles: EntityHashMap::default(),
+            fading: Vec::new(),
+            complained: HashSet::new(),
+            last_census: Vec::new(),
+        }
+    }
+}
+
+impl DoodadEmitterPool {
+    /// `$DSL`'s registration step — `0x69521d`'s compare followed by `0x462000` (reposition) or
+    /// `0x461f80`+`0x461d80` (re-register).
+    ///
+    /// Crossing the marker again with the **same** id only moves the record; that is the whole
+    /// reason there is no wrap retrigger, and why `NightElfStreetLampLoop` (4.000 s of sample on a
+    /// 3.333 s sequence) is not chopped every cycle. A **different** id releases the old
+    /// registration and takes a new one, which is what makes `bellows.m2`'s `$DSL` pair —
+    /// `BellowOut` at t=0.000, `BellowIN` at t=1.100 on one looping 2 s sequence — *alternate*
+    /// through one slot instead of droning together.
+    fn register(&mut self, doodad: Entity, id: u32, pos: Vec3, listener: Vec3) {
+        if let Some(&e) = self.handles.get(&doodad) {
+            if self.entries[e].id == id {
+                if let Some(r) = self.entries[e]
+                    .records
+                    .iter_mut()
+                    .find(|r| r.doodad == doodad)
+                {
+                    r.pos = pos;
+                }
+                return;
+            }
+            self.release(doodad);
+        }
+        // `0x461e60`: the entry already holding this id, else the first free one.
+        let Some(e) = self
+            .entries
+            .iter()
+            .position(|x| x.id == id)
+            .or_else(|| self.entries.iter().position(|x| x.id == 0))
+        else {
+            return; // all 32 entries hold other ids — untracked until one frees (§17)
+        };
+        if self.entries[e].id == 0 {
+            self.entries[e].id = id;
+            self.entries[e].failed = false;
+        }
+        if self.entries[e].records.len() >= RECORDS_PER_ENTRY {
+            // `0x461a60` — the sound ledger's `first_slot_farther_than_query`: evict the FIRST
+            // record farther from the listener than the newcomer, and reject the newcomer when
+            // none is. Not an LRU and not an argmax: first-farther, in claim order.
+            let d = math::dist_sq(listener, pos);
+            let Some(victim) = self.entries[e]
+                .records
+                .iter()
+                .position(|r| math::dist_sq(listener, r.pos) > d)
+            else {
+                return;
+            };
+            let gone = self.entries[e].records.remove(victim);
+            self.handles.remove(&gone.doodad);
+        }
+        self.entries[e].records.push(Record { doodad, pos });
+        self.handles.insert(doodad, e);
+    }
+
+    /// `0x461f80` → `0x461d20` — release `doodad`'s record. When it was the entry's **last**, the
+    /// id is cleared and the channel starts its 3.0 s fade as an orphan.
+    ///
+    /// Reached from `$DSE` (the authored stop token — the elevator and machinery family, where the
+    /// loop runs for one leg of the animation) and from the host's despawn (the doodad's own
+    /// teardown, §9). There is deliberately **no** map-change reset: the reference has none either
+    /// (`0x461a20`'s only caller is the process-shutdown chain), and a streamed-out tile releases
+    /// its doodads one by one, which is the same thing done honestly.
+    fn release(&mut self, doodad: Entity) {
+        let Some(e) = self.handles.remove(&doodad) else {
+            return;
+        };
+        let entry = &mut self.entries[e];
+        entry.records.retain(|r| r.doodad != doodad);
+        if !entry.records.is_empty() {
+            return;
+        }
+        let (kit, voice) = (entry.id, entry.voice);
+        *entry = Entry::default();
+        if let Some(emitter) = voice {
+            self.fading.push(Fading {
+                emitter,
+                kit,
+                gain: 1.0,
+            });
+        }
+    }
+
+    /// Hand this entry's channel to the fade list and leave the entry otherwise intact — the
+    /// cap's eviction (`0x4619c5`), which keeps the id and its records so the entry can start a
+    /// fresh channel the moment it is back under the cap.
+    fn retire(&mut self, e: usize) {
+        let (kit, voice) = {
+            let entry = &mut self.entries[e];
+            (entry.id, entry.voice.take())
+        };
+        if let Some(emitter) = voice {
+            self.fading.push(Fading {
+                emitter,
+                kit,
+                gain: 1.0,
+            });
+        }
+    }
+}
+
+/// The entries that get a channel this frame: the first [`PLAYING_CAP`] entitled ones **by
+/// ascending index** (`0x4619c0`).
+///
+/// Index is claim order, so this is first-come — emphatically **not** nearest. That is the cap's
+/// one surprising property and the reference's own falsifiable prediction: standing where five
+/// distinct doodad ambiences are in range, exactly four sound, and walking toward the fifth does
+/// not make it take over.
+///
+/// Entitlement is deliberately not audibility. An entry whose nearest emitter is past its kit's
+/// `DistanceCutoff` still holds its slot, because in the reference its FMOD channel is still
+/// *playing* — merely attenuated to nothing — and `0x461b40` counts it. A far ambience therefore
+/// keeps a near one silent, which is exactly what the cap does in the real client.
+fn admitted(entries: &[Entry]) -> Vec<usize> {
+    entries
+        .iter()
+        .enumerate()
+        .filter(|(_, x)| x.entitled())
+        .map(|(i, _)| i)
+        .take(PLAYING_CAP)
+        .collect()
+}
+
+/// The pump (`0x461990`): fade the orphans, mark unresolvable kits, then service the admitted
+/// entries — start a channel where there is none, and otherwise only *move* the one there is.
+#[allow(clippy::too_many_arguments)] // the standard sound-driver param set
+fn pump_doodad_emitters(
+    mut pool: ResMut<DoodadEmitterPool>,
+    mut emitters: Query<&mut Transform, With<PoolEmitter>>,
+    time: Res<Time>,
+    kits: Option<ResMut<SoundKits>>,
+    assets: Option<Res<WorldAssets>>,
+    mut out: NonSendMut<SoundOutput>,
+    config: Res<SoundConfig>,
+    listener: Res<AudioListener>,
+    mut commands: Commands,
+) {
+    let (Some(mut kits), Some(assets)) = (kits, assets) else {
+        return;
+    };
+    // Running silent (`WOW_NOSOUND=1`, CI, an unattended probe): a start that cannot succeed must
+    // not be retried per frame per entry, and must not warn — the same lesson the liquid loops
+    // learned at 3975 identical lines in a 75 s run.
+    if out.mixer.is_none() {
+        return;
+    }
+    let listener_pos = listener.pos;
+    let step = if FADE_SECS > 0.0 {
+        time.delta_secs() / FADE_SECS
+    } else {
+        1.0
+    };
+    let pool = &mut *pool;
+
+    // The orphans' fade-out.
+    pool.fading.retain_mut(|f| {
+        f.gain -= step;
+        // Faded out, or nothing left to fade (the frame pump culled the channel past its cutoff,
+        // or the voice ceiling stole it): let the entity go now rather than hold it for 3 s of
+        // silence.
+        if f.gain <= 0.0 || !source_kit_playing(&out, f.emitter, f.kit) {
+            stop_source(&mut out, f.emitter);
+            commands.entity(f.emitter).despawn();
+            return false;
+        }
+        set_source_kit_gain(&mut out, f.emitter, f.kit, f.gain);
+        true
+    });
+
+    // `0x45cda0(id)` returning null → `[+0xE00] = -id`, permanently. Done before the arbitration
+    // so a dead id never costs a live one its slot, not even for a frame. `NightElfLantern01`'s
+    // `$DSL(33764)` is the shipped case: 5875's `SoundEntries` simply has no such row.
+    for entry in pool.entries.iter_mut() {
+        if entry.id != 0 && !entry.failed && kit_name(&kits, entry.id).is_none() {
+            entry.failed = true;
+            if pool.complained.insert(entry.id) {
+                warn!(
+                    "doodad emitter kit {}: no SoundEntries row — entry silenced permanently \
+                     (further reports for this kit suppressed)",
+                    entry.id
+                );
+            }
+        }
+    }
+
+    let admitted = admitted(&pool.entries);
+    let mut census: Vec<(u32, bool)> = Vec::new();
+    for e in 0..POOL_ENTRIES {
+        if !admitted.contains(&e) {
+            // Free, failed, emitter-less — or over the cap, which is the case that matters: the
+            // channel fades out and the entry keeps everything else.
+            pool.retire(e);
+            continue;
+        }
+        let id = pool.entries[e].id;
+        let Some(nearest) = pool.entries[e].nearest(listener_pos) else {
+            continue; // `entitled()` guarantees a record; belt and braces
+        };
+
+        // Put the voice entity at the nearest record. For a live channel this *is* the reference's
+        // reposition — the frame pump's tracked-follow ships the new position and the sound never
+        // restarts, which is the difference between one hum that follows you down a row of lamps
+        // and thirty hums that each retrigger as you pass.
+        let emitter = match pool.entries[e].voice {
+            Some(em) => {
+                match emitters.get_mut(em) {
+                    Ok(mut tf) => tf.translation = nearest,
+                    // Ours, spawned on an earlier frame, so this cannot happen — except through a
+                    // query-filter mistake, which would silently freeze every ambience at the
+                    // first emitter it ever found and leave the whole nearest-follow inert. That
+                    // failure is invisible in the audio (a hum is a hum), so it has to be loud
+                    // here.
+                    Err(err) => {
+                        if pool.complained.insert(id) {
+                            warn!(
+                                "doodad emitter {em}: transform unreachable ({err}) — kit {id} is \
+                                 stuck at its first emitter"
+                            );
+                        }
+                    }
+                }
+                em
+            }
+            None => {
+                let em = commands
+                    .spawn((PoolEmitter, Transform::from_translation(nearest)))
+                    .id();
+                pool.entries[e].voice = Some(em);
+                em
+            }
+        };
+        if source_kit_playing(&out, emitter, id) {
+            census.push((id, true));
+            continue;
+        }
+        // No channel: either this entry has never sounded, or the frame pump culled ours past the
+        // kit's `DistanceCutoff`. **Divergence:** the reference's pool lane has no distance
+        // pre-check and leaves the channel running at zero gain past the cutoff, where ours stops
+        // and restarts it. For a loop of ambience that is inaudible — restarting a hum you could
+        // not hear costs nothing but a phase — and it hands the voice back while it is silent.
+        // The *cap* is unaffected, because [`admitted`] counts entitlement, not liveness.
+        if let Err(err) = play_kit_ext(
+            &mut kits,
+            &assets,
+            &mut out,
+            &config,
+            listener_pos,
+            KitRef::Id(id),
+            Some(nearest),
+            SoundCategory::Sfx,
+            PlayExtras {
+                source: Some(emitter),
+                // Looping is an entry-point constant on this lane, not a flag: `0x7a54d0` builds
+                // mode `0x1002` (`HW3D|LOOP_NORMAL`) and calls `SetLoopCount(-1)`, against
+                // `0x7a5490`'s `0x1000` for the one-shot path. Every `$DSL` loops; no `$DSO` does;
+                // `SoundEntries.Flags` is consulted for neither (§16).
+                force_loop: true,
+                // The per-id suppressors are the one-shot lane's; this lane dedupes structurally
+                // (one entry per id) and must not be blocked by its own fading predecessor.
+                dedupe_exempt: true,
+                ..default()
+            },
+        ) {
+            if pool.complained.insert(id) {
+                warn!("doodad emitter kit {id}: {err:#} (further reports for this kit suppressed)");
+            }
+        }
+        // Whether the start actually took: `play_kit_ext` succeeds *without playing* when the kit
+        // is past its cutoff, held by the loading cover, or refused by the voice ceiling. Reading
+        // the channel back is the only honest answer, and the difference between "admitted" and
+        // "audible" is the whole point of this line.
+        census.push((id, source_kit_playing(&out, emitter, id)));
+    }
+
+    // The pool's one observable. "Which doodad ambiences are sounding, and how many are being held
+    // back by the cap" is invisible in the audio itself — five ids in range and four sounding is
+    // indistinguishable from four in range unless something says so — and it is precisely the
+    // question a retest of the cap has to answer. Logged on the **edge**, so a parked camera
+    // prints one line, not one per frame.
+    if census != pool.last_census {
+        let entitled = pool.entries.iter().filter(|x| x.entitled()).count();
+        let named: Vec<String> = census
+            .iter()
+            .map(|(id, live)| {
+                let name = kit_name(&kits, *id).unwrap_or("?");
+                // A kit past its own `DistanceCutoff` is admitted, holds its cap slot, and is
+                // inaudible. Saying "sounding" of it would be the observable lying about the one
+                // thing it exists to report.
+                format!(
+                    "{id} ({name}){}",
+                    if *live { "" } else { " [out of range]" }
+                )
+            })
+            .collect();
+        debug!(
+            "doodad pool: admitted [{}] — {} sounding, {entitled} entitled entr{}, {} withheld by \
+             the cap, {} fading",
+            named.join(", "),
+            census.iter().filter(|(_, live)| *live).count(),
+            if entitled == 1 { "y" } else { "ies" },
+            entitled.saturating_sub(census.len()),
+            pool.fading.len(),
+        );
+        pool.last_census = census;
+    }
+}
+
+/// Register `doodad`'s emitter for kit `id` at `pos` — `$DSL`'s handler, called from
+/// [`super::anim_events`].
+pub(super) fn register(
+    pool: &mut DoodadEmitterPool,
+    doodad: Entity,
+    id: u32,
+    pos: Vec3,
+    listener: Vec3,
+) {
+    pool.register(doodad, id, pos, listener);
+}
+
+/// Release `doodad`'s emitter — `$DSE`'s handler.
+pub(super) fn release(pool: &mut DoodadEmitterPool, doodad: Entity) {
+    pool.release(doodad);
+}
+
+/// Release the emitters of doodads whose host has gone (`0x7133a0`'s teardown leg, §9).
+///
+/// This replaces B345's channel-scoped reaper. A doodad no longer *owns* a channel, so stopping
+/// "its" channel is the wrong verb: what a despawn retires is one **record**, and the sound only
+/// stops when the last emitter of that id in the world is gone. Streaming out one of thirty lamps
+/// must not silence the other twenty-nine.
+fn release_doodad_emitters_on_despawn(
+    mut gone: RemovedComponents<benilla_world::doodad_anim::DoodadAnimHost>,
+    mut pool: ResMut<DoodadEmitterPool>,
+) {
+    for entity in gone.read() {
+        pool.release(entity);
+    }
+}
+
+pub(super) fn plugin(app: &mut App) {
+    app.init_resource::<DoodadEmitterPool>().add_systems(
+        Update,
+        (
+            // Registration (`$DSL`/`$DSE` in `anim_events`) and the despawn release both write the
+            // pool; the pump reads it and starts channels; the frame pump then applies this
+            // frame's positions and gains. Ordered explicitly rather than left to the scheduler,
+            // because an arbitrary order costs a frame of latency on a stop.
+            release_doodad_emitters_on_despawn.before(pump_doodad_emitters),
+            pump_doodad_emitters
+                .after(super::anim_events::route_anim_events)
+                .before(kit::pump_channels),
+        )
+            .in_set(WorldStage::Present),
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Entities are only identities here — the pool never looks one up.
+    fn doodads(n: u32) -> Vec<Entity> {
+        (0..n)
+            .map(Entity::from_raw_u32)
+            .map(Option::unwrap)
+            .collect()
+    }
+
+    fn pool_with(entries: &[(u32, usize)]) -> DoodadEmitterPool {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(entries.len() as u32 * 2);
+        for (i, (id, records)) in entries.iter().enumerate() {
+            for r in 0..*records {
+                pool.entries[i].records.push(Record {
+                    doodad: ds[r % ds.len()],
+                    pos: Vec3::ZERO,
+                });
+            }
+            pool.entries[i].id = *id;
+        }
+        pool
+    }
+
+    /// The structural dedupe: N doodads naming one kit share ONE entry, which is what makes the
+    /// pump run one channel for the lot.
+    #[test]
+    fn every_doodad_naming_one_kit_shares_a_single_entry() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(30);
+        for (i, d) in ds.iter().enumerate() {
+            pool.register(*d, 3378, Vec3::new(i as f32, 0.0, 0.0), Vec3::ZERO);
+        }
+        assert_eq!(pool.entries.iter().filter(|e| e.id != 0).count(), 1);
+        assert_eq!(pool.entries[0].records.len(), 30);
+        // …and its channel goes to the nearest of the thirty, not to whichever fired last.
+        assert_eq!(
+            pool.entries[0]
+                .nearest(Vec3::new(29.0, 0.0, 0.0))
+                .unwrap()
+                .x,
+            29.0
+        );
+        assert_eq!(pool.entries[0].nearest(Vec3::ZERO).unwrap().x, 0.0);
+    }
+
+    /// `0x461cf6` discards a candidate that is not *strictly* closer.
+    #[test]
+    fn a_tie_for_nearest_keeps_the_first_record() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(2);
+        pool.register(ds[0], 7, Vec3::new(0.0, 0.0, 5.0), Vec3::ZERO);
+        pool.register(ds[1], 7, Vec3::new(0.0, 0.0, -5.0), Vec3::ZERO);
+        assert_eq!(pool.entries[0].nearest(Vec3::ZERO).unwrap().z, 5.0);
+    }
+
+    /// Re-crossing the marker with the same id REPOSITIONS (`0x462000`); it never takes a second
+    /// record and never releases. This is the no-wrap-retrigger property, in the data.
+    #[test]
+    fn re_firing_the_same_id_only_moves_the_record() {
+        let mut pool = DoodadEmitterPool::default();
+        let d = doodads(1)[0];
+        pool.register(d, 3378, Vec3::ZERO, Vec3::ZERO);
+        pool.register(d, 3378, Vec3::new(1.0, 2.0, 3.0), Vec3::ZERO);
+        assert_eq!(pool.entries[0].records.len(), 1);
+        assert_eq!(pool.entries[0].records[0].pos, Vec3::new(1.0, 2.0, 3.0));
+    }
+
+    /// `bellows.m2`: two `$DSL` keys on one looping sequence alternate through the doodad's single
+    /// handle, rather than droning together.
+    #[test]
+    fn a_different_id_moves_the_doodads_one_registration() {
+        let mut pool = DoodadEmitterPool::default();
+        let d = doodads(1)[0];
+        pool.register(d, 1000, Vec3::ZERO, Vec3::ZERO);
+        pool.register(d, 2000, Vec3::ZERO, Vec3::ZERO);
+        assert_eq!(pool.entries.iter().filter(|e| e.id != 0).count(), 1);
+        assert_eq!(pool.entries.iter().find(|e| e.id != 0).unwrap().id, 2000);
+    }
+
+    /// Releasing the last record frees the entry (`0x461d20`) so another id can claim it.
+    #[test]
+    fn the_last_release_frees_the_entry() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(2);
+        pool.register(ds[0], 42, Vec3::ZERO, Vec3::ZERO);
+        pool.register(ds[1], 42, Vec3::ZERO, Vec3::ZERO);
+        pool.release(ds[0]);
+        assert_eq!(pool.entries[0].id, 42, "one emitter left: the id stays");
+        pool.release(ds[1]);
+        assert_eq!(pool.entries[0].id, 0);
+        assert!(pool.handles.is_empty());
+    }
+
+    /// §17: a 33rd distinct id is UNTRACKED — the registration fails outright rather than evicting
+    /// an incumbent. `$DSL` re-fires every cycle, so it takes an entry the moment one frees.
+    #[test]
+    fn a_thirty_third_distinct_id_is_untracked_until_an_entry_frees() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(POOL_ENTRIES as u32 + 1);
+        for (i, d) in ds.iter().enumerate() {
+            pool.register(*d, 100 + i as u32, Vec3::ZERO, Vec3::ZERO);
+        }
+        assert_eq!(pool.handles.len(), POOL_ENTRIES);
+        let late = ds[POOL_ENTRIES];
+        assert!(!pool.handles.contains_key(&late));
+
+        pool.release(ds[0]);
+        pool.register(late, 100 + POOL_ENTRIES as u32, Vec3::ZERO, Vec3::ZERO);
+        assert_eq!(pool.entries[0].id, 100 + POOL_ENTRIES as u32);
+    }
+
+    /// `0x461a60` — first-farther-than-the-newcomer, in claim order. Not an LRU, and not the
+    /// farthest: the FIRST record farther than the incoming one goes.
+    #[test]
+    fn the_two_hundred_and_fifty_seventh_record_evicts_the_first_farther_one() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(RECORDS_PER_ENTRY as u32 + 1);
+        // Records 0..255 at x = 255 down to 0: record 0 is the farthest, record 255 the nearest.
+        for (i, d) in ds.iter().take(RECORDS_PER_ENTRY).enumerate() {
+            let x = (RECORDS_PER_ENTRY - 1 - i) as f32;
+            pool.register(*d, 9, Vec3::new(x, 0.0, 0.0), Vec3::ZERO);
+        }
+        assert_eq!(pool.entries[0].records.len(), RECORDS_PER_ENTRY);
+
+        // A newcomer at x = 10 is nearer than record 0 (x = 255), so record 0 — the first one
+        // farther than it — is the victim, and the newcomer takes the tail slot.
+        let late = ds[RECORDS_PER_ENTRY];
+        pool.register(late, 9, Vec3::new(10.0, 0.0, 0.0), Vec3::ZERO);
+        assert_eq!(pool.entries[0].records.len(), RECORDS_PER_ENTRY);
+        assert!(
+            !pool.handles.contains_key(&ds[0]),
+            "the evicted one loses its handle"
+        );
+        assert_eq!(
+            pool.entries[0].records[0].pos.x,
+            (RECORDS_PER_ENTRY - 2) as f32
+        );
+        assert_eq!(pool.entries[0].records.last().unwrap().pos.x, 10.0);
+    }
+
+    /// …and one farther than every incumbent is REJECTED, not swapped in.
+    #[test]
+    fn a_record_farther_than_all_of_them_is_rejected() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(RECORDS_PER_ENTRY as u32 + 1);
+        for d in ds.iter().take(RECORDS_PER_ENTRY) {
+            pool.register(*d, 9, Vec3::new(1.0, 0.0, 0.0), Vec3::ZERO);
+        }
+        let late = ds[RECORDS_PER_ENTRY];
+        pool.register(late, 9, Vec3::new(500.0, 0.0, 0.0), Vec3::ZERO);
+        assert_eq!(pool.entries[0].records.len(), RECORDS_PER_ENTRY);
+        assert!(!pool.handles.contains_key(&late));
+    }
+
+    /// The cap picks by ENTRY INDEX — claim order — and stops at four.
+    #[test]
+    fn the_cap_admits_the_first_four_entitled_entries_by_index() {
+        let pool = pool_with(&[(10, 1), (20, 1), (30, 1), (40, 1), (50, 1), (60, 1)]);
+        assert_eq!(admitted(&pool.entries), vec![0, 1, 2, 3]);
+    }
+
+    /// Free, emitter-less and failed entries are not entitled and cost the cap nothing — the
+    /// entry after them moves up.
+    #[test]
+    fn unentitled_entries_do_not_consume_a_cap_slot() {
+        let mut pool = pool_with(&[(10, 1), (0, 0), (30, 0), (40, 1), (50, 1), (60, 1), (70, 1)]);
+        pool.entries[3].failed = true;
+        assert_eq!(admitted(&pool.entries), vec![0, 4, 5, 6]);
+    }
+
+    /// The falsifiable half: distance does NOT arbitrate. A fifth id right on top of the listener
+    /// stays silent behind four claimed earlier and far away.
+    #[test]
+    fn distance_never_promotes_a_fifth_entry_over_an_earlier_one() {
+        let mut pool = DoodadEmitterPool::default();
+        let ds = doodads(5);
+        for (i, d) in ds.iter().enumerate().take(4) {
+            pool.register(*d, 100 + i as u32, Vec3::new(400.0, 0.0, 0.0), Vec3::ZERO);
+        }
+        pool.register(ds[4], 999, Vec3::ZERO, Vec3::ZERO);
+        let admitted = admitted(&pool.entries);
+        assert_eq!(admitted, vec![0, 1, 2, 3]);
+        assert!(
+            !admitted.contains(&4),
+            "the near fifth is held back by claim order"
+        );
+    }
+}
diff --git a/crates/benilla-app/src/sound/kit.rs b/crates/benilla-app/src/sound/kit.rs
index 9a1180bd..43d74765 100644
--- a/crates/benilla-app/src/sound/kit.rs
+++ b/crates/benilla-app/src/sound/kit.rs
@@ -308,6 +308,21 @@ const BUS_CAP: [u32; 13] = [0x7fff_ffff, 1, 2, 2, 1, 1, 2, 2, 1, 6, 4, 1, 2];
 /// for why this is ours to add rather than a fidelity port.
 const SAME_KIT_MAX: usize = 2;
 
+/// The reference's own per-id suppressor: kit flag `0x20` set AND a same-kit instance still
+/// audible (`0x458f40` lifts `SoundEntries +0x7c` bit 0x20 into the FMOD flags word, consumed by
+/// the pre-play gate `0x7a66a0`). Named rather than inlined so the tests read the *gate*, not a
+/// copy of it.
+fn no_duplicates_blocks(dedupe_exempt: bool, flags: u32, live_same_kit: usize) -> bool {
+    !dedupe_exempt && flags & sound_kit_flags::NO_DUPLICATES != 0 && live_same_kit > 0
+}
+
+/// [`SAME_KIT_MAX`], decision 1560's looser fallback for the 1 847 rows the reference left
+/// ungated. Both suppressors belong to the **one-shot lane**; see [`PlayExtras::dedupe_exempt`]
+/// for the caller that is exempt from them and why.
+fn same_kit_cap_blocks(dedupe_exempt: bool, live_same_kit: usize) -> bool {
+    !dedupe_exempt && live_same_kit >= SAME_KIT_MAX
+}
+
 /// The reference's **global voice ceiling** — the number this whole hunt came down to.
 ///
 /// `FSOUND_Init(44100, 12, 0x82)` (wow-re `sound/scratch/voice-cap-and-headroom.md` §5, VERIFIED
@@ -467,6 +482,19 @@ pub(super) struct PlayExtras {
     /// Loop regardless of the kit's own 0x200 flag, for the drivers whose *column* is the loop
     /// authority (the creature body-loop; see [`play_kit_ext`]'s own note).
     pub(super) force_loop: bool,
+    /// **Skip the per-id duplicate suppressors** — the kit's own `NO_DUPLICATES` flag and
+    /// [`SAME_KIT_MAX`]. Those are the **one-shot lane's** gate (`0x458f40` lifting `SoundEntries`
+    /// bit 0x20 into the FMOD flags word, consumed by `0x7a66a0`), and a caller that already
+    /// guarantees one channel per kit by construction must not be held to it a second time. The
+    /// ambient emitter pool ([`super::doodad_pool`]) is that caller: it dedupes **structurally**,
+    /// one entry per SoundEntries id (wow-re `doodad-sound-emitters.md` §15), and its opens go
+    /// through `0x7a5680` → `0x7a54d0`, which never reaches that gate at all.
+    ///
+    /// It is not a nicety. `NightElfStreetLampLoop` is Flags **0x220**, so with the gate applied a
+    /// pool entry could not replace its own 3.0 s fade-out — the lamp's hum would drop out for
+    /// three seconds every time its entry was re-admitted past the cap, and 2 776 of the 4 623
+    /// shipped rows carry the bit.
+    pub(super) dedupe_exempt: bool,
     /// Which per-unit latch this play takes, if any ([`Latch`]). Defaults to [`Latch::None`] —
     /// tagging a `source` is about ownership, and taking a latch has to be asked for.
     pub(super) latch: Latch,
@@ -553,6 +581,7 @@ pub(super) fn play_kit_ext(
         variant,
         source,
         force_loop,
+        dedupe_exempt,
         latch,
         bus,
         volume_mult: Volume(mult),
@@ -609,7 +638,8 @@ pub(super) fn play_kit_ext(
     // still audible (0x458f40 lifts SoundEntries +0x7c bit 0x20 into the FMOD flags word). The
     // gate's OTHER arm — an always-on per-category concurrent cap (count[0xcf553c] >=
     // limit[0x87ce60], 13 categories) — stays a deferral until that limit table is read out.
-    if flags & sound_kit_flags::NO_DUPLICATES != 0 && out.channels.iter().any(|c| c.kit == id) {
+    let live_same_kit = out.channels.iter().filter(|c| c.kit == id).count();
+    if no_duplicates_blocks(dedupe_exempt, flags, live_same_kit) {
         return Ok(());
     }
 
@@ -630,7 +660,7 @@ pub(super) fn play_kit_ext(
     // reference's own idea applied, more loosely, where the data left a hole. Two rather than one
     // deliberately: it keeps some sense that several things happened (and cannot silence two
     // genuinely distinct mobs' impacts), while removing the coherent stack that does the damage.
-    if out.channels.iter().filter(|c| c.kit == id).count() >= SAME_KIT_MAX {
+    if same_kit_cap_blocks(dedupe_exempt, live_same_kit) {
         out.copies_dropped += 1;
         return Ok(());
     }
@@ -806,6 +836,13 @@ pub(super) fn source_kit_playing(out: &SoundOutput, source: Entity, kit_id: u32)
         .any(|c| c.source == Some(source) && c.kit == kit_id)
 }
 
+/// The kit's catalog name, or `None` when the id resolves to no `SoundEntries` row — the
+/// reference's `0x45cda0(id)` null test, which is what permanently fails a doodad emitter pool
+/// entry (`[+0xE00] = -id`). The pool is outside this module, and the catalog is not.
+pub(super) fn kit_name(kits: &SoundKits, id: u32) -> Option<&str> {
+    kits.catalog.get(id).map(|k| k.name.as_str())
+}
+
 /// Whether kit `id` is a LOOPING kit (`SoundEntries` flag 0x200) — the client's `0x458830` test
 /// that splits tracked-loop playback from fire-and-forget one-shots (decision 0107).
 pub(super) fn kit_looping(kits: &SoundKits, id: u32) -> bool {
@@ -842,7 +879,11 @@ pub(super) fn stop_source_kit(out: &mut SoundOutput, source: Entity, kit_id: u32
 
 /// Force-stop every channel tagged with `source` — the unit-teardown stop (`0x5fbb6c`: the client
 /// stops + clears the greeting handle when the unit's record is torn down). Called on despawn.
-pub(super) fn stop_source(out: &mut SoundOutput, source: Entity) {
+/// Returns **how many channels it actually stopped** — the caller's only way to tell "this source
+/// held a loop and we reaped it" from "this source was silent", which is the pair a streaming
+/// retest has to distinguish (the doodad reaper in [`super::anim_events`]).
+pub(super) fn stop_source(out: &mut SoundOutput, source: Entity) -> usize {
+    let before = out.channels.len();
     out.channels.retain_mut(|c| {
         if c.source == Some(source) {
             c.handle.stop(mixer::declick());
@@ -851,6 +892,7 @@ pub(super) fn stop_source(out: &mut SoundOutput, source: Entity) {
             true
         }
     });
+    before - out.channels.len()
 }
 
 /// The `PlaySoundFile` path — a raw file play, no kit: no audibility/duplicate gates, no
@@ -1442,8 +1484,10 @@ mod tests {
     /// [`SAME_KIT_MAX`] however many targets the buff had.
     #[test]
     fn a_mass_buff_collapses_to_the_same_kit_cap() {
-        // What the gate sees: N already-live copies of kit 3116, asked for one more.
-        let live_copies = |n: usize| n >= SAME_KIT_MAX;
+        // What the gate sees: N already-live copies of kit 3116, asked for one more. The real
+        // predicate, not a restatement of it — a mirrored copy here would keep passing after the
+        // gate itself changed.
+        let live_copies = |n: usize| same_kit_cap_blocks(false, n);
         assert!(!live_copies(0), "the first copy always plays");
         assert!(
             !live_copies(1),
@@ -1458,6 +1502,35 @@ mod tests {
         }
     }
 
+    /// **The lane split.** Both suppressors are the ONE-SHOT lane's (`0x458f40` → `0x7a66a0`);
+    /// the ambient emitter pool's opens go through `0x7a5680` → `0x7a54d0` and never reach them
+    /// (wow-re `doodad-sound-emitters.md` §15), because that lane already guarantees one channel
+    /// per SoundEntries id structurally.
+    ///
+    /// `NightElfStreetLampLoop` is the case that proves it matters rather than tidies: Flags
+    /// **0x220**, so an un-exempt pool entry could not replace its own 3.0 s fade-out — the lamp's
+    /// hum would drop out for three seconds every time its entry came back under the cap.
+    #[test]
+    fn the_emitter_pool_lane_is_exempt_from_the_one_shot_suppressors() {
+        const LAMP: u32 = 0x220;
+        assert!(
+            no_duplicates_blocks(false, LAMP, 1),
+            "the one-shot lane still honours the reference's own 0x20"
+        );
+        assert!(
+            !no_duplicates_blocks(true, LAMP, 1),
+            "a pool entry must be able to replace its own fading channel"
+        );
+        assert!(
+            !same_kit_cap_blocks(true, 8),
+            "…and the coherent-copy fallback is the same lane's, so it is exempt too"
+        );
+        assert!(
+            same_kit_cap_blocks(false, SAME_KIT_MAX),
+            "the exemption is scoped to the caller that asks for it, not global"
+        );
+    }
+
     /// The looser cap only exists for rows the reference left ungated. A row carrying flag 0x20 is
     /// still capped at **one** by the byte-verified gate above it, and this must not loosen that.
     #[test]
diff --git a/crates/benilla-app/src/sound/missile.rs b/crates/benilla-app/src/sound/missile.rs
index 96466212..7da4f859 100644
--- a/crates/benilla-app/src/sound/missile.rs
+++ b/crates/benilla-app/src/sound/missile.rs
@@ -61,7 +61,9 @@ fn route_missile_sounds(
                 }
             }
             // The missile carries only this one channel — stop everything tagged to it.
-            MissileSound::Stop { entity } => stop_source(&mut out, entity),
+            MissileSound::Stop { entity } => {
+                stop_source(&mut out, entity);
+            }
         }
     }
 }
diff --git a/crates/benilla-app/src/sound/mod.rs b/crates/benilla-app/src/sound/mod.rs
index 6351b288..46c2efdb 100644
--- a/crates/benilla-app/src/sound/mod.rs
+++ b/crates/benilla-app/src/sound/mod.rs
@@ -18,6 +18,7 @@ mod anim_events;
 mod cinematic;
 mod combat;
 mod creature;
+mod doodad_pool;
 mod emote;
 pub(crate) mod footsteps;
 mod gameobject;
@@ -458,6 +459,7 @@ impl Plugin for SoundPlugin {
         cinematic::plugin(app);
         gameobject::plugin(app);
         anim_events::plugin(app);
+        doodad_pool::plugin(app);
         spell::plugin(app);
         missile::plugin(app);
         creature::plugin(app);
diff --git a/crates/benilla-app/src/target/reticle.rs b/crates/benilla-app/src/target/reticle.rs
index ac6019ba..8309722e 100644
--- a/crates/benilla-app/src/target/reticle.rs
+++ b/crates/benilla-app/src/target/reticle.rs
@@ -46,12 +46,6 @@ const RETICLE_DEFAULT_RADIUS: f32 = 1.388_889;
 /// The projection box's vertical slab: ± 2.0 around the picked point (`0x4837b0` — fixed, not
 /// radius-scaled like the ring's).
 const RETICLE_VERT: f32 = 2.0;
-/// Same coplanarity treatment as the ring (`sky_order::Rung::GROUND_FX` rationale) — the
-/// *rasterizer* half only. The reticle's sort rung is `Rung::RETICLE`, in the pre-water decal
-/// band: the reference draws this pass at `0x4836c5` with flags `0x200122`, before the water
-/// (B347). Its liquid-receiver twin at `0x483727` is the half that draws after the water, and it
-/// has no counterpart here until liquid becomes a receiving surface.
-const RETICLE_RASTER_BIAS: i32 = 8192;
 
 /// The two state textures (the render-side residency gate withholds the draw until loaded).
 #[derive(Resource)]
@@ -197,7 +191,14 @@ pub(super) fn push_reticle(
     let mut batch = draw
         .batch(cam, texture)
         .anchored(state.key.center)
-        .rung(benilla_world::sky_order::Rung::RETICLE, RETICLE_RASTER_BIAS);
+        // Sort rung from the pre-water decal band — the reference draws this pass at `0x4836c5`
+        // with flags `0x200122`, before the water (B347); its liquid-receiver twin at `0x483727`
+        // is the half that draws after it, and has no counterpart here until liquid becomes a
+        // receiving surface. Raster margin from the family's shared coplanarity constant.
+        .rung(
+            benilla_world::sky_order::Rung::RETICLE,
+            benilla_world::sky_order::Rung::DECAL_RASTER,
+        );
     batch.extend(state.verts.iter().map(|v| EffectVertex {
         pos: v.pos,
         uv: v.uv,
diff --git a/crates/benilla-app/src/target/ring.rs b/crates/benilla-app/src/target/ring.rs
index 3edc5bee..40617b80 100644
--- a/crates/benilla-app/src/target/ring.rs
+++ b/crates/benilla-app/src/target/ring.rs
@@ -508,7 +508,7 @@ pub(super) fn push_ring(
         .anchored(state.key.feet)
         .rung(
             benilla_world::sky_order::Rung::RING,
-            benilla_world::sky_order::Rung::RING as i32,
+            benilla_world::sky_order::Rung::DECAL_RASTER,
         );
     batch.extend(state.verts.iter().map(|v| EffectVertex {
         pos: v.pos,
diff --git a/crates/benilla-assets/src/shaders/liquid.wgsl b/crates/benilla-assets/src/shaders/liquid.wgsl
index b9583394..0c6020a1 100644
--- a/crates/benilla-assets/src/shaders/liquid.wgsl
+++ b/crates/benilla-assets/src/shaders/liquid.wgsl
@@ -145,6 +145,12 @@ struct LiquidVsOut {
     // colour — the reference's own interior water vertex carries a colour dword for exactly this.
     // White on every other lane (and on any mesh with no colour attribute), where nothing reads it.
     @location(5) vcolor: vec4<f32>,
+    // The per-frame INTERIOR FOG lane for this surface's own room (decision 1787): the client's
+    // `[0xca7f00]`, which gates the WMO liquid pass's block-2 submit (`0x6b6323`–`0x6b6342`)
+    // exactly as it gates the geometry pass — so a pool and the walls around it can never
+    // disagree about which fog they wear. Carried on `MeshTag` bit 30, read once in the vertex
+    // stage and flat-interpolated (the whole surface is one instance).
+    @location(6) @interpolate(flat) room_fog: u32,
 }
 
 // Sun sheen (`secondary`): a Blinn highlight of the sun on the flat water surface — the glint that's
@@ -233,13 +239,14 @@ fn apply_scroll(uv: vec2<f32>) -> vec2<f32> {
 // interior haze. Only two call sites in the whole binary re-submit block 2, and they are the WMO
 // *geometry* pass (`0x6b51d9`/`0x6b51ea`) and the WMO *liquid* pass (`0x6b6323`–`0x6b6342`), both under
 // the same `[0xca7f00]` gate. So an interior room's pool takes the room's fog, in lockstep with the
-// walls around it; ADT liquid submits nothing and draws under the scene block. `w.kind.z` is that
-// gate, resolved at spawn from the group's `MOGI & 0x48` — the same interior test `wow_model.wgsl`
-// uses, which is what keeps the two in step.
-fn apply_fog(rgb: vec3<f32>, world_pos: vec3<f32>) -> vec3<f32> {
+// walls around it; ADT liquid submits nothing and draws under the scene block. `w.kind.z` is the STATIC
+// half of that gate, resolved at spawn from the group's `MOGI & 0x48`; the per-frame half is the
+// room's own `[0xca7f00]` bit on `MeshTag` bit 30 (decision 1787 — the flood decides it, and the
+// WMO geometry lane reads the same answer, which is what keeps the two in step).
+fn apply_fog(rgb: vec3<f32>, world_pos: vec3<f32>, room_fog: u32) -> vec3<f32> {
     var fog_color = wow_light.fog_color;
     var fog_span = wow_light.fog_params.xy;
-    if (w.kind.z > 0.5) {
+    if (w.kind.z > 0.5 && room_fog != 0u) {
         fog_color = wow_light.wmo_fog_color;
         fog_span = wow_light.wmo_fog_params.xy;
     }
@@ -270,6 +277,9 @@ fn vertex(in: Vertex) -> LiquidVsOut {
     out.depth = in.uv_b.x;
     // The faithful per-vertex sun sheen — interpolated across the coarse mesh by the fragment stage.
     out.secondary_vtx = sun_sheen(out.world_normal, out.world_position.xyz);
+    // `MeshTag` bit 30 — see `LiquidVsOut::room_fog`. ADT surfaces carry no tag (0 ⇒ scene fog,
+    // which is their only lane anyway).
+    out.room_fog = mesh_functions::get_tag(in.instance_index) & 0x40000000u;
     return out;
 }
 
@@ -309,7 +319,7 @@ fn fragment(in: LiquidVsOut) -> @location(0) vec4<f32> {
     // depth instead of one that recedes into the murk. (VERIFIED wow-re `liquid-render-state-sided`
     // §3/§3.1/§5, which corrects that row.)
     if (w.kind.x > 0.5) {
-        return vec4<f32>(apply_fog(detail.rgb, in.world_position.xyz), 1.0);
+        return vec4<f32>(apply_fog(detail.rgb, in.world_position.xyz, in.room_fog), 1.0);
     }
 
     // Per-vertex swatch coord V (in `in.depth`, computed CPU-side in wow-formats/liquid.rs): river/lake
@@ -362,7 +372,7 @@ fn fragment(in: LiquidVsOut) -> @location(0) vec4<f32> {
         // reading would have drawn.
         let body = clamp(in.vcolor.rgb + detail.rgb, vec3<f32>(0.0), vec3<f32>(1.0));
         return vec4<f32>(
-            apply_fog(body, in.world_position.xyz),
+            apply_fog(body, in.world_position.xyz, in.room_fog),
             clamp(vtx_alpha + detail.a, 0.0, 1.0),
         );
     }
@@ -414,7 +424,7 @@ fn fragment(in: LiquidVsOut) -> @location(0) vec4<f32> {
         let rgb_ext = primary_ext + detail.rgb + in.secondary_vtx * detail.a;
         // `result.color.w = fragment.color.primary` — the vertex alpha ALONE. The bound program
         // bypasses the texture environment entirely, so the interior arm's `+ At` does not apply here.
-        return vec4<f32>(apply_fog(rgb_ext, in.world_position.xyz), vtx_alpha);
+        return vec4<f32>(apply_fog(rgb_ext, in.world_position.xyz, in.room_fog), vtx_alpha);
     }
 
     // Body colour: lit vertex colour × the depth-lerped water-row swatch colour (`primary·colorTex`).
@@ -447,7 +457,7 @@ fn fragment(in: LiquidVsOut) -> @location(0) vec4<f32> {
 
     // Distance fog (see `apply_fog`) — the water fog colour is also teal, so far water converges on the
     // haze.
-    rgb = apply_fog(rgb, in.world_position.xyz);
+    rgb = apply_fog(rgb, in.world_position.xyz, in.room_fog);
 
     // GAMMA LANE (0161): raw gamma out; alpha blends in gamma like the reference's bytes.
     return vec4<f32>(rgb, alpha);
diff --git a/crates/benilla-assets/src/shaders/wow_model.wgsl b/crates/benilla-assets/src/shaders/wow_model.wgsl
index e44deaf6..c5964ed2 100644
--- a/crates/benilla-assets/src/shaders/wow_model.wgsl
+++ b/crates/benilla-assets/src/shaders/wow_model.wgsl
@@ -1088,16 +1088,21 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // — the level-up fix), WHITE for Mod, GREY for Mod2x; policy 4 (render flag 0x02) = unfogged.
     // Encoded in clutter_fade.z bits 4-6.
     // Interior lanes fog with the INTERIOR triple — the room keeps its warm MFOG haze while the
-    // storm's veil stays on everything seen through the door. Two routes in: the MATERIAL flag
-    // (WMO interior-group batches and their doodad props, m.model_flags.z — round-6 Q-I:
-    // `0x6b5190`/`0x6b62e0` push DNState+0x80/84/88) and the per-INSTANCE tag bit 30 (an entity
-    // M2 whose model stands in a WMO interior — the reference stages a unit's fog by the unit's
-    // own light-node classification, `0x71c110`/`[node+0xc]`, wow-re m2-unit-interior-fog.md;
-    // at camera-out the triples are equal, so the bit only diverges inside a fogged WMO).
-    // Every other lane inherits the scene fog.
+    // storm's veil stays on everything seen through the door. ONE route in, the per-INSTANCE tag
+    // bit 30, written by two disjoint owners for the two mechanisms the reference has:
+    //   * room-bound WMO content (group geometry, its doodad props) takes the client's per-group
+    //     `[0xca7f00]` gate on the two interior-fog pushes `0x6b5190`/`0x6b62e0` (round-6 Q-I),
+    //     resolved per frame by the portal flood (`wmo_portal::GroupPvs::interior_fog`);
+    //   * an entity M2 takes its OWN light-node classification (`0x71c110`/`[node+0xc]`, wow-re
+    //     m2-unit-interior-fog.md), which is a different gate on the same triple.
+    // The material's own `model_flags.z` is NOT that test: it is static per batch, so before
+    // decision 1787 every true-interior group in a building wore the building's MFOG the moment
+    // the camera stood anywhere inside it — B335, where the Shadowfang room two exterior-lit
+    // courtyards away read as a flat teal wash at 70 yd. At camera-out the two triples are equal,
+    // so the bit only ever diverges inside a fogged WMO. Every other lane inherits the scene fog.
     var fog_color = wow_light.fog_color;
     var fog_span = wow_light.fog_params.xy;
-    if (m.model_flags.z > 0.5 || interior_fogged) {
+    if (interior_fogged) {
         fog_color = wow_light.wmo_fog_color;
         fog_span = wow_light.wmo_fog_params.xy;
     }
diff --git a/crates/benilla-formats/src/bin/benilla-extract/main.rs b/crates/benilla-formats/src/bin/benilla-extract/main.rs
index 235a8669..732c43d1 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/main.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/main.rs
@@ -486,6 +486,17 @@ enum Command {
         /// Internal-path prefix filter (e.g. `world`), case-insensitive; all models if omitted.
         prefix: Option<String>,
     },
+    /// Sweep every `.m2` and census the **animation-driven sound emitters**: the models whose
+    /// sequences carry a `$DSL` (doodad sound loop) / `$DSO` (doodad sound one-shot) / `$SND`
+    /// (generic one-shot) marker, the `SoundEntries` kit each names with its 3D parameters, and —
+    /// the column this exists for — whether the carrying sequence is REST-posed, i.e. one the
+    /// render content gate (decision 0130) never builds a rig for. A placed lamp's hum is a single
+    /// `$DSL` on a sequence that keys no bone at all, so the whole class is unreachable through an
+    /// `AnimationPlayer`: the population instrument for "every world doodad is silent" (B345).
+    Soundeventscan {
+        /// Internal-path prefix to limit the sweep (e.g. `world`); all models if omitted.
+        prefix: Option<String>,
+    },
     /// Sweep every `.m2` (optionally under a path prefix) and list the models whose PARTICLE
     /// emitters carry any of the given file-flag bits (`M2ParticleEmitter+0x04`) — the
     /// population instrument for particle-flag mechanisms (which content actually authors
@@ -852,6 +863,7 @@ fn main() -> Result<()> {
         Command::Fxordercensus { prefix } => scan::fxordercensus(&mut chain, prefix.as_deref())?,
         Command::Shardcensus { prefix } => scan::shardcensus(&mut chain, prefix.as_deref())?,
         Command::Idleslotscan { prefix } => scan::idleslotscan(&mut chain, prefix.as_deref())?,
+        Command::Soundeventscan { prefix } => scan::soundeventscan(&mut chain, prefix.as_deref())?,
         Command::Partscan { mask, prefix } => {
             let mask = parse_u32_maybe_hex(&mask)
                 .with_context(|| format!("parsing flag mask '{mask}'"))?;
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs b/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
index 70661472..9be1014a 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
@@ -11,7 +11,8 @@
 //!   the batches whose UV/tint loop differs between sequence slots.
 //! - [`particles`] — particle and ribbon emitters, and the features the corpus authors.
 //! - [`skeleton`] — the bone tree and the attachment table that addresses it.
-//! - [`sequence`] — which sequence an arm plays, and what breaks when it is the wrong one.
+//! - [`sequence`] — which sequence an arm plays, what breaks when it is the wrong one, and
+//!   which of its event markers an arm can reach at all.
 //!
 //! Split out of a single 3.9k-line `scan.rs` once it had grown ~30 independent sweeps: the file
 //! was one *kind* of thing, but not one concern, and nothing in it was shared across families
@@ -34,7 +35,7 @@ pub use material::{alphascan, blendscan, envmapscan, texmodescan, uvslotscan, uv
 pub use particles::{
     cellscan, fxordercensus, partcensus, partscan, partslotscan, ribbonscan, shardcensus,
 };
-pub use sequence::{fxlifescan, goanimscan, idleslotscan, seqclockscan};
+pub use sequence::{fxlifescan, goanimscan, idleslotscan, seqclockscan, soundeventscan};
 pub use skeleton::{attachscan, bonescan};
 pub use world::{doodadscan, placescan, skyboxscan, wmodoodads};
 
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan/sequence.rs b/crates/benilla-formats/src/bin/benilla-extract/scan/sequence.rs
index 4f77789e..7033a5a4 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/sequence.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/sequence.rs
@@ -4,6 +4,10 @@
 //! The GameObject substate arm (`goanimscan`), the effect-model Stand/Hold/Decay lifecycle
 //! (`fxlifescan`), the loader-idle slot the per-sequence bakes degrade away from (`idleslotscan`),
 //! and the models with no keyed bone at all, so no clock ever advances (`seqclockscan`).
+//!
+//! Plus the arm's *reach*: which models author a sound-event marker the rig gate never arms
+//! (`soundeventscan`) — the same failure one level down, where the sequence is right and nothing
+//! runs its clock.
 
 use std::collections::{BTreeMap, HashSet};
 
@@ -597,3 +601,147 @@ pub fn seqclockscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
     );
     Ok(())
 }
+
+/// Sweep every `.m2` and census the **animation-driven sound emitters**: the models whose
+/// sequences carry a `$DSL` (doodad sound loop) / `$DSO` (doodad sound one-shot) / `$SND` (generic
+/// one-shot) event marker, the `SoundEntries` kit each names, and — the column this exists for —
+/// whether the carrying sequence is **rest-posed**.
+///
+/// Why that column decides everything: `benilla_assets`' render content gate
+/// (`idle_pose_differs` → [`benilla_formats::ModelAnimation::is_rest_pose`], decision 0130) skips
+/// building a rig for a sequence that would render as the static mesh, and the whole point of
+/// that gate is that it is a question **about pixels only**. A placed lamp's Stand band keys no
+/// bone at all — it is pure rest pose — yet it carries the one `$DSL` marker that is its hum. So
+/// every model in the `REST` column is one whose sound the arm can never reach through a rig: its
+/// events need a clock that does not depend on there being anything to animate.
+///
+/// Reports the per-model rows, then a tag/kit histogram and the `REST`-gated share.
+pub fn soundeventscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
+    const SOUND_TAGS: [&[u8; 4]; 3] = [b"$DSL", b"$DSO", b"$SND"];
+    let kits = benilla_formats::load_sound_kit_catalog(chain).ok();
+    let names = super::m2_names(chain, prefix)?;
+    let (mut scanned, mut carriers, mut rest_gated, mut hostless) = (0u32, 0u32, 0u32, 0u32);
+    let mut per_tier: BTreeMap<&str, u32> = BTreeMap::new();
+    let mut per_tag: BTreeMap<String, (u32, u32)> = BTreeMap::new(); // tag -> (markers, rest-gated)
+    let mut per_kit: BTreeMap<u32, u32> = BTreeMap::new();
+    for name in names {
+        let Ok(bytes) = chain.read_file(&name) else {
+            continue;
+        };
+        let anims = benilla_formats::parse_m2_animations(&bytes);
+        if anims.is_empty() {
+            continue;
+        }
+        scanned += 1;
+        // The spawn tier `benilla_world::doodad_anim::classify` would give this model, from the
+        // same three inputs it reads: a boneless model is `Static` outright (the 0035 guard);
+        // otherwise the 0130 content gate picks `FirstSeq` when the loader-idle clip's pose
+        // differs from bind, else `GlobalSeqOnly` when free-running channels exist, else
+        // `Static`. `is_rest_pose` is the gate's own predicate (decision 0936 pushed it down
+        // beside the parse so this census cannot drift from it); the tier matters here because
+        // only the two animated tiers get an anim-root ENTITY at all — a `Static` carrier has
+        // nothing but loose submeshes to hang an emitter on.
+        let bones = benilla_m2::parse_m2(&mut std::io::Cursor::new(&bytes))
+            .map_or(0, |f| f.model().bones.len());
+        let idle_id = benilla_formats::parse_m2_playable_animation_lookup(&bytes)
+            .unwrap_or_default()
+            .first()
+            .map_or(0, |p| p.resolved_id);
+        let gseq = !benilla_formats::parse_m2_global_sequence_bones(&bytes).is_empty();
+        let tier = if bones == 0 {
+            "Static"
+        } else if anims
+            .iter()
+            .any(|a| a.anim_id == idle_id && !a.is_rest_pose())
+        {
+            "FirstSeq"
+        } else if gseq {
+            "GlobalSeq"
+        } else {
+            "Static"
+        };
+        let mut rows = Vec::new();
+        let mut model_rest_gated = false;
+        for a in &anims {
+            let marks: Vec<_> = a
+                .events
+                .iter()
+                .filter(|e| SOUND_TAGS.contains(&&e.ident))
+                .collect();
+            if marks.is_empty() {
+                continue;
+            }
+            // The gate is asked of the sequence that CARRIES the marker: that is the one whose
+            // clock has to run for the marker to be reached at all.
+            let rest = a.is_rest_pose();
+            model_rest_gated |= rest;
+            for e in &marks {
+                let tag = String::from_utf8_lossy(&e.ident).into_owned();
+                let slot = per_tag.entry(tag).or_default();
+                slot.0 += 1;
+                slot.1 += u32::from(rest);
+                *per_kit.entry(e.data).or_default() += 1;
+            }
+            let list: Vec<String> = marks
+                .iter()
+                .map(|e| {
+                    let tag = String::from_utf8_lossy(&e.ident);
+                    let kit = kits
+                        .as_ref()
+                        .and_then(|c| c.get(e.data))
+                        .map_or_else(|| "?".to_string(), |k| k.name.clone());
+                    format!("{:.3}s {tag}({}) {kit}", e.time, e.data)
+                })
+                .collect();
+            rows.push(format!(
+                "    seq {:>2} anim {:>3} {:<5} {:>6.3}s  {}  {}",
+                a.seq_index,
+                a.anim_id,
+                if a.looping { "loop" } else { "clamp" },
+                a.duration,
+                if rest { "REST" } else { "rig " },
+                list.join(", "),
+            ));
+        }
+        if rows.is_empty() {
+            continue;
+        }
+        carriers += 1;
+        rest_gated += u32::from(model_rest_gated);
+        *per_tier.entry(tier).or_default() += 1;
+        if tier == "Static" {
+            hostless += 1;
+        }
+        println!("{name}  [{tier}]");
+        for r in rows {
+            println!("{r}");
+        }
+    }
+    println!("\n=== tag histogram (markers, and how many sit on a REST-posed sequence) ===");
+    for (tag, (n, rest)) in &per_tag {
+        println!("  {tag}  {n:>5} marker(s), {rest:>5} on a REST-posed sequence");
+    }
+    println!("\n=== distinct sound kits named ({}) ===", per_kit.len());
+    for (id, n) in &per_kit {
+        let k = kits.as_ref().and_then(|c| c.get(*id));
+        println!(
+            "  {id:>6}  x{n:<4} {:<40} vol {:>4.2}  minDist {:>7.2}  cutoff {:>8.2}  flags 0x{:03x}",
+            k.map_or("MISSING", |k| k.name.as_str()),
+            k.map_or(0.0, |k| k.volume),
+            k.map_or(0.0, |k| k.min_distance),
+            k.map_or(0.0, |k| k.distance_cutoff),
+            k.map_or(0, |k| k.flags),
+        );
+    }
+    println!("\n=== spawn tier of the carriers ===");
+    for (t, n) in &per_tier {
+        println!("  {t:<10} {n:>4} model(s)");
+    }
+    eprintln!(
+        "{scanned} models with sequences scanned; {carriers} carry a $DSL/$DSO/$SND marker, \
+         {hostless} of them on the Static tier (no anim-root entity exists to hang an emitter \
+         on today); {rest_gated} carry the marker on a REST-posed sequence — the class benilla's rig gate \
+         (decision 0130) never arms, so the marker is unreachable through an AnimationPlayer."
+    );
+    Ok(())
+}
diff --git a/crates/benilla-formats/src/models/anim.rs b/crates/benilla-formats/src/models/anim.rs
index 2efaed15..cbee6aea 100644
--- a/crates/benilla-formats/src/models/anim.rs
+++ b/crates/benilla-formats/src/models/anim.rs
@@ -1422,3 +1422,90 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod doodad_sound_tests {
+    /// **The humming lamp, off the real 5875 chain** — bug B345's diagnosis, pinned as data.
+    ///
+    /// `KalidarStreetLamp01.m2` is the shape the whole doodad-ambience class takes, and every
+    /// clause here is a claim the fix rests on:
+    ///
+    /// * it has **one** sequence, `AnimationData` id 0 (Stand), **looping** — so the marker on it
+    ///   is crossed once per cycle, for ever;
+    /// * that sequence is **rest-posed** — it keys no bone at all, so decision 0130's render
+    ///   content gate builds it no rig, which is correct about pixels and was never a statement
+    ///   about the clock. Gating the *event* track on that gate is what made the lamp silent;
+    /// * it carries exactly **one** event, `$DSL` at t = 0.000 with payload **3378** — the
+    ///   `SoundEntries` id of `NightElfStreetLampLoop`.
+    ///
+    /// If any of these stops holding, the fix's premise has moved and the test should fail loudly
+    /// rather than let the lamp go quiet again.
+    #[test]
+    fn the_lamps_hum_is_one_rest_posed_looping_dsl_key() {
+        let data = crate::wow_data_or_skip!();
+        let mut chain = crate::open_chain(&data).expect("open chain");
+        let bytes = chain
+            .read_file("World\\Generic\\NightElf\\Passive Doodads\\Lamps\\KalidarStreetLamp01.m2")
+            .expect("the lamp is in the chain");
+        let seqs = super::parse_m2_animations(&bytes);
+        assert_eq!(seqs.len(), 1, "one authored sequence");
+
+        let stand = &seqs[0];
+        assert_eq!(stand.anim_id, 0, "Stand");
+        assert!(stand.looping, "the hum's carrier loops");
+        assert!(
+            stand.is_rest_pose(),
+            "keys no bone — the rig gate skips it, and that must not silence it"
+        );
+
+        assert_eq!(stand.events.len(), 1, "exactly one event key");
+        let ev = &stand.events[0];
+        assert_eq!(&ev.ident, b"$DSL", "a doodad sound LOOP tag");
+        assert_eq!(ev.data, 3378, "SoundEntries NightElfStreetLampLoop");
+        assert!(ev.time.abs() < 1e-6, "keyed at t = 0");
+    }
+
+    /// **The pair that pins the one-handle-per-doodad slot.** `bellows.m2` keys TWO `$DSL` at
+    /// DIFFERENT times on one looping 2 s sequence — `BellowOut` at t = 0.000 and `BellowIN` at
+    /// t = 1.100, each about 1.18 s of audio.
+    ///
+    /// This looked like proof that `$DSL` could not mean "loop" — a pair of one-shots timed to
+    /// alternate. The RE says otherwise, and the real mechanism is better: a doodad holds exactly
+    /// ONE registration (`[CMapDoodadDef+0x168]`), and crossing a marker with a DIFFERENT id
+    /// releases the held one before registering the new (`0x69521d` → `0x461f80`). So both ARE
+    /// ordinary loops, and the slot is what makes them alternate — the pumping bellows. Every
+    /// `$DSL` loops and no flag is consulted (wow-re `sound/scratch/doodad-sound-emitters.md`).
+    ///
+    /// The guard is therefore on the eviction in `sound::anim_events`: without it both start and
+    /// both drone.
+    #[test]
+    fn a_dsl_pair_on_one_cycle_alternates_through_one_slot() {
+        let data = crate::wow_data_or_skip!();
+        let mut chain = crate::open_chain(&data).expect("open chain");
+        let bytes = chain
+            .read_file("World\\Generic\\Human\\Passive Doodads\\Bellows\\bellows.m2")
+            .expect("the bellows is in the chain");
+        let seqs = super::parse_m2_animations(&bytes);
+        let carrier = seqs
+            .iter()
+            .find(|s| s.events.iter().any(|e| &e.ident == b"$DSL"))
+            .expect("a sequence carries the pair");
+        assert!(carrier.looping, "and it loops");
+
+        let mut keys: Vec<_> = carrier
+            .events
+            .iter()
+            .filter(|e| &e.ident == b"$DSL")
+            .map(|e| (e.data, e.time))
+            .collect();
+        keys.sort_by(|a, b| a.1.total_cmp(&b.1));
+        assert_eq!(keys.len(), 2, "a pair sharing one registration slot");
+        assert!(keys[0].1.abs() < 1e-6, "the first is keyed at t = 0");
+        assert!(
+            keys[1].1 > 1.0,
+            "the second is keyed a second later ({:.3}s) — the eviction is what makes it a pump",
+            keys[1].1
+        );
+        assert_ne!(keys[0].0, keys[1].0, "and they are different kits");
+    }
+}
diff --git a/crates/benilla-world/src/doodad_anim/mod.rs b/crates/benilla-world/src/doodad_anim/mod.rs
index 703b229d..25413d1d 100644
--- a/crates/benilla-world/src/doodad_anim/mod.rs
+++ b/crates/benilla-world/src/doodad_anim/mod.rs
@@ -100,6 +100,43 @@ pub enum DoodadAnimTier<'a> {
     FirstSeq(&'a AnimClip),
 }
 
+/// The animation-event tags that make a placed doodad SOUND: `$DSL` (the looping emitter), `$DSO`
+/// (a positioned one-shot), `$DSE` (the stop token that releases a `$DSL` — `data` is 0 on all 16
+/// shipped models) and the generic `$SND`. Routed by `benilla_app::sound::anim_events`; listed here
+/// because their presence is what earns a bind-posed model a clock it would otherwise be denied
+/// (see [`arms_for_sound`]). Byte law: wow-re `sound/scratch/doodad-sound-emitters.md`.
+pub(crate) const SOUND_EVENT_TAGS: [&[u8; 4]; 4] = [b"$DSL", b"$DSO", b"$DSE", b"$SND"];
+
+/// Does this model's **arm chain** — the loader-idle seed and its variations, the only sequences a
+/// placed doodad ever plays — carry a sound-event marker?
+///
+/// This is deliberately NOT part of [`classify`]: the tier answers "what does this model *render*",
+/// and 0130's whole point is that a bind-posed sequence renders as the static mesh. That stays true.
+/// What it never meant is that the sequence does not *run* — the reference arms every placed doodad
+/// and cycles it on residency (module docs, §1/§5), and the event track rides that clock. A humming
+/// lamp is the proof: `KalidarStreetLamp01.m2` is one looping 3.333 s Stand that keys no bone at all
+/// and carries exactly one event, `$DSL` → `NightElfStreetLampLoop`. Gating its clock on the *rig*
+/// is what made every world doodad silent (bug B345), and the corpus says the class is not marginal
+/// — `benilla-extract soundeventscan`: 273 carrier models, 108 of which no rig gate would ever arm.
+///
+/// Same shape as [`ModelAnimations::idle_clip`]'s own note about emitters and material loops: arming
+/// the idle seed is what gives a consumer a running clock instead of a frozen slot-0 read. Sound is
+/// simply the third consumer.
+pub(crate) fn arms_for_sound(anims: &ModelAnimations) -> bool {
+    let Some(idle) = anims.idle_clip() else {
+        return false;
+    };
+    anims
+        .clips
+        .iter()
+        .filter(|c| c.anim_id == idle.anim_id)
+        .any(|c| {
+            c.events
+                .iter()
+                .any(|e| SOUND_EVENT_TAGS.contains(&&e.ident))
+        })
+}
+
 /// Classify a placed model for the spawn site. Boneless models are `Static` regardless of parsed
 /// tracks — their skinned twin carries joint attributes with no joints to index (the 0035 guard).
 pub fn classify<'a>(
@@ -211,10 +248,21 @@ pub fn spawn_anim_host(
         return None;
     }
     let tier = classify(&m.skeleton, m.animations.as_ref());
-    if matches!(tier, DoodadAnimTier::Static) {
+    // The SOUND arm (bug B345), orthogonal to the tier: a model whose pose is bind renders as the
+    // static mesh — 0130's gate is right about pixels — but its event track still has to run, and
+    // the reference runs it for every placed doodad. So a `Static`/`GlobalSeqOnly` model that
+    // authors `$DSL`/`$DSO`/`$SND` on its arm chain still gets a HOST here: `ModelAnimations` and
+    // the arm bookkeeping (`clip`/`anim_id`, which is what [`reroll_doodad_variation`] maintains and
+    // the event scanner reads), and deliberately **no `AnimationPlayer`** — there is no pose to
+    // evaluate, and paying for a rig to run a clock is exactly what 0130 exists to avoid.
+    let sound_arm = m.animations.as_ref().is_some_and(arms_for_sound);
+    if matches!(tier, DoodadAnimTier::Static) && !sound_arm {
         return None;
     }
-    let anims = m.animations.as_ref().expect("animated tier ⇒ animations");
+    let anims = m
+        .animations
+        .as_ref()
+        .expect("animated tier or sound arm ⇒ animations");
     // Chain-only visibility (`crate::vis_chain`): the host root renders nothing — its parts
     // draw as world roots — and ~1.4k hosts sat in the per-camera sweep at the Goldshire pin.
     let root = commands
@@ -237,6 +285,7 @@ pub fn spawn_anim_host(
     let mut armed_seq = None;
     let mut arm_id = None;
     if let DoodadAnimTier::FirstSeq(head) = tier {
+        // (the rigged arm — player + graph + variation chain)
         // The **loader's** seed only — `0x70ebd0`'s var-0 arm on the head of the chain. The real
         // pick is the holder setup's second op4 call (`0x695100`, `variationIdx = -1`), which lands
         // *after* it and is the effective arm (wow-re §4a); here that second arm is
@@ -257,6 +306,20 @@ pub fn spawn_anim_host(
         clip_info = Some((head.node, head.duration));
         armed_seq = Some(head.seq_index);
         arm_id = Some(head.anim_id);
+    } else if sound_arm {
+        // The clock-only arm: same loader seed, same self-sustaining re-roll — `ModelAnimations` is
+        // what [`reroll_doodad_variation`] needs, and without it the host would never be matched by
+        // that query and its window would never advance. No player, no graph handle: nothing here
+        // poses anything, and `gate_doodad_anim` already treats both as optional.
+        let head = anims.idle_clip().expect("sound arm ⇒ an idle clip");
+        clip_info = Some((head.node, head.duration));
+        arm_id = Some(head.anim_id);
+        commands.entity(root).insert(anims.clone());
+        // `armed_seq` stays `None` ON PURPOSE. It is the *only* input to `PlacementHost::arm`,
+        // which is what puts this placement's emitters on `EmitClock::Host` — a clock that reads
+        // the host's `AnimationPlayer`. This host has none, so claiming the arm would move a
+        // previously-`Pinned` emitter onto a player that does not exist. The sound clock is read
+        // from `clip`/`armed_at` instead, which needs no player and no slot number.
     }
     if let Some(drive) = GlobalSeqDrive::new_rig(&anims.global_bones, m.skeleton.joints.len()) {
         commands.entity(root).insert(drive);
@@ -309,6 +372,31 @@ pub struct DoodadAnimHost {
     pub(crate) parked_at: f32,
 }
 
+impl DoodadAnimHost {
+    /// Where the **armed clip's own clock** stands right now: `(node, seek)`, the seek being
+    /// `(now − armed_at) mod duration`. `None` when nothing is armed (the gseq-only tier without a
+    /// sound arm — free-running channels have no window at all).
+    ///
+    /// The **shared clock, never the `AnimationPlayer`**, and that is the point rather than a
+    /// convenience. The player is paused by [`gate_doodad_anim`] whenever none of the placement's
+    /// submeshes is drawn; the reference's animation cycle is gated on **linkage — residency, not
+    /// the draw** (module docs §5, the same reasoning [`reroll_doodad_variation`] runs over every
+    /// host for). A campfire behind you keeps crackling in the real client, and reading the paused
+    /// player here would stop it the moment you turned around. It also gives the two arms one
+    /// answer: a clock-only host has no player to read, and a rigged one's resume seeks to exactly
+    /// this value, so the two never disagree while drawn.
+    pub fn arm_clock(&self, now: f32) -> Option<(AnimationNodeIndex, f32)> {
+        let (node, duration) = self.clip?;
+        // A zero-length clip has no phase to compute; it sits at its own t = 0.
+        let seek = if duration > 0.0 {
+            (now - self.armed_at).rem_euclid(duration)
+        } else {
+            0.0
+        };
+        Some((node, seek))
+    }
+}
+
 /// The doodad's self-sustaining re-arm (decision 0768, wow-re `doodad-anim-host.md` §5): when the
 /// armed play-window ends, roll a fresh frequency-weighted variation of the same animation id, snap
 /// to it, and write the next window. This is the whole of bug B63's residual — the Blasted Lands
@@ -1101,4 +1189,45 @@ mod tests {
             active.seek_time()
         );
     }
+
+    /// [`DoodadAnimHost::arm_clock`] — the sound lane's phase, which must be the SHARED clock's,
+    /// never the (draw-gated) player's. Three claims: it wraps with the clip, it is unaffected by
+    /// the host being parked, and an unarmed host has no phase at all.
+    #[test]
+    fn arm_clock_wraps_on_the_shared_clock() {
+        let mut host = DoodadAnimHost {
+            meshes: Vec::new(),
+            fade: (0.0, Vec3::ZERO),
+            clip: Some((AnimationNodeIndex::new(1), 3.333)),
+            armed_at: 10.0,
+            window_hi: f32::NEG_INFINITY,
+            anim_id: Some(0),
+            // PARKED — the whole point: a campfire behind you keeps crackling, because the
+            // reference gates the cycle on residency, not on the draw.
+            active: false,
+            parked_at: 0.0,
+        };
+
+        let (_, seek) = host.arm_clock(10.0).expect("armed");
+        assert!(seek.abs() < 1e-6, "at the arm it sits at t = 0");
+
+        let (_, seek) = host.arm_clock(12.0).expect("armed");
+        assert!((seek - 2.0).abs() < 1e-4, "2 s in, {seek}");
+
+        // Past one full cycle it wraps rather than running off the end.
+        let (_, seek) = host.arm_clock(14.0).expect("armed");
+        assert!((seek - (4.0 - 3.333)).abs() < 1e-4, "wrapped to {seek}");
+
+        // A zero-length clip has no phase to compute and must not divide by it.
+        host.clip = Some((AnimationNodeIndex::new(1), 0.0));
+        let (_, seek) = host.arm_clock(99.0).expect("armed");
+        assert!(
+            seek.abs() < 1e-6,
+            "a zero-length clip sits at its own t = 0"
+        );
+
+        // Nothing armed (the gseq-only tier without a sound arm) ⇒ no phase, so nothing fires.
+        host.clip = None;
+        assert!(host.arm_clock(12.0).is_none());
+    }
 }
diff --git a/crates/benilla-world/src/exterior_cull.rs b/crates/benilla-world/src/exterior_cull.rs
index 60b1f6a7..cbd6776c 100644
--- a/crates/benilla-world/src/exterior_cull.rs
+++ b/crates/benilla-world/src/exterior_cull.rs
@@ -856,6 +856,7 @@ mod tests {
                 world_from_local: bevy::math::Affine3A::IDENTITY,
                 name_set: 0,
                 visible: vec![false, false],
+                interior_fog: vec![false, false],
                 liquid_visited: vec![false, false],
                 flooded: vec![None, None],
             })
diff --git a/crates/benilla-world/src/liquid/surface.rs b/crates/benilla-world/src/liquid/surface.rs
index dd2b8b92..97450bdb 100644
--- a/crates/benilla-world/src/liquid/surface.rs
+++ b/crates/benilla-world/src/liquid/surface.rs
@@ -408,6 +408,11 @@ pub(crate) fn spawn_wmo_liquids<'a>(
                 MeshMaterial3d(material),
                 transform,
                 LiquidSurface,
+                // The per-frame interior-fog lane rides `MeshTag` bit 30, written by the one
+                // `Visibility` authority off this pool's own room (decision 1787; `liquid.wgsl`'s
+                // `room_fog`). Spawned clear: a pool wears the room's fog only once the flood has
+                // said the room is on the lane.
+                bevy::mesh::MeshTag(0),
                 // The ambient-loop source rides EVERY kind — the fullbright lava/slime hum too
                 // (0506). It reads its geometry off the `WaterChunkInfo` inserted below.
                 LiquidSoundSource {
diff --git a/crates/benilla-world/src/mesh_tag.rs b/crates/benilla-world/src/mesh_tag.rs
index 04dabfa7..88fa867a 100644
--- a/crates/benilla-world/src/mesh_tag.rs
+++ b/crates/benilla-world/src/mesh_tag.rs
@@ -77,7 +77,13 @@
 //!    laws in a single frame the instant the ramp latched.
 //! 3. `debug_panel::apply_model_visibility` drives the small-prop distance fade (`DoodadFade`
 //!    holders) + glow-card dimming; `DoodadFade` is **never attached** to a lit interior prop
-//!    (spawn-time exclusion in `terrain_stream`), so 2 and 3 are disjoint.
+//!    (spawn-time exclusion in `terrain_stream`), so 2 and 3 are disjoint. The same system also
+//!    owns [`INTERIOR_FOG_BIT`] on **room-bound WMO content** — anything carrying a
+//!    `WmoGroupVis`: a building's group geometry, its doodad props, and the merged blobs of
+//!    either. That is the client's per-group `[0xca7f00]` gate, whose population is disjoint from
+//!    2's by construction (a WMO part is never classified — it holds no `InteriorLit`) and which
+//!    writes through [`with_interior_fog`], so the probe slot a prop was spawned with survives
+//!    the room turning its fog on and off.
 //! 4. `player::apply_self_model_fade` (the zoom-to-first-person feather) runs **after** 1–3 and wins
 //!    on the self body submeshes' alpha while feathering; on the frame it ends it restores the
 //!    alpha field itself and hands the material back to the part's law (it cannot lean on 2 to
@@ -217,6 +223,18 @@ pub fn alpha_bits(alpha: f32) -> u32 {
     }
 }
 
+/// Set or clear [`INTERIOR_FOG_BIT`] alone, preserving the whole payload and the highlight bit —
+/// the room-bound writer's read-modify-write. The payload is untouched on purpose: a WMO interior
+/// prop's probe slot says how it is LIT, and the client's `[0xca7f00]` decides only which fog
+/// TRIPLE its batch is pushed with. The `0` sentinel survives too, because the shader masks bits
+/// 30/31 off before testing it.
+pub(crate) fn with_interior_fog(tag: u32, on: bool) -> u32 {
+    match on {
+        true => tag | INTERIOR_FOG_BIT,
+        false => tag & !INTERIOR_FOG_BIT,
+    }
+}
+
 /// Write the alpha field of a tag, preserving every other field (shade or probe slot, rig, both
 /// flag bits) — the fade writers' read-modify-write (an appear-fade on a unit standing in MCSH
 /// shadow must not flash it lit, and a feathering skinned part must keep its palette).
diff --git a/crates/benilla-world/src/model_render/visibility.rs b/crates/benilla-world/src/model_render/visibility.rs
index ddea0dc0..a04c4bda 100644
--- a/crates/benilla-world/src/model_render/visibility.rs
+++ b/crates/benilla-world/src/model_render/visibility.rs
@@ -81,6 +81,7 @@ pub(super) fn apply_model_visibility(
             &GlobalTransform,
             Option<&Aabb>,
             Has<crate::exterior_cull::ExteriorScene>,
+            Option<&mut MeshTag>,
         ),
         Without<ModelPart>,
     >,
@@ -175,6 +176,18 @@ pub(super) fn apply_model_visibility(
                         .is_none_or(|inst| gv.drawn_by(inst))
                 });
 
+            // …and, off the SAME per-frame flood, which fog triple this piece's batch is pushed
+            // with: the client's per-group `[0xca7f00]` (wow-re round-6 Q-I — the group drawer
+            // `0x6b5190` and the group-doodad drawer `0x6b62e0` push the interior triple only under
+            // it; everything else inherits `push_fog`'s scene triple). `None` for every non-WMO
+            // entity, which leaves `INTERIOR_FOG_BIT` to the entity classifier — a unit's fog is
+            // staged by the unit's OWN classification, not by the room's gate.
+            let room_fog = group_vis.map(|gv| {
+                instances
+                    .get(gv.instance)
+                    .is_ok_and(|inst| gv.interior_fogged_by(inst))
+            });
+
             // The batch's animated material-alpha factor (decision 0130 phase 2): the sampled
             // colour-alpha × transparency-weight loop, `1.0` for the untracked majority. Multiplied
             // into the tag below, and into the cull here — the real client skips a batch whose
@@ -244,18 +257,25 @@ pub(super) fn apply_model_visibility(
             // haze) blasted at full brightness (bug B30). Only the unit lane stays out:
             // `entities::apply_unit_mat_alpha` owns that compose, ordered against the interior
             // classifier and the appear-fade.
-            if fade.is_some() || mat_anim.is_some_and(|m| !m.composes_unit_tag()) {
-                // Glow cards render at AUTHORED brightness (decision 0159 — the dimmer knob died
-                // with the faithful FFXGlow pass; the square-law is what keeps halos in check).
-                let alpha = fade_alpha * mat_factor;
-                // `with_alpha` handles the `MeshTag == 0` opaque-sentinel (a *visible* glow card dimmed
-                // to exactly 0 must not flip to full bright); a distance-faded doodad (`fade_alpha == 0`)
-                // is Hidden anyway, so ≈0 bits there are equally fine. Conventions: `crate::mesh_tag`.
-                if let Some(mut tag) = tag {
-                    let bits = crate::mesh_tag::with_alpha(tag.0, alpha);
-                    if tag.0 != bits {
-                        tag.0 = bits;
-                    }
+            // The two tag fields this system owns, written in ONE read-modify-write so they
+            // compose instead of racing: the fade alpha, and the room's interior-fog bit.
+            if let Some(mut tag) = tag {
+                let mut bits = tag.0;
+                if fade.is_some() || mat_anim.is_some_and(|m| !m.composes_unit_tag()) {
+                    // Glow cards render at AUTHORED brightness (decision 0159 — the dimmer knob died
+                    // with the faithful FFXGlow pass; the square-law is what keeps halos in check).
+                    let alpha = fade_alpha * mat_factor;
+                    // `with_alpha` handles the `MeshTag == 0` opaque-sentinel (a *visible* glow card
+                    // dimmed to exactly 0 must not flip to full bright); a distance-faded doodad
+                    // (`fade_alpha == 0`) is Hidden anyway, so ≈0 bits there are equally fine.
+                    // Conventions: `crate::mesh_tag`.
+                    bits = crate::mesh_tag::with_alpha(bits, alpha);
+                }
+                if let Some(on) = room_fog {
+                    bits = crate::mesh_tag::with_interior_fog(bits, on);
+                }
+                if tag.0 != bits {
+                    tag.0 = bits;
                 }
             }
             if let Some(f) = fade {
@@ -292,7 +312,7 @@ pub(super) fn apply_model_visibility(
     // liquid every frame with no portal re-check for the rest of the world session — the Great
     // Forge's walkway-level pool stays put when its group drops out of the flood (B65). An index
     // past the latch fails OPEN (portal-less props never latch and must always draw).
-    for (gv, mut vis, xf, aabb, exterior) in &mut group_only {
+    for (gv, mut vis, xf, aabb, exterior, tag) in &mut group_only {
         let portal_ok = !m.portal_cull
             || instances.get(gv.instance).ok().is_none_or(|inst| {
                 gv.groups
@@ -321,6 +341,22 @@ pub(super) fn apply_model_visibility(
         if *vis != want {
             *vis = want;
         }
+        // …and the pool's fog lane, off the same per-frame flood as the room's walls (decision
+        // 1787). The reference's WMO liquid pass re-submits the interior fog block under the SAME
+        // `[0xca7f00]` as the geometry pass (wow-re `fog-env-state` §5's 6-site census), so a room
+        // and its water can never disagree; `liquid.wgsl` ANDs this with the surface's own static
+        // interior class. Note the term is the FLOOD's bit, not the ever-visited latch above: a
+        // pool the latch keeps drawing after its room left the PVS wears the scene fog, which is
+        // what the client's per-group toggle does with a group it is not currently walking.
+        if let Some(mut tag) = tag {
+            let on = instances
+                .get(gv.instance)
+                .is_ok_and(|inst| gv.interior_fogged_by(inst));
+            let bits = crate::mesh_tag::with_interior_fog(tag.0, on);
+            if tag.0 != bits {
+                tag.0 = bits;
+            }
+        }
     }
 }
 
diff --git a/crates/benilla-world/src/particles.rs b/crates/benilla-world/src/particles.rs
index 18b6e345..501efd19 100644
--- a/crates/benilla-world/src/particles.rs
+++ b/crates/benilla-world/src/particles.rs
@@ -1106,6 +1106,7 @@ pub(crate) mod tests {
             liquid_visited: vec![false; 3],
             flooded: vec![None; 3],
             visible: vec![true, false, false],
+            interior_fog: vec![false; 3],
         };
         let fade = |groups: Option<&[u16]>| EmitterFade {
             radius: 2.0,
diff --git a/crates/benilla-world/src/particles/render.rs b/crates/benilla-world/src/particles/render.rs
index a7f8ea6a..cdb74ffc 100644
--- a/crates/benilla-world/src/particles/render.rs
+++ b/crates/benilla-world/src/particles/render.rs
@@ -367,6 +367,21 @@ fn extract_effects(
     }));
 }
 
+/// `$WOW_EFFECT_TRACE`'s lane names: which rung of the pre-water surface-decal band a draw's sort
+/// bias is, or `None` for everything else on the stream (particles, ribbons, foam, precipitation).
+/// Keyed on the sort rung — the only field that is unique per decal lane (`sky_order::Rung`).
+fn decal_lane(bias: f32) -> Option<&'static str> {
+    use crate::sky_order::Rung;
+    match bias {
+        b if b == Rung::RING => Some("ring"),
+        b if b == Rung::SHADOW_SORT => Some("shadow"),
+        b if b == Rung::FOOTPRINT => Some("footprint"),
+        b if b == Rung::RETICLE => Some("reticle"),
+        b if b == Rung::GROUND_FX => Some("ground-fx"),
+        _ => None,
+    }
+}
+
 /// Add one [`Transparent3d`] item per draw record to the matching camera's phase.
 fn queue_effects(
     effect_pipeline: Res<EffectPipeline>,
@@ -493,11 +508,16 @@ fn prepare_effects(
     // advances past the absorbed items (`render_phase/mod.rs:1487`).
     let effect_fn = draw_functions.read().id::<DrawEffects>();
     // `$WOW_EFFECT_TRACE` — the lane's own phase probe (the WOW_PHASE shape, decision 0665,
-    // asked of effect items): during the merge walk, record each BLOB-SHADOW item (Tris
-    // topology + the shadow's own sort rung — its RASTER bias is shared with the footprint
-    // lane, which used to label prints as shadows here) with its sort distance and appended index
-    // range, then log the phase totals. Splits "never pushed / never queued / merged away /
-    // submitted but the GPU state ate it" — the gap no pixel reading can see into.
+    // asked of effect items): during the merge walk, record each **surface-decal** item — every
+    // rung of the pre-water band, named by [`decal_lane`] — with its **index in the sorted
+    // transparent phase**, its sort distance, and its appended index range, then log the phase
+    // totals. Splits "never pushed / never queued / merged away / submitted but the GPU state ate
+    // it" — the gap no pixel reading can see into — and, since 1789, reads the draw-order ladder
+    // straight off a live frame: `item 4` vs `item 81` is what B347 was, measured.
+    //
+    // The lane is keyed on the SORT rung because that is the one field unique per lane: the raster
+    // bias is shared (the footprint lane rides `SHADOW_RASTER`, and prints were being labelled
+    // shadows here for exactly that reason).
     let trace = std::env::var_os("WOW_EFFECT_TRACE").is_some();
     let mut trace_lines: Vec<String> = Vec::new();
     meta.indices.clear();
@@ -557,12 +577,9 @@ fn prepare_effects(
                 }
             }
             let index_end = meta.indices.len() as u32;
-            if trace
-                && draw.topology == EffectTopology::Tris
-                && draw.bias == crate::sky_order::Rung::SHADOW_SORT
-            {
+            if let (true, Some(lane)) = (trace, decal_lane(draw.bias)) {
                 trace_lines.push(format!(
-                    "  item {i}: shadow anchor {:.1?}, dist {:.1}, verts {}, indices \
+                    "  item {i}: {lane} anchor {:.1?}, dist {:.1}, verts {}, indices \
                      {index_start}..{index_end}, tex {:?}",
                     draw.anchor,
                     item.distance,
diff --git a/crates/benilla-world/src/shaders/static_gx.wgsl b/crates/benilla-world/src/shaders/static_gx.wgsl
index 3ee7101b..37c500a8 100644
--- a/crates/benilla-world/src/shaders/static_gx.wgsl
+++ b/crates/benilla-world/src/shaders/static_gx.wgsl
@@ -68,7 +68,9 @@ struct GxCell {
 @group(1) @binding(0) var<uniform> cell: GxCell;
 // The per-ITEM record table, indexed by the vertex word's low bits:
 // x = texture-array layer, y = the WMO authored batch order (the clip-z nudge; 0 on cells —
-// an exact no-op), z = the MOMT SIDN colour packed r|g<<8|b<<16 (gamma bytes), w = free.
+// an exact no-op), z = the MOMT SIDN colour packed r|g<<8|b<<16 (gamma bytes), w = flags:
+// bit 0 the exile kill bit (B2), bits 1..=13 the interior-prop probe slot (B4), bit 14 the
+// per-frame INTERIOR FOG lane (1787 — the client's per-group `[0xca7f00]`).
 @group(1) @binding(1) var<storage, read> recs: array<vec4<u32>>;
 @group(1) @binding(2) var tex_array: texture_2d_array<f32>;
 // Repeat and clamp variants of the BLP model-albedo sampler (linear tri-filtered, aniso 8 —
@@ -437,9 +439,15 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
     // Black/White/Grey families belong to blends this lane excludes by admission). Interior
     // WMO surfaces fog with the INTERIOR triple — the room keeps its warm MFOG haze
     // (round-6 Q-I: one flag gates walls, pools and props alike).
+    // The interior fog lane is the per-frame record bit, NOT the baked `WORD_INTERIOR`: the
+    // client pushes the interior triple per GROUP under `[0xca7f00]` (`0x6b5190` for surfaces,
+    // `0x6b62e0` for the group's doodads — wow-re round-6 Q-I), and the flood decides it each
+    // frame (decision 1787, `wow_model.wgsl` carries the same law on its tag bit 30). Keyed on
+    // the batch's static interior flag instead, every true-interior group of a building wore the
+    // building's MFOG the moment the camera stood anywhere in it — B335.
     var fog_color = wow_light.fog_color;
     var fog_span = wow_light.fog_params.xy;
-    if ((in.word & WORD_INTERIOR) != 0u) {
+    if ((recs[in.word & 0xffffu].w & 16384u) != 0u) {
         fog_color = wow_light.wmo_fog_color;
         fog_span = wow_light.wmo_fog_params.xy;
     }
diff --git a/crates/benilla-world/src/sky_order.rs b/crates/benilla-world/src/sky_order.rs
index 32526846..f2538559 100644
--- a/crates/benilla-world/src/sky_order.rs
+++ b/crates/benilla-world/src/sky_order.rs
@@ -164,21 +164,37 @@ impl Rung {
     /// near-side default is after the water. Everything with a *known* slot moved to the
     /// pre-water band below (B347).
     pub const GROUND_FX: f32 = 8192.0;
-    /// The **selection ring**, the same number in both roles and the same coplanarity rationale.
-    /// **Not in the pre-water band — not yet, and not by argument:** the ring's draw hangs off the
-    /// CGObject per-frame slot (`0x614ada` inside `0x614a90` = vtable +0x38), not off a call the
-    /// frame driver's own row names, so which side of the water pass it lands on is unread. An RE
-    /// is out for it (B347); until it answers the ring keeps the rung it has shipped on rather
-    /// than moving on a guess.
-    pub const RING: f32 = 8192.0;
-    /// **The pre-water decal band, rung 1: the unit blob shadow.**
+    /// The **rasterizer** constant the decal family shares — [`GROUND_FX`](Rung::GROUND_FX)'s
+    /// number in its second role, named so the lanes whose *sort* rung left the +8192 neighbourhood
+    /// (the ring, the reticle) still reach the coplanarity margin rather than a copy of it. The
+    /// blob shadow is the one lane that needs more: [`SHADOW_RASTER`](Rung::SHADOW_RASTER), B131.
+    pub const DECAL_RASTER: i32 = 8192;
+    /// **The pre-water decal band, rung 1: the selection ring** (and, when they are built, the
+    /// corpse marker and the click-to-move marker — the same `+0x30` slot and the same call site).
+    ///
+    /// This rung shipped at **+8192** for months and was moved on a guess's opposite: 1785 left it
+    /// alone because the ring's frame slot was *unread*, and the RE it dispatched came back with a
+    /// slot earlier than anything guessed. `[node+0xb4] = 0x481540` → `0x4815d0` →
+    /// `0x48160c call [obj vt+0x38]` → `0x614ada call [obj vt+0x30]` → `0x608e00`: the ring is
+    /// emitted **from inside PHASE 1's own M2 node drain** (`0x6812c5 call 0x683dd0`), the same
+    /// loop body that then calls `0x6d78f0` for that node's blob shadow — so the family is not
+    /// merely before the water, it is before the footprints and before the M2 opaque pass too.
+    ///
+    /// **And the ring draws UNDER the shadow, not over it.** Per node the `+0x38` tick runs first
+    /// (`0x48160c`) and the shadow gate second (`0x683ec3`), so the additive ring goes down and the
+    /// modulate shadow darkens it. This ladder asserted the opposite for as long as both rungs have
+    /// existed — "where both decals stack the ring draws later deterministically" was a tie-break
+    /// invented here, not a fact read anywhere, and it was backwards.
+    pub const RING: f32 = -5.4e4;
+    /// **The pre-water decal band, rung 2: the unit blob shadow.**
     ///
     /// The reference draws its ground decals *before* the water, and B347 is what it costs not
     /// to. The frame driver `0x483460` emits this one inside PHASE 1's opaque drain row
     /// (`0x6812c5 call 0x683dd0` → `0x6d78f0` → `0x6d7920`; wow-re `unit-blob-shadow.md` Q1) —
-    /// before the footprints, before the M2 opaque pass (`0x4836a6`), and long before the water
-    /// surfaces, which draw in phase 3 *between* the two M2 transparent passes
-    /// (`water-frame-straddle.md` §1). Every transparent in the world paints over a shadow there.
+    /// in the same node-drain loop body as the ring above and immediately after it, before the
+    /// footprints, before the M2 opaque pass (`0x4836a6`), and long before the water surfaces,
+    /// which draw in phase 3 *between* the two M2 transparent passes (`water-frame-straddle.md`
+    /// §1). Every transparent in the world paints over a shadow there.
     ///
     /// Here it did the exact opposite. At the old **+4096** the shadow's key (`view-z + bias`)
     /// beat every world transparent — [`WATER_BIAS`], [`FAR_SIDE_BIAS`], and the unbiased
@@ -190,21 +206,22 @@ impl Rung {
     /// WMO-skybox band above it, each by more than a world view-z can travel (`WORLD_VIEW_Z_FLOOR`
     /// — two rungs are only separated if their gap exceeds it). The deepest world transparent
     /// sorts at `FAR_SIDE_BIAS − 8 − far ≈ −4.3e4`; the shallowest skybox batch at
-    /// `WMO_SKYBOX_BIAS − 0.09 ≈ −6.0e4` — a window of `(−5.7e4, −4.3e4)`, which the three rungs
-    /// take centred, 2e3 apart, with ~5e3 of margin at each end. The assert block below is the
+    /// `WMO_SKYBOX_BIAS − 0.09 ≈ −6.0e4` — a window of `(−5.7e4, −4.3e4)`, which the four rungs
+    /// take 2e3 apart, clearing the skybox by 3e3 below and the world band by ~5e3 above. The
+    /// assert block below is the
     /// check, and it is arithmetic on the neighbours rather than a blanket 1e4: the window is only
     /// 1.4e4 wide, so the ladder's usual margin does not fit and pretending it does would be the
     /// lie. **The depth of the rung costs nothing at the rasterizer** — unlike [`WATER_BIAS`] and
     /// the two rungs above, the effect stream carries sort and raster as separate fields
     /// ([`SHADOW_RASTER`](Rung::SHADOW_RASTER) is this lane's other half).
     pub const SHADOW_SORT: f32 = -5.2e4;
-    /// **The pre-water band, rung 2: footprints** — the reference draws them at
+    /// **The pre-water band, rung 3: footprints** — the reference draws them at
     /// `0x483654` (`0x670240` → `0x69a3e0`), one slot AFTER the shadow pass and still before the
     /// M2 opaque pass, so a print paints over a shadow rather than under it. That was inverted
     /// here: the print rode +2048 *below* the shadow's +4096, on a comment calling the reference's
     /// frame order an open RE item — `water-frame-straddle.md` §1 had already closed it.
     pub const FOOTPRINT: f32 = -5.0e4;
-    /// **The pre-water band, rung 3: the ground-target reticle** — the reference's solid-receiver
+    /// **The pre-water band, rung 4: the ground-target reticle** — the reference's solid-receiver
     /// pass (`0x4836c5`, flags `0x200122`) is the last decal before the water. Its *liquid* pass
     /// (`0x483727`, flags `0xf0000`) is the family's one genuinely post-water draw, and it has no
     /// counterpart here: liquid is not a `GroundDecalSurface` yet, so nothing we project can land
@@ -254,15 +271,17 @@ const _: () = {
     assert!(Rung::GROUND_FX - CLOUDS_BIAS > 1.0e4);
     assert!(GLARE_BIAS - Rung::GROUND_FX > 1.0e4);
     assert!(Rung::NAMEPLATE - GLARE_BIAS > 1.0e4);
-    // The ring still draws after the shadow where the two stack, and the shadow's raster margin
-    // is its own axis (B131) — not comparable to the sort rungs, only to zero.
-    assert!(Rung::RING > Rung::SHADOW_SORT && Rung::SHADOW_RASTER > 0);
+    // The two raster margins are their own axis (B131) — not comparable to the sort rungs above,
+    // only to zero and to each other: the shadow's is the raised one.
+    assert!(Rung::SHADOW_RASTER > Rung::DECAL_RASTER && Rung::DECAL_RASTER > 0);
 
-    // ─── The pre-water decal band (B347) ────────────────────────────────────────────────────
-    // Internally ordered as the reference's frame emits them — shadow (PHASE 1, `0x6812c5`) →
-    // footprints (`0x483654`) → the reticle's solid pass (`0x4836c5`) — with a step far wider
-    // than the view-z two *stacked* decals can differ by (they share a patch of ground, so their
-    // anchors are yards apart, not kilometres).
+    // ─── The pre-water decal band (B347, 1785/1789) ─────────────────────────────────────────
+    // Internally ordered as the reference's frame emits them — ring then shadow, both from
+    // PHASE 1's node drain (`0x6812c5 call 0x683dd0`: the `+0x38` tick at `0x48160c`, then the
+    // shadow gate at `0x683ec3`) → footprints (`0x483654`) → the reticle's solid pass
+    // (`0x4836c5`) — with a step far wider than the view-z two *stacked* decals can differ by
+    // (they share a patch of ground, so their anchors are yards apart, not kilometres).
+    assert!(Rung::SHADOW_SORT - Rung::RING > 1.0e3);
     assert!(Rung::FOOTPRINT - Rung::SHADOW_SORT > 1.0e3);
     assert!(Rung::RETICLE - Rung::FOOTPRINT > 1.0e3);
     // And below EVERY world transparent whatever its distance — the deepest being a far-side
@@ -271,9 +290,10 @@ const _: () = {
     // was the one thing in the scene the water did not attenuate.
     assert!(FAR_SIDE_BIAS - 8.0 + WORLD_VIEW_Z_FLOOR - Rung::RETICLE > 1.0e3);
     // ...and above the WMO-skybox band whatever the decal's distance, so a building's painted sky
-    // can never sort over a shadow (it is depth-forced to the far plane as well, but the ladder
-    // does not get to lean on a second mechanism to state its own order).
-    assert!(Rung::SHADOW_SORT + WORLD_VIEW_Z_FLOOR - WMO_SKYBOX_BIAS > 1.0e3);
+    // can never sort over a decal (it is depth-forced to the far plane as well, but the ladder
+    // does not get to lean on a second mechanism to state its own order). Measured at the band's
+    // FLOOR, which is the ring's rung.
+    assert!(Rung::RING + WORLD_VIEW_Z_FLOOR - WMO_SKYBOX_BIAS > 1.0e3);
 };
 
 /// The depth law (module doc) is a property of the **shaders**, so it is checked there: every sky
diff --git a/crates/benilla-world/src/static_gx/cull.rs b/crates/benilla-world/src/static_gx/cull.rs
index 8f55d5c2..24cc627a 100644
--- a/crates/benilla-world/src/static_gx/cull.rs
+++ b/crates/benilla-world/src/static_gx/cull.rs
@@ -418,12 +418,26 @@ pub(super) fn cull_cells(
             let Ok(inst) = instances.get(entity) else {
                 continue;
             };
-            let mut sel = vec![false; draw.sets.len()];
+            let mut sel = crate::static_gx::render::GxSel {
+                drawn: vec![false; draw.sets.len()],
+                fog: vec![false; draw.sets.len()],
+            };
             let mut any = false;
             for (set, aabb) in &draw.groups {
                 let Some(rooms) = draw.sets.get(usize::from(*set)) else {
                     continue;
                 };
+                // The interior-fog lane is decided per SET whether or not the set draws — the
+                // record sync reads the whole vector, and a set the frustum drops this frame is
+                // back next frame with the same rooms. `set_admitted`'s fail-OPEN read is wrong
+                // here: `interior_fogged_by`'s fail-closed one is the fog rule (a missing bit
+                // must not paint a room's MFOG onto a prop).
+                sel.fog[usize::from(*set)] = rooms.iter().any(|&g| {
+                    inst.interior_fog
+                        .get(usize::from(g))
+                        .copied()
+                        .unwrap_or(false)
+                });
                 if m.portal_cull && !set_admitted(&inst.visible, rooms) {
                     continue;
                 }
@@ -445,7 +459,7 @@ pub(super) fn cull_cells(
                 {
                     continue;
                 }
-                sel[usize::from(*set)] = true;
+                sel.drawn[usize::from(*set)] = true;
                 any = true;
             }
             if any {
@@ -462,7 +476,7 @@ pub(super) fn cull_cells(
     // The WMO regions — the dev WMO toggle wholesale, then per-group admission; regions
     // likewise ordered near-first (B3).
     if m.kind_visible[crate::model_render::kind_index(crate::model_render::ModelKind::Wmo)] {
-        let mut admitted: Vec<(u32, (Entity, Vec<bool>))> = Vec::new();
+        let mut admitted: Vec<(u32, (Entity, crate::static_gx::render::GxSel))> = Vec::new();
         for (&entity, draw) in &world.wmos {
             // A region whose instance can't answer this frame (spawn-command latency) keeps
             // last frame's absence — one frame of the entity path's own arrival class.
@@ -470,9 +484,19 @@ pub(super) fn cull_cells(
                 continue;
             };
             let max_group = draw.groups.iter().map(|(g, _)| *g).max().unwrap_or(0);
-            let mut sel = vec![false; usize::from(max_group) + 1];
+            let mut sel = crate::static_gx::render::GxSel {
+                drawn: vec![false; usize::from(max_group) + 1],
+                fog: vec![false; usize::from(max_group) + 1],
+            };
             let mut any = false;
             for (group, aabb) in &draw.groups {
+                // The fog lane first, for every group of the region and not only the drawn ones —
+                // see the prop site above for why.
+                sel.fog[usize::from(*group)] = inst
+                    .interior_fog
+                    .get(usize::from(*group))
+                    .copied()
+                    .unwrap_or(false);
                 // The portal PVS bit — the SAME fail-open read `WmoGroupVis::drawn_by` takes,
                 // behind the same panel switch.
                 if m.portal_cull
@@ -502,7 +526,7 @@ pub(super) fn cull_cells(
                 {
                     continue;
                 }
-                sel[usize::from(*group)] = true;
+                sel.drawn[usize::from(*group)] = true;
                 any = true;
             }
             if any {
@@ -541,7 +565,7 @@ pub(super) fn cull_cells(
                             .iter()
                             .filter(|i| {
                                 i.group.is_some_and(|s| {
-                                    sel.get(usize::from(s)).copied().unwrap_or(false)
+                                    sel.drawn.get(usize::from(s)).copied().unwrap_or(false)
                                 })
                             })
                             .count();
@@ -556,12 +580,13 @@ pub(super) fn cull_cells(
                     .draws
                     .iter()
                     .filter(|i| {
-                        i.group
-                            .is_some_and(|g| sel.get(usize::from(g)).copied().unwrap_or(false))
+                        i.group.is_some_and(|g| {
+                            sel.drawn.get(usize::from(g)).copied().unwrap_or(false)
+                        })
                     })
                     .count();
             }
-            wmo_groups += sel.iter().filter(|b| **b).count();
+            wmo_groups += sel.drawn.iter().filter(|b| **b).count();
         }
         let (mut fs, mut fx, mut fg) = (0usize, 0usize, 0usize);
         for cell in gx.cells.values() {
diff --git a/crates/benilla-world/src/static_gx/mod.rs b/crates/benilla-world/src/static_gx/mod.rs
index d20a75f7..6880ad40 100644
--- a/crates/benilla-world/src/static_gx/mod.rs
+++ b/crates/benilla-world/src/static_gx/mod.rs
@@ -612,7 +612,7 @@ impl StaticGx {
             .world
             .visible_wmos
             .iter()
-            .map(|(_, bits)| bits.iter().filter(|b| **b).count())
+            .map(|(_, bits)| bits.drawn.iter().filter(|b| **b).count())
             .sum();
         (
             self.world.visible.len(),
diff --git a/crates/benilla-world/src/static_gx/pick.rs b/crates/benilla-world/src/static_gx/pick.rs
index 10984625..94ef7531 100644
--- a/crates/benilla-world/src/static_gx/pick.rs
+++ b/crates/benilla-world/src/static_gx/pick.rs
@@ -56,10 +56,9 @@ impl PickSource for StaticGx {
                         continue;
                     };
                     gather(region, origin, dir, &mut candidates, |region, i| {
-                        region.items[i]
-                            .prop
-                            .as_ref()
-                            .is_some_and(|p| sets.get(usize::from(p.set)).copied().unwrap_or(false))
+                        region.items[i].prop.as_ref().is_some_and(|p| {
+                            sets.drawn.get(usize::from(p.set)).copied().unwrap_or(false)
+                        })
                     });
                 }
             }
@@ -69,10 +68,13 @@ impl PickSource for StaticGx {
                 continue;
             };
             gather(region, origin, dir, &mut candidates, |region, i| {
-                region.items[i]
-                    .wmo
-                    .as_ref()
-                    .is_some_and(|w| groups.get(usize::from(w.group)).copied().unwrap_or(false))
+                region.items[i].wmo.as_ref().is_some_and(|w| {
+                    groups
+                        .drawn
+                        .get(usize::from(w.group))
+                        .copied()
+                        .unwrap_or(false)
+                })
             });
         }
         candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
diff --git a/crates/benilla-world/src/static_gx/render.rs b/crates/benilla-world/src/static_gx/render.rs
index 43c2cba2..6d584b18 100644
--- a/crates/benilla-world/src/static_gx/render.rs
+++ b/crates/benilla-world/src/static_gx/render.rs
@@ -118,8 +118,21 @@ fn mark_world_camera(
 #[derive(Clone)]
 pub(crate) enum GxDoodadVis {
     Cell((i32, i32)),
-    /// A prop region + this frame's per-referrer-SET admission bits.
-    Prop(Entity, Vec<bool>),
+    /// A prop region + this frame's per-referrer-SET verdicts.
+    Prop(Entity, GxSel),
+}
+
+/// One region's per-selection-grain verdicts for this frame — a WMO region's grain is the GROUP,
+/// a prop region's the referrer-SET index, and both index these vectors the same way.
+#[derive(Clone, Default)]
+pub(crate) struct GxSel {
+    /// Drawn this frame: PVS ∧ frustum ∧ farclip ∧ the exterior window gate.
+    pub drawn: Vec<bool>,
+    /// On the interior fog lane — the client's per-group `[0xca7f00]`, resolved by the portal
+    /// flood ([`crate::wmo_portal::GroupPvs::interior_fog`]). Rides beside `drawn` because it is
+    /// the same walk's answer at the same grain, and because the node syncs it into the record
+    /// table exactly where it already syncs the kill column.
+    pub fog: Vec<bool>,
 }
 
 /// The published half the render world clones each frame. The baked regions sit behind `Arc`
@@ -141,11 +154,16 @@ pub(crate) struct GxWorld {
     /// This frame's per-group admission per region (indexed by absolute group index): the
     /// portal flood's verdict collapsed to CPU range selection — the node draws exactly the
     /// runs whose group bit is set.
-    pub visible_wmos: Vec<(Entity, Vec<bool>)>,
+    pub visible_wmos: Vec<(Entity, GxSel)>,
 }
 
 use super::pool::GxTexturePool;
 
+/// Record column `w`, bit 14 — the per-item **interior fog** lane (decision 1787), written per
+/// frame by the fog sync and read by `static_gx.wgsl`'s fog select. Bit 0 is the exile kill bit
+/// and bits 1..=13 the interior-prop probe slot, so 14 is the first free bit.
+const RECORD_FOG_BIT: u32 = 1 << 14;
+
 /// One coalesced draw run: adjacent live bake items sharing (bind-group slot, pipeline
 /// bucket, group). Killed items are SKIPPED at build time (B3): a run never carries an exiled
 /// or gone item, so a far cell of fully-faded faders submits no vertex work at all (the WGSL
@@ -180,6 +198,11 @@ struct GxCellGpu {
     records: Vec<[u32; 4]>,
     /// The `killed_rev` this table last uploaded.
     killed_applied: u32,
+    /// The per-grain interior-fog verdict this table's records were last written from
+    /// ([`GxSel::fog`]) — empty until the first sync. Compared rather than revisioned: it is
+    /// tens of bools, it changes only when the camera changes rooms, and unlike the kill bitmap
+    /// it is produced by the per-frame cull rather than owned by the region.
+    fog_applied: Vec<bool>,
 }
 
 #[derive(Resource, Default)]
@@ -504,6 +527,39 @@ fn prepare_static_gx(
         gpu.runs = build_runs(&draw.draws, &gpu.item_slot, &draw.killed);
         gpu.killed_applied = draw.killed_rev;
     }
+
+    // The interior-fog sync (decision 1787): the client's per-group `[0xca7f00]` decides which
+    // fog triple a WMO group's surfaces — and its doodad props — are pushed with, so it is a
+    // per-frame property of the SELECTION, not of the bake. It rides the record table's w column
+    // (bit `RECORD_FOG_BIT`) beside the kill bit, written per item from its own selection grain.
+    // Rewritten only when the verdict actually moves — which is when the camera changes rooms —
+    // and it never touches run membership, so no coalesce is owed.
+    let sync_fog = |gpu: &mut GxCellGpu, draw: &GxCellDraw, sel: &GxSel| {
+        if gpu.fog_applied == sel.fog {
+            return;
+        }
+        for (rec, item) in gpu.records.iter_mut().zip(&draw.draws) {
+            let on = item
+                .group
+                .is_some_and(|g| sel.fog.get(usize::from(g)).copied().unwrap_or(false));
+            rec[3] = (rec[3] & !RECORD_FOG_BIT) | (u32::from(on) * RECORD_FOG_BIT);
+        }
+        render_queue.write_buffer(&gpu.record_table, 0, bytemuck::cast_slice(&gpu.records));
+        gpu.fog_applied.clone_from(&sel.fog);
+    };
+    for (entity, sel) in &gx.visible_wmos {
+        if let (Some(gpu), Some(draw)) = (cache.wmos.get_mut(entity), gx.wmos.get(entity)) {
+            sync_fog(gpu, draw, sel);
+        }
+    }
+    for vis in &gx.visible {
+        let GxDoodadVis::Prop(entity, sel) = vis else {
+            continue; // cell items are never on the interior lane
+        };
+        if let (Some(gpu), Some(draw)) = (cache.props.get_mut(entity), gx.props.get(entity)) {
+            sync_fog(gpu, draw, sel);
+        }
+    }
 }
 
 /// Assemble one region's GPU state against the shared pool: pool slots for its textures, the
@@ -601,6 +657,8 @@ fn assemble_region(
         runs,
         records,
         killed_applied: draw.killed_rev,
+        // Empty ⇒ the first fog sync always fires (the baked records carry no lane bit).
+        fog_applied: Vec::new(),
     })
 }
 
@@ -714,7 +772,7 @@ impl ViewNode for StaticGxNode {
         // (B3/B4): the real client's own drain order (1429's byte-true anchor: terrain →
         // WMO → … → doodad), and the buildings are the frame's best early-z occluders for
         // the doodads behind them.
-        let mut resolved: Vec<(&GxCellGpu, &GxCellDraw, Option<&Vec<bool>>)> = Vec::new();
+        let mut resolved: Vec<(&GxCellGpu, &GxCellDraw, Option<&GxSel>)> = Vec::new();
         for (entity, sel) in &gx.visible_wmos {
             if let (Some(gpu), Some(draw)) = (cache.wmos.get(entity), gx.wmos.get(entity)) {
                 resolved.push((gpu, draw, Some(sel)));
@@ -783,7 +841,7 @@ impl ViewNode for StaticGxNode {
                 // The PVS range selection (1429's collapse): a WMO run draws iff its group's
                 // admission bit is set this frame; a cell run always draws.
                 if let (Some(sel), Some(group)) = (sel, run.group) {
-                    if !sel.get(usize::from(group)).copied().unwrap_or(false) {
+                    if !sel.drawn.get(usize::from(group)).copied().unwrap_or(false) {
                         continue;
                     }
                 }
diff --git a/crates/benilla-world/src/terrain_stream/spawn/mod.rs b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
index fac7fcfe..8ef0c3af 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/mod.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
@@ -338,6 +338,9 @@ pub(super) fn spawn_loaded_placements(
                                 world_from_local: p.transform.compute_affine(),
                                 name_set: p.name_set,
                                 visible: vec![true; m.group_nav.len()],
+                                // Nothing wears the building's own fog until a flood says
+                                // it is on the chain (`WmoPortalInstance::interior_fog`).
+                                interior_fog: vec![false; m.group_nav.len()],
                                 liquid_visited: vec![false; m.group_nav.len()],
                                 // The MOGP `groupLiquid` override, resolved once at spawn: 13
                                 // groups in the whole archive declare "this room is wholly
diff --git a/crates/benilla-world/src/wmo_portal/audit/mod.rs b/crates/benilla-world/src/wmo_portal/audit/mod.rs
index 33501196..5f3aa57c 100644
--- a/crates/benilla-world/src/wmo_portal/audit/mod.rs
+++ b/crates/benilla-world/src/wmo_portal/audit/mod.rs
@@ -44,6 +44,7 @@ mod pin;
 
 /// A building at its real spot on a real map: the model, plus the MODF placement to find (by its
 /// `uniqueId`) in `tile`, whose 3×3 tile block supplies the terrain the down-ray races.
+#[derive(Clone, Copy)]
 struct Site {
     wmo: &'static str,
     map: &'static str,
@@ -112,6 +113,17 @@ const IRONFORGE: Site = Site {
     uid: 7706,
 };
 
+/// Shadowfang Keep — B335's site: the courtyard whose far doorways read as a flat blue-cyan wash.
+/// Its two courtyard groups (g38, g72) are EXTERIOR_LIT (`0x40`) while the rooms behind their
+/// arches (g61, g60) are true interiors, which is the shape the interior-fog chain gate turns on.
+/// `.go xyz -214.30 2211.84 79.78 33` looks at the arches; `-213.90 2236.15 79.78` is inside g61.
+const SHADOWFANG: Site = Site {
+    wmo: r"world\wmo\dungeon\ld_shadowfang\ld_shadowfanginterior.wmo",
+    map: "Shadowfang",
+    tile: (27, 32),
+    uid: 218202,
+};
+
 /// Eye height above a floor point for both the standing player and the seated camera samples.
 const EYE_HEIGHT: f32 = 1.7;
 
diff --git a/crates/benilla-world/src/wmo_portal/audit/pin.rs b/crates/benilla-world/src/wmo_portal/audit/pin.rs
index 0afa3501..fd11c9d0 100644
--- a/crates/benilla-world/src/wmo_portal/audit/pin.rs
+++ b/crates/benilla-world/src/wmo_portal/audit/pin.rs
@@ -7,27 +7,58 @@
 use benilla_assets::coords::{bevy_to_wow, wow_to_bevy};
 use bevy::math::{Mat4, Vec3};
 
-use super::{load_subject, Site, EXTERIOR, UNDERCITY};
+use super::{
+    load_subject, Site, BLACKSMITH, DEADMINES, EXTERIOR, FARGODEEP, GOLDSHIRE, IRONFORGE,
+    SHADOWFANG, UNDERCITY,
+};
 
-/// The pin family's shared env targeting (`WOW_PIN_WMO`/`_MAP`/`_TILE`/`_UID`, default
-/// [`UNDERCITY`]).
+/// The named subjects `WOW_PIN_SITE` selects — every [`Site`] the harness carries, so a report at a
+/// building we have already stood in is one word rather than four env vars (whose `WOW_PIN_WMO`
+/// backslash quoting is its own trap). Unknown names list themselves.
+const NAMED_SITES: &[(&str, Site)] = &[
+    ("goldshire", GOLDSHIRE),
+    ("fargodeep", FARGODEEP),
+    ("deadmines", DEADMINES),
+    ("blacksmith", BLACKSMITH),
+    ("undercity", UNDERCITY),
+    ("ironforge", IRONFORGE),
+    ("shadowfang", SHADOWFANG),
+];
+
+/// The pin family's shared env targeting: `WOW_PIN_SITE=<name>` picks a [`NAMED_SITES`] subject
+/// (default [`UNDERCITY`]), and `WOW_PIN_WMO`/`_MAP`/`_TILE`/`_UID` each override one field of it —
+/// so an unnamed building still works, and a named one needs no quoting.
 fn site_from_env() -> Site {
+    let base = match std::env::var("WOW_PIN_SITE") {
+        Ok(name) => {
+            let key = name.trim().to_ascii_lowercase();
+            *NAMED_SITES
+                .iter()
+                .find(|(n, _)| *n == key)
+                .map(|(_, s)| s)
+                .unwrap_or_else(|| {
+                    let known: Vec<&str> = NAMED_SITES.iter().map(|(n, _)| *n).collect();
+                    panic!("WOW_PIN_SITE={name:?} is not one of {known:?}")
+                })
+        }
+        Err(_) => UNDERCITY,
+    };
     Site {
         wmo: Box::leak(
             std::env::var("WOW_PIN_WMO")
-                .unwrap_or_else(|_| UNDERCITY.wmo.to_string())
+                .unwrap_or_else(|_| base.wmo.to_string())
                 .into_boxed_str(),
         ),
         map: Box::leak(
             std::env::var("WOW_PIN_MAP")
-                .unwrap_or_else(|_| UNDERCITY.map.to_string())
+                .unwrap_or_else(|_| base.map.to_string())
                 .into_boxed_str(),
         ),
-        tile: std::env::var("WOW_PIN_TILE").map_or(UNDERCITY.tile, |s| {
+        tile: std::env::var("WOW_PIN_TILE").map_or(base.tile, |s| {
             let (a, b) = s.split_once(',').expect("WOW_PIN_TILE wants tx,ty");
             (a.trim().parse().unwrap(), b.trim().parse().unwrap())
         }),
-        uid: std::env::var("WOW_PIN_UID").map_or(UNDERCITY.uid, |s| s.trim().parse().unwrap()),
+        uid: std::env::var("WOW_PIN_UID").map_or(base.uid, |s| s.trim().parse().unwrap()),
     }
 }
 
@@ -67,6 +98,27 @@ fn wmo_group_census() {
         site.wmo,
         subject.model.group_nav.len()
     );
+    // The root's MFOG table, once. Every group line below names the ≤4 record indices it points
+    // at, and the fog a room ends up wearing is one of these — which is the whole diagnosis when a
+    // far room reads as a flat wash of one colour (B335: SFK's `0xff28444f` at end 106.9 yd). The
+    // colour is decoded exactly as [`super::super::fog`] decodes it (`0xAARRGGBB`).
+    for (i, f) in subject.model.fogs.iter().enumerate() {
+        println!(
+            "mfog f{i}: flags {:#x} pos ({:.1},{:.1},{:.1}) r[{:.2},{:.2}] end {:.1} start×{:.3} = {:.1} rgb({},{},{})",
+            f.flags,
+            f.pos[0],
+            f.pos[1],
+            f.pos[2],
+            f.radius_inner,
+            f.radius_outer,
+            f.fog_end,
+            f.fog_start_scalar,
+            f.fog_end * f.fog_start_scalar,
+            (f.color >> 16) & 0xff,
+            (f.color >> 8) & 0xff,
+            f.color & 0xff,
+        );
+    }
     // `WOW_PIN_COL=<world-x,world-y>`: every walking-collision face crossing that column, per group,
     // as world z — the down-ray's Leg A candidate list for one spot, without running the flood.
     if let Some((cx, cy)) = std::env::var("WOW_PIN_COL").ok().and_then(|v| {
@@ -211,6 +263,17 @@ fn wmo_group_census() {
                 .map(|(lo, hi)| format!("  LIQUID local z[{lo:.1},{hi:.1}]"))
                 .unwrap_or_default(),
         );
+        // Which MFOG records this group's MOGP header points at, and whether the group is on the
+        // INTERIOR fog lane at all (`flags & 0x48 == 0` — the drawer router's own test).
+        println!(
+            "     fog {:?}{}",
+            g.fog_indices,
+            if g.flags & 0x48 == 0 {
+                "  INTERIOR-LANE"
+            } else {
+                "  scene-lane (0x48 set)"
+            }
+        );
         // The group's portal edges, each placed in WoW world space. The group lines above answer
         // "which room is that"; without this the doorway between two of them is a local-space
         // vertex span nobody can point at in game, so a `.go xyz` report can't name the portal it
@@ -353,12 +416,28 @@ fn wmo_pin_probe() {
     }
 
     let vis: Vec<usize> = pvs
+        .visible
         .iter()
         .enumerate()
         .filter(|(_, &v)| v)
         .map(|(i, _)| i)
         .collect();
-    println!("visible: {} of {} groups {vis:?}", vis.len(), pvs.len());
+    println!(
+        "visible: {} of {} groups {vis:?}",
+        vis.len(),
+        pvs.visible.len()
+    );
+    // The interior-fog gate (`[0xca7f00]`, [`super::super::GroupPvs`]): which of those groups wear
+    // the building's own MFOG triple, and which inherit the scene fog. B335 is read straight off
+    // this line — the room behind the courtyard's arches must NOT be on it.
+    let fogged: Vec<usize> = pvs
+        .interior_fog
+        .iter()
+        .enumerate()
+        .filter(|(_, &v)| v)
+        .map(|(i, _)| i)
+        .collect();
+    println!("interior-fog lane: {fogged:?}");
 
     // The portal graph of every group the flood reached. A flood that stops has either run out of
     // edges or had them all rejected, and only the edge list tells the two apart.
@@ -435,8 +514,118 @@ fn wmo_pin_probe() {
                 if g.flags & EXTERIOR != 0 { " EXT" } else { "" },
                 g.ref_start,
                 g.ref_count,
-                if pvs[gi] { "VISIBLE" } else { "CULLED" }
+                match (pvs.visible[gi], pvs.interior_fog[gi]) {
+                    (true, true) => "VISIBLE · interior fog",
+                    (true, false) => "VISIBLE · scene fog",
+                    (false, _) => "CULLED",
+                }
             );
         }
     }
 }
+
+/// **B335's fixture** — the Shadowfang courtyard's far doorways, as an invariant instead of a
+/// screenshot. The reported spot (`.go xyz -224.01 2168.63 79.79 33`, third-person camera behind)
+/// stands in the open courtyard **g38**, whose MOGP flags carry `0x40` EXTERIOR_LIT; the two arches
+/// at the back of it open (through the second courtyard **g72**, also `0x40`) into room **g61**, a
+/// true interior. The report was that g61 fills with a flat blue-cyan at distance: that colour is
+/// this building's own MFOG record — `rgb(40,68,79)`, end 106.9 yd, start 10.7 — which at 70 yd is
+/// nearly saturated, while the reference shows the room under the scene fog (map 33 noon: end 333,
+/// start 83 ⇒ no fog at all at that range).
+///
+/// So the assertion is not about visibility — the flood reaches g61 from anywhere in the courtyard,
+/// and always did. It is about which fog lane it lands on: the seed's own group takes the interior
+/// lane, and the chain breaks below the exterior-lit courtyards, so **g61 must be on the scene
+/// lane**. The control is the seed itself, which must stay on the interior lane.
+#[test]
+#[ignore = "needs the local game data (WoW/Data); run with --ignored"]
+fn shadowfang_courtyard_leaves_the_far_room_on_the_scene_fog() {
+    let site = SHADOWFANG;
+    let subject = load_subject(site.wmo, Some(&site));
+    let placed = subject
+        .placed
+        .as_ref()
+        .expect("the fixture needs a placement");
+    let to_local =
+        |wow: [f32; 3]| bevy_to_wow(placed.local_from_world.transform_point3(wow_to_bevy(wow)));
+    // The reported camera: third-person behind the player at the fountain, aimed at the p50 arches.
+    let eye_world = [-227.1_f32, 2157.0, 83.7];
+    let look_world = [-212.5_f32, 2232.3, 84.2];
+    let eye = to_local(eye_world);
+    let eye_bevy = placed.world_from_local.transform_point3(wow_to_bevy(eye));
+    let look_bevy = placed
+        .world_from_local
+        .transform_point3(wow_to_bevy(to_local(look_world)));
+    let clip = Mat4::perspective_rh(crate::view::CAM_FOVY, 16.0 / 9.0, 0.1, 1000.0)
+        * Mat4::look_at_rh(eye_bevy, look_bevy, Vec3::Y);
+    let pvs = crate::wmo_portal::compute_pvs_traced(
+        &subject.model,
+        eye,
+        subject.terrain_z(eye),
+        &clip,
+        &placed.world_from_local,
+        &mut (),
+    );
+
+    // The flags the whole verdict turns on, asserted so a data misread can't pass silently.
+    assert_eq!(
+        subject.model.group_nav[38].flags & 0x48,
+        0x40,
+        "g38 is the EXTERIOR_LIT courtyard"
+    );
+    assert_eq!(
+        subject.model.group_nav[72].flags & 0x48,
+        0x40,
+        "g72 is the second EXTERIOR_LIT courtyard"
+    );
+    assert_eq!(
+        subject.model.group_nav[61].flags & 0x48,
+        0,
+        "g61 is a true interior room"
+    );
+
+    assert!(
+        pvs.visible[61],
+        "the flood reaches the room behind the arches"
+    );
+    assert!(
+        !pvs.interior_fog[61],
+        "B335: the room two exterior-lit courtyards away must inherit the SCENE fog, not this \
+         building's MFOG teal"
+    );
+    assert!(
+        !pvs.interior_fog[72],
+        "the chain is already broken at the second courtyard"
+    );
+    assert!(
+        !pvs.interior_fog[38],
+        "the courtyard the camera stands in is exterior-LIT: the exterior drawer pushes no fog, \
+         so its own surfaces are on the scene lane too"
+    );
+    assert!(
+        pvs.interior_fog.iter().all(|f| !f),
+        "from this courtyard NOTHING wears the building's MFOG — which is what the reference \
+         screenshot shows: not one navy pixel in the frame"
+    );
+
+    // The control, from a true interior: standing in g61 itself, the room DOES take the lane —
+    // otherwise this fixture would pass on a gate that is simply always off.
+    let inside = to_local([-213.90, 2236.15, 81.5]);
+    let inside_bevy = placed
+        .world_from_local
+        .transform_point3(wow_to_bevy(inside));
+    let inside_clip = Mat4::perspective_rh(crate::view::CAM_FOVY, 16.0 / 9.0, 0.1, 1000.0)
+        * Mat4::look_at_rh(inside_bevy, eye_bevy, Vec3::Y);
+    let inside_pvs = crate::wmo_portal::compute_pvs_traced(
+        &subject.model,
+        inside,
+        subject.terrain_z(inside),
+        &inside_clip,
+        &placed.world_from_local,
+        &mut (),
+    );
+    assert!(
+        inside_pvs.interior_fog[61],
+        "control: the room seeds its own flood, so it wears the building's MFOG from inside"
+    );
+}
diff --git a/crates/benilla-world/src/wmo_portal/mod.rs b/crates/benilla-world/src/wmo_portal/mod.rs
index 13923eda..5b0b636a 100644
--- a/crates/benilla-world/src/wmo_portal/mod.rs
+++ b/crates/benilla-world/src/wmo_portal/mod.rs
@@ -153,6 +153,18 @@ impl WmoGroupVis {
             .iter()
             .any(|&g| inst.visible.get(g as usize).copied().unwrap_or(true))
     }
+
+    /// The interior-fog verdict: this piece takes the building's MFOG triple iff **any** naming
+    /// group does ([`WmoPortalInstance::interior_fog`], the client's `[0xca7f00]`). ORed for the
+    /// same reason `drawn_by` ORs — a prop several rooms name is drawn from any of them, so it
+    /// wears the fog of any of them. A lookup miss reads FALSE, the opposite of `drawn_by`'s
+    /// fail-open: a missing bit here must not paint a room's fog onto the open world, and the scene
+    /// fog is what every un-gated surface already wears.
+    pub fn interior_fogged_by(&self, inst: &WmoPortalInstance) -> bool {
+        self.groups
+            .iter()
+            .any(|&g| inst.interior_fog.get(g as usize).copied().unwrap_or(false))
+    }
 }
 
 /// **Is a room-bound RIDER drawn this frame?** — [`WmoGroupVis::drawn_by`] resolved for the lanes
@@ -202,6 +214,12 @@ pub struct WmoPortalInstance {
     /// PVS. Seeded all-`true` (everything shows until the first compute, and forever for portal-less
     /// props).
     pub visible: Vec<bool>,
+    /// Per-group **interior-fog** gate for this frame (the client's `[0xca7f00]`): `true` = this
+    /// group's surfaces and its doodads draw with the building's MFOG triple, `false` = they
+    /// inherit the scene fog. Computed by the same flood as `visible` — see [`GroupPvs`] for the
+    /// rule and the byte cites. Seeded all-`false`: nothing wears a room's fog until a flood says
+    /// so, and a portal-less prop (which never floods) never does.
+    pub interior_fog: Vec<bool>,
     /// Per-group **ever-visited** latch — the client's render-record persistence (wow-re
     /// `wmo-record-persistence.md`, landed wow-re main @`00a766f6`): the visit callback `0x685d70`
     /// creates a per-(instance,group) record the first time the flood visits a group, the record
@@ -371,8 +389,18 @@ fn compute_wmo_pvs(
         // precondition) before it was born.
         if model.portal_refs.is_empty() || model.portal_infos.is_empty() {
             let held = inst.bypass_change_detection();
+            // …and never on the interior fog lane: a portal-less prop runs no flood, so there is
+            // no chain to be on (the same reading the fog resolve takes — see [`fog`]'s module doc).
+            let mut changed = false;
             if held.visible.len() != groups || held.visible.iter().any(|v| !*v) {
                 held.visible = vec![true; groups];
+                changed = true;
+            }
+            if held.interior_fog.len() != groups || held.interior_fog.iter().any(|v| *v) {
+                held.interior_fog = vec![false; groups];
+                changed = true;
+            }
+            if changed {
                 inst.set_changed();
             }
             continue;
@@ -403,8 +431,12 @@ fn compute_wmo_pvs(
             &world_from_local,
             &mut (&mut tap, &mut log),
         );
-        if inst.bypass_change_detection().visible != fresh {
-            inst.bypass_change_detection().visible = fresh;
+        if inst.bypass_change_detection().visible != fresh.visible {
+            inst.bypass_change_detection().visible = fresh.visible;
+            inst.set_changed();
+        }
+        if inst.bypass_change_detection().interior_fog != fresh.interior_fog {
+            inst.bypass_change_detection().interior_fog = fresh.interior_fog;
             inst.set_changed();
         }
         if let (Some(text), Some(log)) = (&mut dump_text, &log) {
@@ -419,8 +451,37 @@ fn compute_wmo_pvs(
         // fires only when the doorway's screen rect survives, the carved pass-1 law).
         if claim.is_none() {
             if let Some(gi) = tap.in_group {
-                if let Some(nav) = model.group_nav.get(gi).filter(|n| n.flags & EXTERIOR == 0) {
-                    fog_target = select_wmo_fog(&model.fogs, nav.fog_indices, eye_local);
+                if model
+                    .group_nav
+                    .get(gi)
+                    .is_some_and(|n| n.flags & EXTERIOR == 0)
+                {
+                    // **The MFOG engagement conjunct** (wow-re `models/scratch/wmo-interior-fog-gate.md`,
+                    // §5 VERIFIED; the byteOut loop `0x69de5f`–`0x69dea0` over the camera's containing
+                    // set `0xc7cd88`): the interior fog target exists only when one of the camera's
+                    // ≤2 CONTAINING groups — the down-ray's in-group and its across-portal partner,
+                    // which is exactly that set — is a TRUE interior, `flags & 0x48 == 0`. In an
+                    // exterior-LIT courtyard the client's `t` decays to 0 and the interior triple
+                    // equals the scene triple; no surface of the building is on the lane either
+                    // (decision 1787), so what this conjunct actually decides is the fog of an
+                    // interior-classified UNIT standing in the building, which reads the triple by
+                    // its own classification and would otherwise wear a courtyard's MFOG.
+                    //
+                    // The candidate walk reads THAT group's own MOGP fog indices (`grp+0x34`), not
+                    // the containing group's unconditionally — a courtyard's indices never engage.
+                    // The interior CLAIM below keeps the `0x8`-alone test it has always had: the
+                    // `[0xc7b748]` writer rejects on EXTERIOR only (round-6 Q-H(c)), and the weather
+                    // gate and the submersion probe both read the claim, not this.
+                    fog_target = [Some(gi), tap.across]
+                        .into_iter()
+                        .flatten()
+                        .find_map(|g| {
+                            model
+                                .group_nav
+                                .get(g)
+                                .filter(|n| n.flags & (EXTERIOR | EXTERIOR_LIT) == 0)
+                        })
+                        .and_then(|n| select_wmo_fog(&model.fogs, n.fog_indices, eye_local));
                     claim = Some(InteriorClaim {
                         room: WmoRoom {
                             instance: entity,
@@ -496,12 +557,18 @@ fn compute_wmo_pvs(
 #[derive(Default)]
 struct SeedTap {
     in_group: Option<usize>,
+    /// The down-ray's ACROSS-portal seed. With [`Self::in_group`] this is the client's
+    /// `0xc7cd88` — the camera's ≤2 *containing* groups, which the MFOG engagement conjunct
+    /// tests (and which is NOT the flood's visible set, a confusion wow-re corrected in
+    /// `models/scratch/wmo-interior-fog-gate.md`).
+    across: Option<usize>,
     /// `(destination group, rect it was entered on)` for every accepted portal step.
     entered: Vec<(usize, Rect)>,
 }
 impl FloodTrace for SeedTap {
     fn seed(&mut self, seeds: DownRaySeeds) {
         self.in_group = seeds.in_group;
+        self.across = seeds.across;
     }
     fn entered(&mut self, _from: usize, _portal: u16, to: usize, rect: Rect, _on_plane: bool) {
         self.entered.push((to, rect));
@@ -610,6 +677,30 @@ fn compute_pvs(
         world_from_local,
         &mut (),
     )
+    .visible
+}
+
+/// What one flood publishes per group: this frame's PVS bit, and whether the group draws with the
+/// building's **interior fog** triple rather than the scene fog.
+///
+/// The second is the client's per-group `[0xca7f00]` — the gate on BOTH interior-fog pushes, the
+/// group drawer `0x6b5190` and the group-doodad drawer `0x6b62e0` (wow-re
+/// `lighting/scratch/rf-weather-emission-timeline.md` round-6 Q-I, `terrain/scratch/fog-env-state.md`
+/// §block 2). Decision 0347 modelled the LANE (interior triple on shared-light rows 18-19, selected
+/// by the batch's own `flags & 0x48` interior bit) and recorded this gate as *"not modelled"*; B335
+/// is that gap seen from the Shadowfang courtyard, where the room two exterior-lit courtyards away
+/// wore the building's MFOG teal at 70 yd while the reference showed it under the scene fog.
+///
+/// The rule here: the seed's own group takes the lane (`0x6b3b4c`/`0x6b3df5` force it), and the walk
+/// carries it to a neighbour only while no group on the path has `flags & 0x48` — the interior-chain
+/// anchor breaking at an exterior/exterior-lit group (`0x6b424f` → `0x6b42c6`, QL-1). A `0x48` group
+/// is drawn by the exterior drawer `0x6b4f10`, which pushes no fog at all, so its own bit is inert;
+/// what the break decides is the rooms BEYOND it.
+pub(crate) struct GroupPvs {
+    /// Per absolute group index: in this frame's portal PVS.
+    pub(crate) visible: Vec<bool>,
+    /// Per absolute group index: draws with the interior fog triple (the `[0xca7f00]` equivalent).
+    pub(crate) interior_fog: Vec<bool>,
 }
 
 /// [`compute_pvs`] with a [`FloodTrace`] tap on every decision — the same single flood; the probe dump
@@ -621,9 +712,10 @@ fn compute_pvs_traced<T: FloodTrace>(
     clip_from_world: &Mat4,
     world_from_local: &Affine3A,
     trace: &mut T,
-) -> Vec<bool> {
+) -> GroupPvs {
     let nav = &model.group_nav;
     let mut visible = vec![false; nav.len()];
+    let mut interior_fog = vec![false; nav.len()];
 
     // Seed: the down-ray's set — the camera's current group AND, when the nearest crossing was a
     // portal, the group on its other side. Each is an independent flood ROOT with the full screen
@@ -632,21 +724,23 @@ fn compute_pvs_traced<T: FloodTrace>(
     // under-floods at exactly the near-portal moment the second root exists to cover). Over no surface
     // (open air) or an exterior one ⇒ the outside leg, seeding each EXTERIOR group full-screen (Bevy
     // then frustum-culls the genuinely off-screen ones by their Aabb). Stack item: (group, came_from,
-    // working screen rect, depth).
-    let mut stack: Vec<(usize, usize, Rect, u32)> = Vec::new();
+    // working screen rect, depth, interior-chain intact).
+    let mut stack: Vec<(usize, usize, Rect, u32, bool)> = Vec::new();
     let seeds = down_ray_seeds(model, eye_local, terrain_z);
     trace.seed(seeds);
     match seeds.in_group {
         Some(c) => {
-            stack.push((c, usize::MAX, FULL_SCREEN, 0));
+            stack.push((c, usize::MAX, FULL_SCREEN, 0, true));
             if let Some(a) = seeds.across {
-                stack.push((a, usize::MAX, FULL_SCREEN, 0));
+                stack.push((a, usize::MAX, FULL_SCREEN, 0, true));
             }
         }
         None => {
+            // The outside leg — no containing map object, so nothing takes the interior fog lane
+            // (the client's selector bails on `[0xc7b748] == 0` ahead of all of this, round 5 Q-G).
             for (gi, g) in nav.iter().enumerate() {
                 if g.flags & EXTERIOR != 0 {
-                    stack.push((gi, usize::MAX, FULL_SCREEN, 0));
+                    stack.push((gi, usize::MAX, FULL_SCREEN, 0, false));
                 }
             }
         }
@@ -656,16 +750,32 @@ fn compute_pvs_traced<T: FloodTrace>(
     // (`wow-5875-re` `wmo-insideleg-phase3.md`): only then is the exterior shell drawn (below).
     let mut deferred_exterior = false;
     let mut iters = 0u32;
-    while let Some((g, came, rect, depth)) = stack.pop() {
+    while let Some((g, came, rect, depth, chain)) = stack.pop() {
         iters += 1;
         if iters > MAX_ITERS || g >= nav.len() {
             continue;
         }
         visible[g] = true;
+        // The interior-fog gate ([`GroupPvs::interior_fog`]): this group draws with the building's
+        // own MFOG triple iff the walk that reached it kept an unbroken interior chain from the
+        // seed AND the group is itself a true interior. ORed over paths — a group two walks reach
+        // takes the lane if EITHER kept the chain.
+        //
+        // The second term is the DRAWER ROUTER folded in (`0x6b3fe8` picks interior-vs-exterior on
+        // the same `flags & 0x48`): an exterior/exterior-lit group is drawn by `0x6b4f10`, which
+        // pushes no fog at all, so `[0xca7f00]` cannot reach its surfaces however the walk got
+        // there — and that is true of the SEED's own group too when the camera stands in a
+        // courtyard. Folding it here rather than ANDing it in each of the three consuming lanes
+        // keeps one definition of "which fog does this room wear".
+        interior_fog[g] |= chain && nav[g].flags & (EXTERIOR | EXTERIOR_LIT) == 0;
         if depth >= DEPTH_CAP {
             continue;
         }
         let nav_g = &nav[g];
+        // The chain breaks BELOW an exterior/exterior-lit group, never at the seed: the seed forces
+        // the lane on for its own group (`0x6b3b4c`/`0x6b3df5`), and a `flags & 0x48` group is the
+        // anchor the walk's chain breaks at (`0x6b424f` → `0x6b42c6`).
+        let chain_on = chain && nav_g.flags & (EXTERIOR | EXTERIOR_LIT) == 0;
         let start = nav_g.ref_start as usize;
         let end = (start + nav_g.ref_count as usize).min(model.portal_refs.len());
         for r in &model.portal_refs[start..end] {
@@ -719,7 +829,7 @@ fn compute_pvs_traced<T: FloodTrace>(
             if nav.get(neighbour).is_some_and(|n| n.flags & EXTERIOR != 0) {
                 deferred_exterior = true;
             }
-            stack.push((neighbour, g, inter, depth + 1));
+            stack.push((neighbour, g, inter, depth + 1, chain_on));
         }
     }
 
@@ -738,7 +848,10 @@ fn compute_pvs_traced<T: FloodTrace>(
             }
         }
     }
-    visible
+    GroupPvs {
+        visible,
+        interior_fog,
+    }
 }
 
 /// The portal's polygon vertices (WoW model space), or `None` if the span is out of range or
@@ -890,6 +1003,7 @@ mod tests {
             world_from_local: Affine3A::IDENTITY,
             name_set: 0,
             visible: vec![false, true, false],
+            interior_fog: vec![false; 3],
             liquid_visited: vec![false; 3],
             flooded: vec![None; 3],
         };
@@ -911,6 +1025,48 @@ mod tests {
         assert!(key(&[9]).drawn_by(&inst), "index past the set fails open");
     }
 
+    /// The interior-fog key ORs like `drawn_by` — a prop several rooms name wears the fog of any
+    /// of them — but a lookup miss reads FALSE where `drawn_by`'s reads true. The asymmetry is
+    /// deliberate: a missing PVS bit must not blank a building, and a missing fog bit must not
+    /// paint a room's MFOG onto something the flood never placed.
+    #[test]
+    fn the_interior_fog_key_ors_over_rooms_and_fails_closed() {
+        let inst = WmoPortalInstance {
+            handle: Handle::default(),
+            world_from_local: Affine3A::IDENTITY,
+            name_set: 0,
+            visible: vec![true; 3],
+            interior_fog: vec![false, true, false],
+            liquid_visited: vec![false; 3],
+            flooded: vec![None; 3],
+        };
+        let key = |groups: &[u16]| WmoGroupVis {
+            instance: Entity::PLACEHOLDER,
+            groups: Arc::from(groups),
+        };
+        assert!(key(&[1]).interior_fogged_by(&inst), "its own room is on it");
+        assert!(
+            !key(&[0]).interior_fogged_by(&inst),
+            "its own room is off it"
+        );
+        assert!(
+            key(&[0, 2, 1]).interior_fogged_by(&inst),
+            "one referrer on the lane is enough"
+        );
+        assert!(
+            !key(&[0, 2]).interior_fogged_by(&inst),
+            "no referrer is on it"
+        );
+        assert!(
+            !key(&[]).interior_fogged_by(&inst),
+            "no referrers: nothing ORs"
+        );
+        assert!(
+            !key(&[9]).interior_fogged_by(&inst),
+            "index past the set fails CLOSED — the opposite of drawn_by"
+        );
+    }
+
     /// **Only `0x8` opens a window onto the open world** (`0x6b44f8`), and the flag values here are
     /// Stormwind's own, read off a live cull trace at the director's `.go xyz -8798.70 478.64 95.79`
     /// (decision 1148). The city is 306 groups of which **exactly one** — `g46`, `0x08809` — carries