diff --git a/LIGHTING.md b/LIGHTING.md
new file mode 100644
index 00000000..0a7ed62b
--- /dev/null
+++ b/LIGHTING.md
@@ -0,0 +1,69 @@
+# benilla-lighting
+
+A dynamic light and shadow system for [benilla](https://github.com/samwhosung/benilla), the Rust +
+Bevy reimplementation of the 1.12.1 client. This branch is upstream benilla (merged at
+`66388278`) plus the lighting work, and nothing else. It needs no data changes: everything is
+derived from what a 1.12 install already carries (WMO `MOLT` lights, `MOCV` vertex colour, portals,
+M2 particle emitters, `Light.dbc`).
+
+Everything here is a departure from the reference client's look, so every lane has a live cvar and
+most can be switched off. Code is tagged `MONKEY (<topic>)` with the rationale and the measurements
+behind each constant.
+
+## What it does
+
+| Lane | What you see | Main switch |
+|---|---|---|
+| Sun shadows, characters | real silhouettes for units instead of the oval blob | `characterShadows` |
+| Sun shadows, world | trees, buildings and alpha-tested foliage cast; baked terrain shadows step aside | `worldShadows` |
+| Dynamic interiors | WMO rooms are lit per fragment by their own fixtures with a soft falloff, gated per room so light does not leak through walls | `interiorLight`, `interiorRoomGate` |
+| Synthesised lights | torches, braziers, lanterns, campfires and lampposts emit a light in the colour of their flame, with flicker | `fireLightGain`, `fireFlicker` |
+| Torch shadows | cube-map shadows from point lights onto buildings, models and terrain, with a contact-hardening penumbra and a shadow floor | `interiorShadows`, `exteriorShadows`, `torchShadowStrength`, `interiorShadowSoft` |
+| Daylight and doorways | calibrated fixtures at doors, windows and open boundaries carry daylight into a room, and doorways between rooms bleed light | `interiorDaylight`, env `WOW_DAYLIGHT`, `WOW_BLEED` |
+| Spell and firework lights | fire, holy and fel effects light their surroundings for their lifetime; frost, nature, arcane and shadow do not | `spellLightGain`, env `WOW_SPELL_LIGHT=0` |
+| Night and interior level | global dimming of the night sky term and of interior ambient | `nightGain`, `interiorGain`, `interiorBakeFloor` |
+
+The dev build has a panel for all of it: **Ctrl+Shift+D → Lighting & shadows**, with Dim / Default /
+Bright presets. The Video options page gains Real Character Shadows, World Shadows and Shadow
+Distance.
+
+## Where the code lives
+
+- **Shaders**: `crates/benilla-assets/src/shaders/shadow_hook.wgsl` (shared shadow sampling),
+  `crates/benilla-world/src/shaders/torch_depth.wgsl`, and the lighting lanes inside
+  `static_gx.wgsl`, `wow_model.wgsl` and `terrain.wgsl`. The three receivers mirror each other; the
+  comments say where.
+- **World** (`crates/benilla-world/src`): `lighting/global_light.rs` (light table packer, lanes,
+  room claims, gains), `lighting/daylight.rs`, `lighting/flicker.rs`, `static_gx/torch_depth.rs`
+  (cube-map cache), `static_gx/shadow.rs`, and the light spawning in `terrain_stream/spawn/`.
+- **Data rules** (`crates/benilla-formats/src`): `fire_light.rs` (which models emit light, their
+  colour and reach, the spell school rules) and `room_claim.rs` (which rooms a light may light).
+- **App** (`crates/benilla-app/src`): `torch_shadow.rs` (caster selection), `shadow_core.rs`,
+  `character_shadow.rs`, `world_shadow.rs`, `blob_shadow.rs`, `entities/carried_light.rs`,
+  `entities/spell_fx/lifecycle.rs`, `dynamic_interior.rs`, `debug_panel/lighting_controls.rs`, and
+  the cvars in `cvars.rs` / `video.rs`.
+- **Tools**: `benilla-extract <Data> wmolights <wmo> [--verts <group>]`, `wmolamps`, `m2firescan`
+  print the inputs the system works from (groups, batch classes, portals, claims, flame emitters).
+
+## Invariants worth knowing before editing
+
+- The shared light buffer stays 8528 bytes and the torch table 6416 bytes; both are mirrored in
+  three shaders and pinned by tests.
+- World lights use upstream's `WorldPointLight`, never Bevy's `PointLight`.
+- WGSL only fails at pipeline creation, so a shader edit is verified by running a world scene, not
+  by `cargo check`.
+- Exterior point lights are selected per draw unit (12 slots, ranked against the chunk's box); the
+  cube-map occlusion is evaluated for the nearest three.
+
+## Build
+
+```bash
+cargo build --release -p benilla
+```
+
+Debug tracing: `WOW_TORCH_TRACE=1`, `WOW_POINTS_DUMP=1`, `WOW_SHADOW_TRACE=1`, and the cvar
+`interiorDebug` 1..4.
+
+## Licence
+
+Same as upstream: MIT OR Apache-2.0.
diff --git a/crates/benilla-app/assets/ui/OptionsFrame.xml b/crates/benilla-app/assets/ui/OptionsFrame.xml
index 9619b109..d9d432eb 100644
--- a/crates/benilla-app/assets/ui/OptionsFrame.xml
+++ b/crates/benilla-app/assets/ui/OptionsFrame.xml
@@ -804,6 +804,20 @@
             .. "which it could only do in exclusive fullscreen. benilla applies it to the "
             .. "finished image instead, so it works in both display modes."
 
+        BENILLA_TOOLTIP_CHARACTER_SHADOWS =
+            "Renders real dynamic silhouettes for players, NPCs, creatures, and mounts, replacing "
+            .. "the legacy oval blob. Matches Wrath's character-only shadow tier. This uses "
+            .. "additional GPU time and memory."
+
+        BENILLA_TOOLTIP_WORLD_SHADOWS =
+            "Casts real dynamic shadows from the static world (trees, buildings, and foliage) "
+            .. "following the sun, and switches off the baked terrain shadows they replace. "
+            .. "Independent of Real Character Shadows. This uses additional GPU time and memory."
+
+        BENILLA_TOOLTIP_SHADOW_DISTANCE =
+            "How far realtime shadows are drawn, in yards. Higher covers more ground but spreads "
+            .. "the shadow map thinner (softer edges) and costs more. Applies on Okay/Apply."
+
         OPTIONS_PAGE_ROWS = {
             -- Seven rows became sixteen at 2180, and the nine that arrived were not new
             -- settings: every one names a CVar this client already registered AND read, with no
@@ -836,7 +850,9 @@
             Graphics = {
                 "RowUiScale", "RowFarclip", "RowWorldDetail", "RowBrightness",
                 "RowWeatherDensity",
-                "RowDisplayMode", "RowVerticalSync", "RowRenderScale",
+                "RowDisplayMode", "RowVerticalSync",
+                "RowCharacterShadows", "RowWorldShadows", "RowShadowDistance",
+                "RowRenderScale",
             },
             -- Player Guild Names (2180) rides as a CHILD of Player Names, which is the
             -- reference's own relationship twice over: its CheckButton22 hangs off 21 with a +26
@@ -3083,11 +3099,48 @@
                                                     "OPTION_TOOLTIP_VERTICAL_SYNC")
                                             </OnLoad></Scripts>
                                         </Frame>
-                                        <Frame name="$parentRowRenderScale" inherits="OptionsSliderRowTemplate">
+                                        <Frame name="$parentRowCharacterShadows" inherits="OptionsCheckboxRowTemplate">
                                             <Anchors>
                                                 <Anchor point="TOPLEFT" relativeTo="$parentRowVerticalSync" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                                 <Anchor point="TOPRIGHT" relativeTo="$parentRowVerticalSync" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
                                             </Anchors>
+                                            <Scripts><OnLoad>
+                                                OptionsRow_OnLoad(self, "characterShadows", "Real Character Shadows",
+                                                    "BENILLA_TOOLTIP_CHARACTER_SHADOWS")
+                                            </OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowWorldShadows" inherits="OptionsCheckboxRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowCharacterShadows" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowCharacterShadows" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
+                                            <Scripts><OnLoad>
+                                                OptionsRow_OnLoad(self, "worldShadows", "World Shadows",
+                                                    "BENILLA_TOOLTIP_WORLD_SHADOWS")
+                                            </OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowShadowDistance" inherits="OptionsSliderRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowWorldShadows" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowWorldShadows" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
+                                            <Scripts><OnLoad>
+                                                -- Realtime-shadow render distance (yd): the cascade
+                                                -- range + caster reach. 40-200, matching the CVar's
+                                                -- own clamp (SHADOW_DISTANCE_RANGE). DEFERRED to
+                                                -- Apply so a drag doesn't re-fit the cascade + recollect
+                                                -- casters on every tick (one rebuild on commit instead).
+                                                OptionsRow_OnLoad(self, "shadowDistance", "Shadow Distance",
+                                                    "BENILLA_TOOLTIP_SHADOW_DISTANCE")
+                                                OptionsSliderRow_Setup(self, 40, 200, 10, "yards")
+                                                self.deferred = 1
+                                            </OnLoad></Scripts>
+                                        </Frame>
+                                        <Frame name="$parentRowRenderScale" inherits="OptionsSliderRowTemplate">
+                                            <Anchors>
+                                                <Anchor point="TOPLEFT" relativeTo="$parentRowShadowDistance" relativePoint="BOTTOMLEFT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                                <Anchor point="TOPRIGHT" relativeTo="$parentRowShadowDistance" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="0" y="-9"/></Offset></Anchor>
+                                            </Anchors>
                                             <Scripts><OnLoad>
                                                 -- Render Scale (decision 1639) -- benilla's own
                                                 -- row, no 1.12 counterpart: the reference renders
diff --git a/crates/benilla-app/src/blob_shadow.rs b/crates/benilla-app/src/blob_shadow.rs
index d9b01c8a..cacc5293 100644
--- a/crates/benilla-app/src/blob_shadow.rs
+++ b/crates/benilla-app/src/blob_shadow.rs
@@ -99,9 +99,11 @@ use bevy::prelude::*;
 use crate::creature_anim::AnimData;
 use crate::net::{Embodied, NetEntity};
 use benilla_world::decal::{DecalFrame, WorldDecal};
+use benilla_world::lighting::WowLighting;
 use benilla_world::particles::buffer::{begin_effect_frame, EffectVertex};
 use benilla_world::schedule::WorldStage;
 use benilla_world::view::WorldCamera;
+use benilla_world::wmo_portal::UnitWmoRoom;
 
 /// The reference's shadow disc (`Textures\ShadowBlob.blp`, wow-re unit-blob-shadow RE): grayscale
 /// radial blob (gray-160 core → white rim) under a binary alpha disc, multiplied onto the ground.
@@ -112,6 +114,10 @@ const BOX_CLAMP: f32 = 5.0;
 /// Degenerate-box epsilon (the reference's `[0x8029d4]` = 2.384e-7): a zero horizontal extent is
 /// the no-op exit — no shadow.
 const DEGENERATE_EPS: f32 = 2.384e-7;
+/// MONKEY (night blob): the realtime lane's edge band — mirrors `SHADOW_EDGE_BAND` in
+/// `shadow_hook.wgsl`, where the realtime shadow lightens over the last yards of the cascade.
+/// The oval fades back IN across the same band, so the handover is a crossfade at both ends.
+const SHADOW_EDGE_BAND: f32 = 14.0;
 
 /// One unit's shadow record (a top-level entity — no render components; the cached projection
 /// rides the effect stream). Despawned when the owner goes.
@@ -229,11 +235,18 @@ fn sync_shadows(
 /// reaches zero, or no receiving surface is in the box (the reference's no-ground gate).
 #[allow(clippy::type_complexity)]
 fn update_shadows(
+    video: Res<crate::video::VideoConfig>,
     time: Res<Time>,
     catalog: Option<Res<AnimData>>,
     shadow_assets: Option<Res<ShadowAssets>>,
     images: Res<Assets<Image>>,
     decals: WorldDecal,
+    // MONKEY (night blob): the live celestial sun, for the realtime lane's day strength — the SAME
+    // `celestial_dir` height `global_light` packs the shader's night fade from, so the oval's
+    // crossfade and the realtime shadow's fade are two halves of one number.
+    lighting: Res<WowLighting>,
+    // …and the camera, for the realtime lane's EDGE fade (its cascade ends at `shadowDistance`).
+    cam_pos: Query<&GlobalTransform, With<WorldCamera>>,
     // The unit's render alpha, asked of the unit — see the alpha block below.
     unit_alpha: benilla_world::model_fade::UnitRenderAlpha,
     owners: Query<
@@ -246,6 +259,10 @@ fn update_shadows(
             // pass 2 is not in the reference's scene, so it casts nothing (decision 1277). The
             // election writes the ROOT's `Visibility`; this is that verdict after propagation.
             Option<&InheritedVisibility>,
+            // …and the unit's WMO room. `Some(room)` = indoors — the realtime SUN shadow is gated
+            // out of interiors, so an INDOOR unit keeps its oval even when `characterShadows` is on
+            // (otherwise it would have no ground shadow at all). Absent / no-room = outdoors.
+            Option<&UnitWmoRoom>,
         ),
         Without<BlobShadow>,
     >,
@@ -262,6 +279,27 @@ fn update_shadows(
     // report, answerable from a log instead of a debugger.
     mut census_at: Local<f32>,
 ) {
+    // `characterShadows 1`: the realtime shadow-map path owns OUTDOOR unit shadows — the per-unit
+    // gate in the loop below fades the oval out for outdoor units so they don't wear both, while
+    // INDOOR units keep it at full strength (the realtime sun shadow is gated out of interiors, so
+    // an indoor unit would otherwise have no ground shadow at all). (This keys on the CHARACTER
+    // lane, not the world lane: the oval is a character's shadow, so `worldShadows` alone must
+    // leave it be.) With the cvar off — the shipped default — that gate is a single false branch
+    // and this is the reference path.
+    //
+    // MONKEY (night blob): it is a FADE, not the hard hide it used to be. The realtime lane's own
+    // strength is `night · (1 − edge_fade)` (`shadow_hook.wgsl::realtime_shadow`), and `night` is
+    // `sun_shadow_strength(celestial sun height)` — exactly ZERO once the sun is under the horizon.
+    // So with the old hide, an outdoor unit between dusk and dawn had NO shadow of any kind: no
+    // realtime cast (faded to nothing) and no oval (hidden by the cvar). The reference client draws
+    // the oval all night, which is what the complement below restores. The oval is NOT replaced by
+    // a moon-lit realtime cast: benilla's rig aims only at the celestial SUN (`shadow_sun_travel`),
+    // the moon direction is `pub(super)` inside `benilla-world`'s day/night module and never
+    // reaches a shadow lane, and the packed `night` scalar would zero a moon cast anyway.
+    let sun_strength = sun_shadow_strength(lighting.celestial_dir().y);
+    // No camera yet → treat every unit as beyond the cascade, i.e. keep its oval. Failing toward
+    // "has a shadow" is the safe direction for a lane whose bug is a missing shadow.
+    let camera_pos = cam_pos.iter().next().map(GlobalTransform::translation);
     let now = time.elapsed_secs();
     let census = now >= *census_at;
     if census {
@@ -276,12 +314,31 @@ fn update_shadows(
     let surface_count = decals.receiver_count();
     for (shadow, mut key, mut verts) in &mut shadows {
         n_total += 1;
-        let Ok((unit, anims, is_self, mount_child, drawn)) = owners.get(shadow.owner) else {
+        let Ok((unit, anims, is_self, mount_child, drawn, room)) = owners.get(shadow.owner) else {
             // sync_shadows despawns next frame; keep it cleared meanwhile.
             hide(&mut key, &mut verts);
             n_no_owner += 1;
             continue;
         };
+        // `characterShadows`: the realtime cast owns OUTDOOR units, so the oval yields to it there
+        // (no double shadow). INDOOR units (`UnitWmoRoom::room()` = Some) keep it at full strength —
+        // the realtime sun shadow is gated out of interiors, so without this an indoor unit has no
+        // ground shadow at all. Absent room component / no-room claim = outdoors.
+        //
+        // MONKEY (night blob): "yields to it" is now proportional to how much the realtime lane
+        // actually casts for THIS unit — full oval at night and past the cascade edge, none in
+        // broad daylight up close, a crossfade between. Below a colour step of oval there is
+        // nothing left to draw, so that stays the early-out the hard hide used to be.
+        let indoors = room.is_some_and(|r| r.room().is_some());
+        let mut lane_w = 1.0;
+        if video.character_shadows && !indoors {
+            let cam_dist = camera_pos.map_or(f32::INFINITY, |c| unit.translation.distance(c));
+            lane_w = blob_weight(sun_strength, cam_dist, video.shadow_distance);
+            if lane_w <= 1.0 / 255.0 {
+                hide(&mut key, &mut verts);
+                continue;
+            }
+        }
         // An owner that is not drawn casts nothing. The director's report from inside Caverns of
         // Time (decision 1277): the exterior election had correctly stopped drawing the Tanaris
         // mobs overhead, and their shadows carried on being projected onto the cavern floor,
@@ -341,7 +398,13 @@ fn update_shadows(
         //
         // The self first-person fade comes with it (the reference rides the same slot), which is
         // why there is no `is_self` term here any more.
-        let alpha = unit_alpha.get(shadow.owner);
+        let mut alpha = unit_alpha.get(shadow.owner);
+        // MONKEY (night blob): the realtime-lane handover rides the SAME alpha the spawn/despawn
+        // fades do — the oval is a Multiply decal, so scaling its alpha scales its darkening, and
+        // `ShadowKey::alpha` already re-arms the projection when it moves by a colour step. `1.0`
+        // whenever the realtime lane is off, indoors, or contributing nothing, so the shipped
+        // default path is untouched.
+        alpha *= lane_w;
         if alpha <= 0.0 {
             hide(&mut key, &mut verts);
             continue;
@@ -568,6 +631,30 @@ fn key_changed(a: &ShadowKey, b: &ShadowKey) -> bool {
         || a.surfaces != b.surfaces
 }
 
+/// MONKEY (night blob): the realtime sun lane's DAY strength — 0 at or below the horizon, 1 by
+/// ~12° of elevation, smoothstepped. A three-line mirror of `sun_shadow_strength` in
+/// `benilla_world::lighting::global_light` (private there; that copy is what gets packed into the
+/// shader's `night` scalar). The pair is pinned by `oval_is_the_complement_of_the_realtime_lane`
+/// below — if the curve is ever tuned, tune both or the handover gains a seam.
+fn sun_shadow_strength(sun_height: f32) -> f32 {
+    let t = (sun_height / 0.208).clamp(0.0, 1.0); // 0.208 ≈ sin(12°)
+    t * t * (3.0 - 2.0 * t)
+}
+
+/// MONKEY (night blob): how much OVAL a unit still wears while `characterShadows` owns it.
+///
+/// `shadow_hook.wgsl::realtime_shadow` returns `1 − (1 − shadow) · night · (1 − edge_fade)`, so
+/// `night · (1 − edge_fade)` is precisely the fraction of a realtime cast that survives to the
+/// screen. The oval takes the COMPLEMENT of that: full where the realtime lane lands nothing (all
+/// night; past the cascade's last [`SHADOW_EDGE_BAND`] yards), zero where it lands everything
+/// (daylight, close in), a continuous crossfade through dusk and dawn and across the edge band —
+/// so neither shadow pops in or out.
+fn blob_weight(sun_strength: f32, cam_dist: f32, shadow_range: f32) -> f32 {
+    let t = ((cam_dist - (shadow_range - SHADOW_EDGE_BAND)) / SHADOW_EDGE_BAND).clamp(0.0, 1.0);
+    let edge_fade = t * t * (3.0 - 2.0 * t);
+    (1.0 - sun_strength.clamp(0.0, 1.0) * (1.0 - edge_fade)).clamp(0.0, 1.0)
+}
+
 /// The reference's trapezoid alpha ramp (`0x6d81a0`/`0x6d82d0`, diffed bit-exact in wow-re:
 /// `x = 12·u` — rise `x<2 → x/2`, flat `2≤x<10 → 1`, fall `x≥10 → (12−x)/2`, clamped at 0).
 fn shadow_ramp(u: f32) -> f32 {
@@ -601,6 +688,32 @@ mod tests {
         assert_eq!(shadow_ramp(2.0), 0.0);
     }
 
+    /// MONKEY (night blob): the oval is the exact complement of what the realtime lane casts —
+    /// gone in daylight up close (the old hide), FULL at night (the bug: the sun lane's `night`
+    /// scalar is 0 under the horizon, so nothing was casting and nothing was drawing either), and
+    /// full again past the cascade's edge band. Monotone in between, so no pop at dusk or dawn.
+    #[test]
+    fn oval_is_the_complement_of_the_realtime_lane() {
+        // Sun down (and the whole night): the realtime lane casts nothing → the full oval.
+        assert_eq!(sun_shadow_strength(-0.3), 0.0);
+        assert_eq!(blob_weight(sun_shadow_strength(-0.3), 10.0, 70.0), 1.0);
+        // High sun, well inside the cascade: the realtime cast owns it → no oval.
+        assert_eq!(sun_shadow_strength(0.9), 1.0);
+        assert_eq!(blob_weight(sun_shadow_strength(0.9), 10.0, 70.0), 0.0);
+        // Same high sun, but past the cascade edge: the realtime cast has faded → the oval is back.
+        assert_eq!(blob_weight(sun_shadow_strength(0.9), 80.0, 70.0), 1.0);
+        // Dusk sweeps the weight monotonically from 0 up to 1 with no jump.
+        let mut prev = 0.0;
+        for step in 0..=20 {
+            let height = 0.25 - 0.25 * step as f32 / 20.0; // ~14° down to the horizon
+            let w = blob_weight(sun_shadow_strength(height), 10.0, 70.0);
+            assert!(w >= prev - 1e-6, "dusk weight went backwards at step {step}");
+            assert!(w - prev < 0.35, "dusk weight jumped at step {step}");
+            prev = w;
+        }
+        assert!((prev - 1.0).abs() < 1e-6);
+    }
+
     /// The box law: clamp INTO ±5 pre-scale (a cap, not a floor), then scale.
     #[test]
     fn box_clamp_caps_pre_scale() {
diff --git a/crates/benilla-app/src/character_shadow.rs b/crates/benilla-app/src/character_shadow.rs
new file mode 100644
index 00000000..149dda4a
--- /dev/null
+++ b/crates/benilla-app/src/character_shadow.rs
@@ -0,0 +1,143 @@
+//! The CHARACTER shadow lane — a thin plug-in on top of [`super::shadow_core`].
+//!
+//! It owns nothing but its own per-frame caster (players, NPCs, creatures, mounts). When
+//! `characterShadows` is on it declares demand to the shared rig ([`ShadowDemand`]); while the rig
+//! is live it collects the CREATURE entity parts into its caster using the rig's shared material and
+//! the per-frame facts the rig publishes ([`ShadowFrame`]). It does not know [`super::world_shadow`]
+//! exists — remove either lane and the other is untouched.
+
+use bevy::pbr::MeshMaterial3d;
+use bevy::prelude::*;
+
+use benilla_assets::materials::WowModelMaterial;
+use benilla_world::billboard::BillboardCard;
+use benilla_world::interact::PickMesh;
+use benilla_world::model_render::{ModelPart, ShadowOccluder};
+use benilla_world::rig_palette::{RigPalettes, RigPart, RigSkin};
+
+use crate::shadow_core::{
+    collect_entity_geometry, empty_shadow_mesh, restore_mesh_buffers, shadow_trace,
+    spawn_solid_caster, take_mesh_buffers, RebuildRate, ShadowDemand, ShadowFrame, ShadowSet,
+};
+use crate::video::VideoConfig;
+
+pub(crate) struct CharacterShadowPlugin;
+
+impl Plugin for CharacterShadowPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<CharacterLane>()
+            .add_systems(Last, collect_character_shadows.in_set(ShadowSet::Lanes));
+    }
+}
+
+/// The character lane's retained per-frame caster.
+#[derive(Resource, Default)]
+struct CharacterLane {
+    caster: Option<Entity>,
+    mesh: Option<Handle<Mesh>>,
+    /// [`shadow_trace`]'s change detector: (tris, admitted, rejected).
+    traced: (u32, u32, u32),
+    /// MONKEY (sun shadow perf): the `characterShadowRate` cadence gate — see the rebuild comment
+    /// in [`collect_character_shadows`].
+    rate: RebuildRate,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn collect_character_shadows(
+    video: Res<VideoConfig>,
+    time: Res<Time>,
+    mut demand: ResMut<ShadowDemand>,
+    frame: Res<ShadowFrame>,
+    mut lane: ResMut<CharacterLane>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    parts: Query<
+        (
+            &PickMesh,
+            &ModelPart,
+            Option<&GlobalTransform>,
+            Option<&RigPart>,
+            &ShadowOccluder,
+            Option<&MeshMaterial3d<WowModelMaterial>>,
+        ),
+        Without<BillboardCard>,
+    >,
+    rigs: Query<&RigSkin>,
+    palettes: Res<RigPalettes>,
+) {
+    let on = video.character_shadows;
+    // Declare demand so the shared rig stays up while this lane is on (the rig reads it next frame).
+    demand.0 = demand.0 || on;
+
+    // Rig down or lane off → drop our caster so it stops casting.
+    if !(frame.active && on) {
+        if let Some(entity) = lane.caster.take() {
+            commands.entity(entity).despawn();
+        }
+        if let Some(handle) = lane.mesh.take() {
+            meshes.remove(handle.id());
+        }
+        // The mesh this gate was pacing is gone — re-arm so a re-enable builds on its first frame.
+        lane.rate.reset();
+        return;
+    }
+    let Some(material) = frame.material.clone() else {
+        return;
+    };
+
+    // Animated rigs re-skin every frame and creatures spawn/despawn under lifecycles this lane
+    // can't cheaply observe — so the caster is collected fresh, at a CAPPED cadence.
+    if lane.caster.is_none() {
+        let mesh = meshes.add(empty_shadow_mesh());
+        let entity = spawn_solid_caster(&mut commands, mesh.clone(), material);
+        lane.caster = Some(entity);
+        lane.mesh = Some(mesh);
+        // A brand-new caster is an EMPTY mesh; make sure this frame fills it.
+        lane.rate.reset();
+    }
+    // MONKEY (sun shadow perf): the `characterShadowRate` gate. This rebuild is the expensive half
+    // of the ~3 ms the character lane costs — it CPU-skins every admitted unit and then mutates the
+    // `Mesh` asset, and a mutated mesh is re-extracted and re-uploaded (vertices AND indices) to the
+    // GPU. Skipping it simply leaves the previous proxy in place: the shadow MAP is still rendered
+    // from that proxy every frame, so nothing flickers or disappears — a moving unit's silhouette
+    // merely lags by up to 1/rate second.
+    //
+    // Why a rate cap and not change detection: the obvious `Changed<GlobalTransform>` gate does not
+    // work here. A unit's shadow geometry comes from the RIG PALETTE (`append_skinned` reads
+    // `RigPalettes`, the per-frame skinning pose), not from the part's transform — so a standing NPC
+    // whose idle animation is breathing has an unchanged `GlobalTransform` and changed VERTICES.
+    // Gating on the transform would freeze exactly the poses this lane exists to draw. The rate cap
+    // is the honest saving, and it is bounded work rather than a guess about content.
+    if !lane.rate.due(time.elapsed_secs(), video.character_shadow_rate) {
+        return;
+    }
+    if let Some(handle) = lane.mesh.clone() {
+        if let Some(mesh) = meshes.get_mut(&handle) {
+            let (mut positions, mut indices) = take_mesh_buffers(mesh);
+            let (admitted, rejected) = collect_entity_geometry(
+                &parts,
+                &rigs,
+                &palettes,
+                true,  // want_creatures
+                false, // want_environment (the world lane's job)
+                frame.light_position,
+                frame.entity_reach,
+                frame.tall_reach,
+                &mut positions,
+                &mut indices,
+            );
+            let tris = (indices.len() / 3) as u32;
+            restore_mesh_buffers(mesh, positions, indices);
+            if shadow_trace() {
+                let now = (tris, admitted, rejected);
+                if lane.traced != now {
+                    info!(
+                        "shadow-trace: character {} tris | creatures admitted {} / rejected {} (was {:?})",
+                        tris, admitted, rejected, lane.traced
+                    );
+                    lane.traced = now;
+                }
+            }
+        }
+    }
+}
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index 0a02335d..0615c76b 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -908,6 +908,250 @@ pub(crate) const REGISTERED: &[Registered] = &[
     // `gxRestart = 1` does not apply (wgpu swaps the presentation interval live, so the box takes
     // effect on click), and `$WOW_NOVSYNC=1` overrides it session-only, below.
     same("gxVSync", "1").latched(),
+    // Benilla's opt-in realtime shadow-map path, split into two INDEPENDENT lanes over one shared
+    // shadow rig (one sun / one map). `worldShadows` = the static world (trees, buildings, foliage)
+    // casts realtime shadows and baked MCSH terrain shadows switch off; `characterShadows` =
+    // players/NPCs/creatures/mounts cast realtime silhouettes instead of the legacy oval blob.
+    //
+    // `ours(...)`, not `same(...)`: the reference has no realtime shadow at all — it bakes MCSH
+    // into the terrain and draws an oval under every unit — so there is no registered default for
+    // these two to agree with, and claiming `Same` would put a false entry in the one column
+    // [`Reference`] exists to keep honest. (They read `same("…", "1")` until the 2303 registry
+    // port; the default string is unchanged.)
+    ours(
+        "worldShadows",
+        "1",
+        "benilla's own: the static world (trees, buildings, alpha-tested foliage) casts a realtime \
+         shadow and the baked MCSH terrain shadows stand aside; the reference bakes and has no \
+         such switch",
+    ),
+    ours(
+        "characterShadows",
+        "1",
+        "benilla's own: units cast a realtime silhouette instead of the reference's oval blob \
+         decal, which is all 1.12 has and is therefore not a setting there",
+    ),
+    // Realtime-shadow render distance in yards (the shadow-map cascade range + caster reach).
+    // benilla's own — the reference has no realtime shadow to size. Clamped to SHADOW_DISTANCE_RANGE.
+    ours(
+        "shadowDistance",
+        "80",
+        "1900: benilla's own realtime-shadow render-distance slider; the reference bakes MCSH and \
+         has no cascade to size",
+    ),
+    // MONKEY (sun shadow perf): the five live dials over the sun lanes' ~5 ms/frame (RTX 3070,
+    // 1080p, both lanes on: 45-47 fps, and 68-73 with both off). All benilla's own — the reference
+    // bakes MCSH and has no realtime shadow to tune. `shadow_core`'s constants block holds the cost
+    // split each one takes; every row is LIVE, so the whole set A/Bs from one chat line.
+    ours(
+        "shadowMapSize",
+        "2048",
+        "benilla's own: directional shadow-map edge in texels, 1024/2048/4096 (cost is quadratic)",
+    ),
+    ours(
+        "shadowFilter",
+        "1",
+        "benilla's own: shadow PCF kernel: 0 hardware-2x2 (1 sample), 1 gaussian (9, the look)",
+    ),
+    ours(
+        "characterShadowRate",
+        "30",
+        "benilla's own: Hz cap on the character shadow proxy re-skin+upload, 0..120 (0 = per frame)",
+    ),
+    ours(
+        "worldShadowRate",
+        "30",
+        "benilla's own: Hz cap on the world lane's environment caster, 0..120 (0 = per frame)",
+    ),
+    ours(
+        "shadowCasterReach",
+        "1",
+        "benilla's own: multiplier on the shadow caster-collection reach, 0.25..2 (1 = unchanged)",
+    ),
+    // MONKEY (dynamic interiors): WMO interiors + their props light from the room's LIVE fixtures
+    // instead of the MOCV bake / the baked prop probe (`static_gx.wgsl` `interior_room_light`;
+    // bridged by `dynamic_interior`). The three numeric knobs are live-tunable from chat —
+    // `/script SetCVar("interiorExposure", 2)` — which is how their defaults were found.
+    ours(
+        "interiorLight",
+        "1",
+        "benilla's own: fixture-lit WMO interiors (0 = the reference's baked interior path)",
+    ),
+    ours(
+        "interiorAmbient",
+        "0.015",
+        "benilla's own: interior base ambient, 0..1",
+    ),
+    ours(
+        "interiorFill",
+        "0.08",
+        "benilla's own: interior per-fixture bounce gain, 0..2",
+    ),
+    ours(
+        "interiorExposure",
+        "2.5",
+        "benilla's own: interior light-budget multiplier before the soft rolloff, 0.25..8",
+    ),
+    // MONKEY (soft falloff): the live scale on every interior fixture's AUTHORED attenuation
+    // window (WMO MOLT `+0x28/+0x2c`; M2 sources bucket by intensity instead — their authored pair
+    // is a template default, not a reach). A fixture's EFFECTIVE RADIUS is `authored end × this`.
+    // The artists' own ends — Goldshire inn 6.97-9.53 yd over 10 fixtures, its blacksmith 6.0,
+    // NSabbey 4.17-5.56, Stormwind's 606 median 6.94 — are where FULL brightness ends, not where
+    // light stops, so `1` drew a hard-edged disc at exactly that radius with black beyond it (the
+    // abbey candelabra ring). **2.5** is the default: the pool now tails smoothly to 2.5× the
+    // authored end, reading ~⅓ of its 1 yd brightness AT the authored end and ~8 % at twice it.
+    // `>1.6` widens further, `<1.6` tightens, `0` switches the window off (the 48 yd lane), so the
+    // whole shape A/Bs from chat.
+    ours(
+        "interiorAttenScale",
+        "1.6",
+        "benilla's own: scale on interior fixtures' authored attenuation window = their effective \
+         radius, 0..8 (0 = no window, the old flat lane)",
+    ),
+    // MONKEY (room gate): whether an interior fixture may light only the rooms it CLAIMS — its
+    // authored MOLR groups unioned with the interior groups whose MOGI bounding box it stands
+    // inside (`LightLitRooms` carries the corpus evidence for why MOLR alone is far too sparse:
+    // the Goldshire inn authors one on 2 of its 12 groups). Off restores the pre-gate behaviour:
+    // every interior fixture in range lights every interior surface in range, so an inn's
+    // ground-floor candles light its basement through the floor. Kept as a dial because a room the
+    // gate leaves on ambient alone looks the same as a bug, and this tells the two apart in one
+    // keystroke.
+    ours(
+        "interiorRoomGate",
+        "1",
+        "benilla's own: an interior fixture lights only the WMO groups it claims (0 = the old \
+         leak-through-walls behaviour)",
+    ),
+    ours(
+        "interiorShadows",
+        "1",
+        "benilla's own: interior fixtures cast real shadows (Stage B, the nearest few); needs \
+         interiorLight",
+    ),
+    // MONKEY (outdoor torch shadows): the outdoor half of the same cube-map lane. Its own row
+    // because it is its own audience (a night camp, a lit village) and its own cost profile — and
+    // because "turn the outdoor shadows off" must not also turn the inn's candles' shadows off.
+    ours(
+        "exteriorShadows",
+        "1",
+        "benilla's own: outdoor fire lights (campfires, braziers, lampposts) cast real shadows at          night; no effect by day",
+    ),
+    // MONKEY (static torch cache): residency and per-frame work have separate live budgets.
+    ours(
+        "interiorShadowCasters",
+        "12",
+        "benilla's own: resident interior fixture shadow maps, 1..16",
+    ),
+    ours(
+        "interiorShadowDynamic",
+        "4",
+        "benilla's own: nearest promoted fixtures with moving entity shadows, 0..16",
+    ),
+    // MONKEY (torch lane perf): the moving-caster REGATHER cadence. Its own row (and not folded
+    // into `interiorShadowDynamic`) because it trades a different currency: `Dynamic` buys how
+    // MANY fixtures overlay moving casters, this buys how OFTEN the one shared overlay mesh is
+    // rebuilt. Neither of the count dials moved the frame time at all, so the cost was never per
+    // map -- it was this gather + mesh mutation, paid once a frame no matter what the counts said.
+    // `0` is the pre-feature every-frame behaviour, kept as the live A/B.
+    ours(
+        "interiorShadowEntityRate",
+        "30",
+        "benilla's own: how often (Hz) moving torch-shadow casters are regathered; 0 = every frame",
+    ),
+    // MONKEY (torch caster selection): the PCF tap radius on the torch maps. Candle clusters read
+    // very hard-edged at 1 (a half-texel box on a 512² face); 2 is a visible softening for four
+    // extra texel-neighbourhood taps' worth of cache pressure, no extra samples.
+    ours(
+        "interiorShadowSoft",
+        "1.5",
+        "benilla's own: torch-shadow edge softness — the PCF tap radius scale at a CONTACT, 0.5..3",
+    ),
+    // MONKEY (shadow floor): how BLACK a torch shadow is allowed to get. The lane's shadows were
+    // the only occlusion in the direct term and took all of it, which is what made them read as
+    // scars rather than as shadows; 0.7 leaves 30 % standing in place of the bounce light this
+    // renderer does not have. `1` is the shipped look, `0` is off.
+    ours(
+        "torchShadowStrength",
+        "0.7",
+        "benilla's own: torch-shadow darkness — how much of the direct term a shadow removes, 0..1",
+    ),
+    ours(
+        "interiorDebug",
+        "0",
+        "benilla's own: interior diagnostic overlay — 1 classification, 2 shadow, 3 caster count, 4 WMO lane map",
+    ),
+    // MONKEY (darkness gains): the two live dim dials. `nightGain` scales the EXTERIOR day/night
+    // law (the packed ambient/diffuse/specular rows) by `mix(1, gain, night_w)`, so it is exactly
+    // inert by day and full strength after dark; `interiorGain` scales the room lane's inputs (base
+    // ambient, per-fixture fill, and every interior fixture's colour). Both fold in at PACK time in
+    // `build_light_data`, so `SetCVar` moves the whole world on the very next frame — which is how
+    // "20 % / 30 % darker" gets judged at all, and `1` on either is the restore.
+    //
+    // Neither touches the fires: a point light keeps its brightness under both dials, because the
+    // ask is for a darker night AROUND the flame, not a dimmer flame.
+    ours(
+        "nightGain",
+        "0.45",
+        "benilla's own: exterior night brightness, 0.2..1.5 (1 = the reference's own night)",
+    ),
+    // MONKEY (lighting debug panel): weaker fresh interiors; persisted gains still win at boot.
+    ours(
+        "interiorGain",
+        "0.5",
+        "benilla's own: WMO interior brightness, 0.2..1.5 (1 = the pre-dial fixture-lit room)",
+    ),
+    // MONKEY (enclosed day floor): the daylight a room INSIDE A BUILDING gets by day, for the
+    // doorways this renderer cannot locate in the data (the Goldshire inn's entry group authors no
+    // portal, no EXT-class batch, no stitched vertex and no bake hot spot — there is nowhere to
+    // stand a fixture). An additive ambient in `interiorAmbient`'s own units, scaled by the sun's
+    // day envelope, so it is exactly 0 at night and the night look never moves. `0` is the restore.
+    ours(
+        "interiorDaylight",
+        "0.0",
+        "benilla's own: daylight floor for rooms inside a building, 0..1 (0 = none, the old look)",
+    ),
+    // MONKEY (bake floor): the share of an interior batch's own MOCV bake that survives the live-
+    // fixture lane. The lane throws the bake away and lets the fixtures decide, which leaves a room
+    // no fixture reaches (the Lion's Pride Inn's east vestibule: MOLR 0, no claims, one faded
+    // portal hop) rendering black between a sky-lit porch and a candle-lit hall — something the
+    // reference client cannot do, because it draws every interior batch at its bake regardless of
+    // lights. A fraction of the bake, inside the room law's rolloff, so a lit surface barely moves.
+    ours(
+        "interiorBakeFloor",
+        "0.12",
+        "benilla's own: share of an interior batch's baked light kept where no fixture reaches, 0..1 (0 = the old look)",
+    ),
+    // MONKEY (fire GO lights): the gain on lights SYNTHESISED from a model's flame emitter for the
+    // ~410 fire props the artists never gave a light block (campfires, wall torches, magic
+    // braziers, forges, candles). Live, like the interior knobs — and `0` is the kill switch for
+    // the whole invented-light lane, which matters because unlike everything beside it this one is
+    // a heuristic over content rather than a byte-verified mechanism.
+    ours(
+        "fireLightGain",
+        "1",
+        "benilla's own: brightness of lights synthesised from fire props' flame emitters (0 = off)",
+    ),
+    // MONKEY (spellLightGain): the same dial for the SPELL lane — a kit's aura glow, a missile's
+    // core, an impact flash, a firework's burst. A separate knob from the one above it because the
+    // two are separate judgements: that one tunes SCENERY (how bright is the invented campfire),
+    // this one tunes COMBAT (how hard does a fight flash the room), and a spell light carries both
+    // markers, so one dial over both would mean dimming the world's hearths to calm a fireball.
+    // `0` is this lane's kill switch and reaches nothing else.
+    ours(
+        "spellLightGain",
+        "1",
+        "benilla's own: brightness of spell, missile and impact lights (0 = off)",
+    ),
+    // MONKEY (flame flicker): how hard every FLAME breathes — candles fast and shallow, bonfires
+    // slow and shallower still (`benilla_world::lighting::FlameKind`). Live like the gain beside
+    // it, and `0` restores the steady constants every fire had before the feature, which is the
+    // escape hatch this needs precisely because "subtle" is a judgement call and a flicker that
+    // reads as a strobe is worse than none.
+    ours(
+        "fireFlicker",
+        "1",
+        "benilla's own: how strongly fire lights flicker — 0 steady, 1 default, 2 pronounced",
+    ),
     // **Display mode** (decisions 1627, 1650) — 1.12's own `gxWindow`, worn since 1650 as modern
     // Classic's two-entry *Display Mode* dropdown rather than 1.12's *Windowed Mode* checkbox: the
     // two states 1627 settled on ARE that client's two (its own `Graphics.lua` builds the list from
@@ -2405,6 +2649,85 @@ mod tests {
         // VSync welds to the video knob, which in turn welds to the window literal's boot
         // mode (`video::tests`) — so the registered "1" cannot drift from what we ship.
         assert_eq!(d["gxVSync"] != 0.0, VideoConfig::default().vsync);
+        // ── MONKEY (lighting): the weld for the dynamic light + shadow system's whole row set ──
+        //
+        // **All 29, as one census, with the count asserted.** Every one of them lands on
+        // `VideoConfig` and is read from there per frame (`shadow_core::update_shadows`,
+        // `dynamic_interior::bridge`, `torch_shadow`), so a registered default that drifts from
+        // the struct's literal is a setting that reads one way in `config.toml` and renders
+        // another — invisible until someone compares a fresh install against a configured one.
+        // Spelling the table out rather than asserting a favourite handful is what makes "added
+        // a row, forgot its weld" fail HERE: the length check below is the gate.
+        let shadows = VideoConfig::default();
+        let flag = |b: bool| if b { 1.0 } else { 0.0 };
+        let lighting: [(&str, f32); 29] = [
+            // The two sun lanes and the cascade they share.
+            ("worldShadows", flag(shadows.world_shadows)),
+            ("characterShadows", flag(shadows.character_shadows)),
+            ("shadowDistance", shadows.shadow_distance),
+            // MONKEY (sun shadow perf): the five cost dials.
+            ("shadowMapSize", shadows.shadow_map_size as f32),
+            ("shadowFilter", shadows.shadow_filter as f32),
+            ("characterShadowRate", shadows.character_shadow_rate as f32),
+            ("worldShadowRate", shadows.world_shadow_rate as f32),
+            ("shadowCasterReach", shadows.shadow_caster_reach),
+            // MONKEY (dynamic interiors): the room lane's switch and its light law.
+            ("interiorLight", flag(shadows.interior_light)),
+            ("interiorAmbient", shadows.interior_ambient),
+            ("interiorFill", shadows.interior_fill),
+            ("interiorExposure", shadows.interior_exposure),
+            ("interiorAttenScale", shadows.interior_atten_scale),
+            ("interiorRoomGate", flag(shadows.interior_room_gate)),
+            ("interiorDebug", shadows.interior_debug as f32),
+            // MONKEY (torch shadows): the cube-map lane, indoors and out.
+            ("interiorShadows", flag(shadows.interior_shadows)),
+            ("exteriorShadows", flag(shadows.exterior_shadows)),
+            (
+                "interiorShadowCasters",
+                shadows.interior_shadow_casters as f32,
+            ),
+            (
+                "interiorShadowDynamic",
+                shadows.interior_shadow_dynamic as f32,
+            ),
+            (
+                "interiorShadowEntityRate",
+                shadows.interior_shadow_entity_rate as f32,
+            ),
+            ("interiorShadowSoft", shadows.interior_shadow_soft),
+            ("torchShadowStrength", shadows.torch_shadow_strength),
+            // MONKEY (darkness gains) / (enclosed day floor) / (bake floor): the four level dials.
+            ("nightGain", shadows.night_gain),
+            ("interiorGain", shadows.interior_gain),
+            ("interiorDaylight", shadows.interior_daylight),
+            ("interiorBakeFloor", shadows.interior_bake_floor),
+            // MONKEY (fire GO lights) / (spellLightGain) / (flame flicker): the invented lanes.
+            ("fireLightGain", shadows.fire_light_gain),
+            ("spellLightGain", shadows.spell_light_gain),
+            ("fireFlicker", shadows.fire_flicker),
+        ];
+        for (name, want) in lighting {
+            assert_eq!(d[name], want, "{name}: registered default left the knob");
+        }
+        // …and the census IS the row set. A name here that nothing registers would weld against a
+        // row the client does not have; the length is the other half — 29 rows, 29 welds.
+        let welded: std::collections::BTreeSet<&str> = lighting.iter().map(|(n, _)| *n).collect();
+        assert_eq!(welded.len(), 29, "the lighting lane welds 29 distinct rows");
+        for name in &welded {
+            assert!(
+                REGISTERED.iter().any(|r| r.name == *name),
+                "{name}: welded but not registered"
+            );
+        }
+        // Three of them are CALIBRATED rather than chosen, so the weld alone is not enough — it
+        // would pass just as happily if a tuning session left the struct's literal wherever it was
+        // last dragged in the debug panel. These pin the measured numbers themselves.
+        assert_eq!(d["interiorGain"], 0.5, "MONKEY (lighting debug panel)");
+        // MONKEY (bake floor): the inn's black door band measured up to 0.108 x tex with
+        // candle-lit surfaces moving under +10 % — only true at this number.
+        assert_eq!(d["interiorBakeFloor"], 0.12);
+        assert_eq!(d["spellLightGain"], 1.0, "the spell lane ships neutral");
+        // ── end MONKEY (lighting) ─────────────────────────────────────────────────────────────
         // The pane half-rate (1444) welds to the portrait knob's shipped default.
         assert_eq!(d["boothHalfRate"] != 0.0, PaneRate::default().half);
         // Render scale (1639) welds to OFF. Not a taste default: the whole tree of visual
diff --git a/crates/benilla-app/src/debug_panel/lighting_controls.rs b/crates/benilla-app/src/debug_panel/lighting_controls.rs
new file mode 100644
index 00000000..9776689d
--- /dev/null
+++ b/crates/benilla-app/src/debug_panel/lighting_controls.rs
@@ -0,0 +1,192 @@
+//! MONKEY (lighting debug panel): a native editor for the LIVE video CVars. Reads are typed
+//! `VideoConfig` fields, never a second settings store; changed widgets alone call
+//! `UiScript::set_cvar_engine`, whose queue is the same one Lua `SetCVar` feeds. The normal host
+//! sync owns clamps, renderer bridges and persistence, so a slider and a chat command cannot
+//! acquire separate truths. Registry lookup is reserved for an explicit reset, not idle frames.
+
+use std::ops::RangeInclusive;
+
+use benilla_ui::script::UiScript;
+use bevy_egui::egui;
+
+use crate::cvars::REGISTERED;
+use crate::shadow_core::{CASTER_REACH_RANGE, MAX_SHADOW_RATE, SHADOW_DISTANCE_RANGE, SHADOW_MAP_SIZES};
+use crate::video::VideoConfig;
+
+enum Widget {
+    Toggle,
+    Slider(RangeInclusive<f32>),
+    Integer(RangeInclusive<f32>),
+    Choice(&'static [u32]),
+}
+
+struct Knob {
+    name: &'static str,
+    read: fn(&VideoConfig) -> f32,
+    widget: Widget,
+    help: &'static str,
+}
+
+// MONKEY (lighting debug panel): keep names, typed reads and presentation together. The numeric
+// bounds mirror `video::on_cvar`'s MONKEY (lighting) arms — the registry's change-callback
+// observer since 2303 — including their wider ambient/fill/attenuation ranges;
+// shared shadow constants follow the setter directly. Casting the booleans through u32 keeps
+// the descriptor read-only without inventing a parallel configuration type.
+macro_rules! knob {
+    ($name:literal, $field:ident, $widget:expr, $help:literal) => {
+        Knob { name: $name, read: |v| v.$field as f32, widget: $widget, help: $help }
+    };
+    (flag $name:literal, $field:ident, $help:literal) => {
+        Knob { name: $name, read: |v| v.$field as u32 as f32, widget: Widget::Toggle, help: $help }
+    };
+}
+
+use Widget::{Choice, Integer, Slider};
+
+const INTERIOR: &[Knob] = &[
+    knob!(flag "interiorLight", interior_light, "Fixture-lit interiors; off restores the baked path."),
+    knob!("interiorGain", interior_gain, Slider(0.2..=1.5), "Overall room input brightness."),
+    knob!("interiorAmbient", interior_ambient, Slider(0.0..=1.0), "Base room ambient."),
+    knob!("interiorFill", interior_fill, Slider(0.0..=2.0), "Per-fixture bounce gain."),
+    // MONKEY (bake floor): index 4, immediately after fill, because the three presets below take
+    // `INTERIOR[1..5]` as one group — this dial belongs with gain/ambient/fill, not with the
+    // exposure and reach knobs the presets deliberately leave alone.
+    knob!("interiorBakeFloor", interior_bake_floor, Slider(0.0..=1.0), "Share of a room's baked light kept where no fixture reaches; 0 = fixtures only."),
+    knob!("interiorExposure", interior_exposure, Slider(0.25..=8.0), "Light budget before soft rolloff."),
+    knob!("interiorAttenScale", interior_atten_scale, Slider(0.0..=8.0), "Pool radius scale; 0 disables the authored window."),
+    knob!("interiorDaylight", interior_daylight, Slider(0.0..=1.0), "Sun-driven day floor in enclosed rooms."),
+    knob!(flag "interiorRoomGate", interior_room_gate, "Restrict fixtures to the rooms they claim."),
+];
+
+const GROUPS: &[(&str, &[Knob])] = &[
+    ("Interior light", INTERIOR),
+    ("Fire", &[
+        knob!("fireLightGain", fire_light_gain, Slider(0.0..=4.0), "Brightness of lights synthesized from flame emitters."),
+        // MONKEY (spellLightGain): in the "Fire" group because a spell light IS one of the invented
+        // sources this group tunes — it is just the one whose brightness is a combat setting rather
+        // than a scenery one, which is exactly why it needs its own dial and not the one above it.
+        knob!("spellLightGain", spell_light_gain, Slider(0.0..=4.0), "Brightness of spell, missile and impact lights."),
+        knob!("fireFlicker", fire_flicker, Slider(0.0..=2.0), "0 steady, 1 default, 2 pronounced."),
+    ]),
+    ("Torch shadows", &[
+        knob!(flag "interiorShadows", interior_shadows, "Interior fixture shadows; requires interiorLight."),
+        knob!(flag "exteriorShadows", exterior_shadows, "Outdoor fire shadows at night."),
+        knob!("interiorShadowCasters", interior_shadow_casters, Integer(1.0..=16.0), "Resident fixture shadow maps."),
+        knob!("interiorShadowDynamic", interior_shadow_dynamic, Integer(1.0..=crate::torch_shadow::MAX_TORCH_DYNAMIC as f32), "Nearest fixtures with moving entity shadows."),
+        knob!("interiorShadowSoft", interior_shadow_soft, Slider(0.5..=3.0), "Shadow edge softness at a contact; the penumbra grows from it."),
+        knob!("torchShadowStrength", torch_shadow_strength, Slider(0.0..=1.0), "Shadow darkness: how much direct light a shadow removes. 1 = black."),
+        knob!("interiorShadowEntityRate", interior_shadow_entity_rate, Integer(0.0..=240.0), "Moving caster regather Hz; 0 = every frame."),
+    ]),
+    ("Sun shadows", &[
+        knob!(flag "characterShadows", character_shadows, "Realtime character silhouettes instead of blobs."),
+        knob!(flag "worldShadows", world_shadows, "Realtime static-world shadows instead of baked terrain shadows."),
+        knob!("shadowDistance", shadow_distance, Slider(SHADOW_DISTANCE_RANGE), "Shadow distance in yards."),
+        knob!("shadowMapSize", shadow_map_size, Choice(&SHADOW_MAP_SIZES), "Map edge in texels; larger maps cost more GPU time and memory."),
+        knob!("shadowFilter", shadow_filter, Widget::Toggle, "0 hardware 2x2, 1 Gaussian PCF."),
+        knob!("characterShadowRate", character_shadow_rate, Integer(0.0..=MAX_SHADOW_RATE as f32), "Character shadow update Hz; 0 = every frame."),
+        knob!("worldShadowRate", world_shadow_rate, Integer(0.0..=MAX_SHADOW_RATE as f32), "World shadow update Hz; 0 = every frame."),
+        knob!("shadowCasterReach", shadow_caster_reach, Slider(CASTER_REACH_RANGE), "Caster collection reach multiplier."),
+    ]),
+    ("Night", &[
+        knob!("nightGain", night_gain, Slider(0.2..=1.5), "Exterior night brightness; inert by day."),
+    ]),
+    ("Debug", &[
+        knob!("interiorDebug", interior_debug, Choice(&[0, 1, 2, 3, 4]), "0 off, 1 classification, 2 shadow, 3 caster count, 4 WMO lane map."),
+    ]),
+];
+
+fn reset(script: &mut UiScript, knobs: &[Knob]) {
+    for knob in knobs {
+        let registered = REGISTERED.iter().find(|r| r.name == knob.name)
+            .expect("lighting panel knob must be registered");
+        script.set_cvar_engine(registered.name, registered.default);
+    }
+}
+
+fn row(ui: &mut egui::Ui, video: &VideoConfig, script: &mut UiScript, knob: &Knob) {
+    let mut value = (knob.read)(video);
+    // MONKEY (lighting debug panel): stack the label over numeric controls so even the longest
+    // CVar fits the existing 280 px panel. Sliders retain their editable current-value readout;
+    // integer knobs cannot queue fractional counts/rates, and flags explicitly show their 0/1.
+    let changed = ui.push_id(knob.name, |ui| match &knob.widget {
+        Widget::Toggle => {
+            let mut enabled = value != 0.0;
+            let response = ui.checkbox(&mut enabled, format!("{}  {}", knob.name, value as u32))
+                .on_hover_text(knob.help);
+            value = enabled as u32 as f32;
+            response.changed()
+        }
+        Slider(range) | Integer(range) => {
+            ui.label(knob.name).on_hover_text(knob.help);
+            let mut slider = egui::Slider::new(&mut value, range.clone());
+            if matches!(knob.widget, Integer(_)) {
+                slider = slider.integer();
+            }
+            ui.add(slider).on_hover_text(knob.help).changed()
+        }
+        Choice(options) => {
+            ui.label(knob.name).on_hover_text(knob.help);
+            let mut changed = false;
+            egui::ComboBox::from_id_salt("value")
+                .selected_text((value as u32).to_string())
+                .show_ui(ui, |ui| {
+                    for &option in *options {
+                        changed |= ui.selectable_value(&mut value, option as f32, option.to_string()).changed();
+                    }
+                });
+            changed
+        }
+    }).inner;
+    if changed {
+        script.set_cvar_engine(knob.name, &value.to_string());
+    }
+}
+
+pub(super) fn section(ui: &mut egui::Ui, video: &VideoConfig, script: Option<&mut UiScript>) {
+    let Some(script) = script else {
+        ui.weak("Lighting controls are available once the UI session is ready.");
+        return;
+    };
+    ui.horizontal(|ui| {
+        ui.label("Presets");
+        for (label, values) in [
+            // MONKEY (bake floor): the fourth value is `interiorBakeFloor`, and it rides the
+            // presets because it is a room BRIGHTNESS INPUT exactly like the three beside it.
+            // Leaving it out would make the presets change the RATIO between a fixture-lit room
+            // and a fixture-starved one rather than the level of both: Bright would raise the
+            // candles and leave the vestibule at the Default floor. (The `interiorGain` the
+            // presets also set does scale it at pack time, so its own value composes with that
+            // — which is why Dim asks for 0.08 and not for 0.12 halved twice.)
+            ("Dim", Some(["0.5", "0.015", "0.08", "0.08"])),
+            ("Default", None),
+            ("Bright", Some(["1.0", "0.04", "0.16", "0.2"])),
+        ] {
+            if ui.small_button(label).on_hover_text("Only gain, ambient, fill and bake floor; other settings stay as they are.").clicked() {
+                if let Some(values) = values {
+                    for (knob, value) in INTERIOR[1..5].iter().zip(values) {
+                        script.set_cvar_engine(knob.name, value);
+                    }
+                } else {
+                    reset(script, &INTERIOR[1..5]);
+                }
+            }
+        }
+    });
+    if ui.small_button("Reset all").on_hover_text("Restore registry defaults for every group in Lighting & shadows.").clicked() {
+        for (_, knobs) in GROUPS {
+            reset(script, knobs);
+        }
+    }
+    for (name, knobs) in GROUPS {
+        ui.push_id(name, |ui| {
+            ui.separator();
+            ui.strong(*name);
+            for knob in *knobs {
+                row(ui, video, script, knob);
+            }
+            if ui.small_button("Reset group to defaults").clicked() {
+                reset(script, knobs);
+            }
+        });
+    }
+}
diff --git a/crates/benilla-app/src/debug_panel/mod.rs b/crates/benilla-app/src/debug_panel/mod.rs
index aaa43d89..3b991233 100644
--- a/crates/benilla-app/src/debug_panel/mod.rs
+++ b/crates/benilla-app/src/debug_panel/mod.rs
@@ -50,6 +50,7 @@ use crate::ui_script::EguiPointerOver;
 
 mod inspect;
 mod journal;
+mod lighting_controls;
 
 /// The dev state this panel edits — resource-only, faithful defaults (decision 0026: the
 /// always-present config layer; this module is only its editor). The engine owns and inits it,
@@ -397,7 +398,11 @@ fn debug_panel_ui(
     ping: Res<crate::net::PingShared>,
     dropped: Res<crate::net::DroppedOpcodes>,
     mut weather_state: Option<ResMut<benilla_world::weather::WeatherState>>,
-    mut world: WorldReadout,
+    (mut world, video, mut script): (
+        WorldReadout,
+        Res<crate::video::VideoConfig>,
+        Option<NonSendMut<benilla_ui::script::UiScript>>,
+    ),
 ) -> Result {
     if !debug.open {
         return Ok(());
@@ -583,6 +588,12 @@ fn debug_panel_ui(
                             ui.checkbox(&mut l.disable_sky_dome, "disable sky dome");
                         });
 
+                    egui::CollapsingHeader::new("Lighting & shadows")
+                        .default_open(false)
+                        .show(ui, |ui| {
+                            lighting_controls::section(ui, &video, script.as_deref_mut());
+                        });
+
                     egui::CollapsingHeader::new("Weather")
                         .default_open(false)
                         .show(ui, |ui| {
diff --git a/crates/benilla-app/src/dynamic_interior.rs b/crates/benilla-app/src/dynamic_interior.rs
new file mode 100644
index 00000000..621924ef
--- /dev/null
+++ b/crates/benilla-app/src/dynamic_interior.rs
@@ -0,0 +1,94 @@
+//! MONKEY (dynamic interiors): the app-side half of the fixture-lit WMO interior lane — a
+//! plug-and-play bridge from the `interiorLight` / `interiorAmbient` / `interiorFill` /
+//! `interiorExposure` cvars ([`VideoConfig`]) to benilla-world's [`DynamicInteriors`] resource,
+//! which `global_light` packs for `static_gx.wgsl`'s `interior_room_light` (WMO interior surfaces
+//! AND interior props light from the room's live fixtures instead of the MOCV bake / the baked prop
+//! probe). Independent of the shadow lanes: removing this plugin leaves the resource at its
+//! shipped defaults; `interiorLight 0` restores the faithful baked interior path.
+//!
+//! The knobs are LIVE — `/script SetCVar("interiorExposure", 2)` in chat retunes the room without
+//! a rebuild, which is how the defaults were found.
+//!
+//! MONKEY (fire GO lights): the same bridge also carries `fireLightGain` →
+//! [`benilla_world::lighting::FireLightGain`]. Same shape, same guard, same liveness requirement —
+//! and `fireLightGain 0` is the kill switch for the synthesised-fire lane the way `interiorLight 0`
+//! is for this one.
+//!
+//! MONKEY (spellLightGain): and `spellLightGain` → [`benilla_world::lighting::SpellLightGain`],
+//! the third of the same shape.
+use benilla_world::lighting::{DynamicInteriors, FireLightGain, SpellLightGain};
+use bevy::prelude::*;
+
+use crate::video::VideoConfig;
+
+pub(crate) struct DynamicInteriorPlugin;
+
+impl Plugin for DynamicInteriorPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, bridge);
+    }
+}
+
+/// Publish the cvars to benilla-world when they change. Guarded so the resource's change ticks
+/// stay quiet on idle frames.
+///
+/// MONKEY (fire GO lights): `fireLightGain` rides along here rather than in a module of its own —
+/// it is the same shape (a live video cvar → a benilla-world resource the light packer reads) and
+/// the same one-line guard, and a second plugin to carry one `f32` is not worth its wiring.
+fn bridge(
+    video: Res<VideoConfig>,
+    mut out: ResMut<DynamicInteriors>,
+    mut fire: ResMut<FireLightGain>,
+    // MONKEY (spellLightGain): the spell lane's own gain rides the same bridge as the fire gain,
+    // for the same reasons — same shape (a live video cvar → a benilla-world resource the packer
+    // reads), same one-line guard, and a third plugin to carry a second `f32` is not worth its
+    // wiring. Kept a SEPARATE resource rather than a field on `DynamicInteriors` because it is not
+    // an interior knob at all: a fireball down a street takes it exactly as one down a corridor
+    // does, and `FireLightGain` beside it already stands as the precedent for that.
+    mut spell: ResMut<SpellLightGain>,
+) {
+    if fire.0 != video.fire_light_gain {
+        fire.0 = video.fire_light_gain;
+    }
+    if spell.0 != video.spell_light_gain {
+        spell.0 = video.spell_light_gain;
+    }
+    let want = DynamicInteriors {
+        enabled: video.interior_light,
+        ambient: video.interior_ambient,
+        fill: video.interior_fill,
+        exposure: video.interior_exposure,
+        // MONKEY (interior attenuation): the authored-window scale rides the same bridge — the
+        // light packer folds it into every interior entry's packed reach, so
+        // `SetCVar("interiorAttenScale", 2)` widens every pool on the very next frame.
+        atten_scale: video.interior_atten_scale,
+        // MONKEY (room gate): the packer turns this into a per-light claim head, so
+        // `SetCVar("interiorRoomGate", 0)` restores the ungated look on the very next frame.
+        room_gate: video.interior_room_gate,
+        debug: video.interior_debug,
+        // MONKEY (flame flicker): the wobble gain rides the same bridge — it is consumed entirely
+        // on the CPU in `build_light_data`, so `SetCVar("fireFlicker", 0)` freezes every flame on
+        // the very next frame with no respawn and no shader change.
+        flicker: video.fire_flicker,
+        // MONKEY (darkness gains): both dim dials ride this same bridge — they are consumed
+        // entirely on the CPU in `build_light_data` (folded into the packed rows / the packed
+        // colours), so `SetCVar("nightGain", 1)` restores the reference night on the very next
+        // frame with no respawn and no shader change. `night_gain` is an EXTERIOR knob living on an
+        // interior-named resource for the sake of one bridge rather than two; the packer reads it
+        // ungated by `enabled`.
+        night_gain: video.night_gain,
+        interior_gain: video.interior_gain,
+        // MONKEY (enclosed day floor): the daylight floor rides the same bridge, but is consumed in
+        // the SHADER (it rides the packed `wmo_fog_params.w` fraction) rather than folded on the
+        // CPU — the packer's only job is to put it in the lane.
+        daylight: video.interior_daylight,
+        // MONKEY (bake floor): the bake floor rides the same bridge. Half CPU, half shader: the
+        // packer folds `interiorGain` in and puts the product in the `sh_c16.w` fraction, and the
+        // two interior lanes read it from there — so `SetCVar("interiorBakeFloor", 0)` restores
+        // the pre-feature look on the very next frame with no respawn and no pipeline rebuild.
+        bake_floor: video.interior_bake_floor,
+    };
+    if *out != want {
+        *out = want;
+    }
+}
diff --git a/crates/benilla-app/src/entities.rs b/crates/benilla-app/src/entities.rs
index a47894d7..bb264ee9 100644
--- a/crates/benilla-app/src/entities.rs
+++ b/crates/benilla-app/src/entities.rs
@@ -47,6 +47,16 @@ use attach::{attach_entity_visuals, build_dressup_preview, build_glue_pet, build
 /// decision 0016's law applied to the *entity* half of the scene, not just the placed half.
 mod carried_light;
 use carried_light::spawn_carried_lights;
+// MONKEY (spell light): the same file's second spawner — the ONE light a luminous spell effect /
+// firework throws, hung on the effect's own root so the effect's death reaps it. Used by the kit,
+// missile and dest-anchored lanes.
+use carried_light::spawn_spell_light;
+// MONKEY (carried light stability): `torch_shadow` needs the settle verdict to refuse a MOVING
+// carried light a cube-shadow slot.
+pub(crate) use carried_light::CarriedLightMotion;
+// MONKEY (outdoor torch shadows): …and the HELD/creature-owned marker, so the exterior shadow lane
+// can refuse a torch that a body is carrying.
+pub(crate) use carried_light::HeldLight;
 
 /// Equipment visuals (decisions 0072/0074): held items (weapon/shield/ranged) plus worn-armor and
 /// helm/shoulder resolution, all resolved from the unit descriptor + ItemDisplayInfo and spawned as
@@ -965,6 +975,41 @@ impl Plugin for EntitiesPlugin {
                 .after(apply_render_fade)
                 .before(crate::player::apply_self_model_fade),
         )
+        // MONKEY (fire GO lights): copy each carried light's owner room onto the light, so an
+        // entity's torch/brazier is portal-gated like a building's own fixture AND is eligible for
+        // a cube shadow. In `Update` **after the classifier** — that is the frame's only writer of
+        // `InteriorAnchor::room`, and the whole of `Update` precedes `PostUpdate`'s light pack
+        // (`lighting::build_light_data`), so a claim made here is always in this frame's table.
+        .add_systems(
+            Update,
+            carried_light::claim_carried_light_rooms
+                .after(benilla_world::interior::classify_entity_interior),
+        )
+        // MONKEY (carried light stability): how long each carried light has been standing still,
+        // which is what lets `torch_shadow` refuse a MOVING one a cube-shadow slot (a walking
+        // bearer invalidated its cached depth map every frame, and a withdrawn map zeroes the
+        // slot's cross-fade weight with no ramp — the imp's strobing green pool). `PostUpdate`
+        // after transform propagation, because a child light's `GlobalTransform` is only this
+        // frame's once `Propagate` has run; `update_torch_shadows` reads it later the SAME frame,
+        // in `Last`.
+        .add_systems(
+            PostUpdate,
+            carried_light::track_carried_light_motion
+                .after(bevy::transform::TransformSystems::Propagate),
+        )
+        // MONKEY (spell light): the luminous-effect lights' envelope and their ceiling. `Update`,
+        // after the attach passes that spawn them (`EntityVisualsSet`) so a light born this frame
+        // is already on its own clock, and well before `PostUpdate`'s packer reads the intensity
+        // they write. The budget runs after the envelope so the age it orders on is this frame's.
+        .add_systems(
+            Update,
+            (
+                spell_fx::advance_spell_lights,
+                spell_fx::budget_spell_lights,
+            )
+                .chain()
+                .after(EntityVisualsSet),
+        )
         // The aura CharProc layer (`crate::aura_visual`): the state kit's effect on the BODY.
         // The drain installs/removes this frame's nodes; the author then owns the render alpha
         // of every part under a translucent unit — after the three steady-state alpha authors
diff --git a/crates/benilla-app/src/entities/attach/mod.rs b/crates/benilla-app/src/entities/attach/mod.rs
index 4ed7cac5..29898d73 100644
--- a/crates/benilla-app/src/entities/attach/mod.rs
+++ b/crates/benilla-app/src/entities/attach/mod.rs
@@ -1017,7 +1017,13 @@ pub(super) fn attach_entity_visuals(
                         .map(|a| (l.def.bone, a))
                 })
                 .collect();
-            super::spawn_carried_lights(&mut commands, model_lights, entity, |bone| {
+            // MONKEY (outdoor torch shadows): a CREATURE's own glow is body-carried and may not
+            // cast an outdoor shadow (`carried_light::HeldLight` holds the three reasons); a
+            // placed GameObject — a brazier, a campfire, a lit quest object — is a fixture that
+            // stands still, so it stays eligible. `net.kind` is the only place the two are told
+            // apart: downstream both are just a `PointLight` under a `ChildOf`.
+            let body_carried = !matches!(net.kind, EntityKind::GameObject);
+            super::spawn_carried_lights(&mut commands, model_lights, entity, body_carried, |bone| {
                 light_anchors.get(&bone).copied()
             });
             // Ribbon trails (wisp streamers, trailing quest-object crystals) — the same host-bone
diff --git a/crates/benilla-app/src/entities/carried_light.rs b/crates/benilla-app/src/entities/carried_light.rs
index e00ef207..daf059d4 100644
--- a/crates/benilla-app/src/entities/carried_light.rs
+++ b/crates/benilla-app/src/entities/carried_light.rs
@@ -26,7 +26,19 @@ use benilla_assets::coords::wow_to_bevy;
 use benilla_assets::ModelLight;
 use bevy::prelude::*;
 
-use benilla_world::terrain_stream::point_light;
+use benilla_world::interior::{InteriorAnchor, WmoResidency};
+use benilla_world::lighting::{
+    LightLane, LightLitRooms, LightRooms, ShadowProxyLight, SpellFxLight, SyntheticFireLight,
+    WorldPointLight,
+};
+use benilla_world::static_gx::LightOwner;
+use benilla_world::terrain_stream::{carried_light_claims, point_light, CarriedClaimSet};
+use benilla_world::wmo_portal::{WmoGroupVis, WmoPortalInstance, WmoRoom};
+
+// MONKEY (spell light): the effect-side lifecycle this file's spawn helper stamps on — the
+// envelope, the budget and the kill switch all live beside the rest of the effect lifecycle
+// (`spell_fx::lifecycle`), because that is what a spell light's lifetime IS.
+use super::spell_fx::{spell_lights_enabled, SpellLight, SpellLightMode, SPELL_BURST_SPAN};
 
 /// Spawn a `PointLight` child for each **casting** (`type==1`, not visibility-gated dark) M2 light of
 /// an entity's model.
@@ -39,17 +51,62 @@ use benilla_world::terrain_stream::point_light;
 ///
 /// Children, not free entities: the light's lifecycle and its frame both come from the hierarchy, so
 /// a gear change, a despawn, or a mount transition takes its lights with it.
+/// MONKEY (outdoor torch shadows): this light is carried BY A BODY — a held torch, a creature's
+/// own glow (an imp's hand flame, a fire elemental), a player's lantern. It is a marker, not a
+/// gate: the light still lights the world exactly as it did, and it is still eligible for an
+/// INTERIOR cube-shadow slot (that lane's behaviour is unchanged by this feature).
+///
+/// What it refuses is the EXTERIOR shadow lane. Three separate reasons, any one of which is enough:
+///  · the caster gather cannot exclude the owner's own body from its own map (the emitter-owner
+///    exclusion below works on retained `GxItem` bounds; a skinned creature is not one), so a
+///    torch-bearing guard would stand in his own shadow, at full outdoor strength;
+///  · a body walks, and this lane caches a depth cube per fixture and withdraws it the moment the
+///    fixture leaves the 0.1 yd it was baked at ([`super::super::torch_shadow`]'s
+///    `map_publishable`) — indoors a held torch is one of twelve resident candles and its churn is
+///    hidden, outdoors it would be one of six casters for a whole village;
+///  · the effect being built is "the CAMPFIRE throws the fence's shadow", and a shadow that walks
+///    with the light source is the one thing that reads as a bug rather than as lighting.
+/// Placed GameObject braziers and campfires are NOT held — they keep their slot (the
+/// [`CarriedLightMotion::settled`] gate is what covers a brazier riding a moving transport).
+#[derive(Component, Clone, Copy)]
+pub(crate) struct HeldLight;
+
 pub(super) fn spawn_carried_lights(
     commands: &mut Commands,
     lights: &[ModelLight],
     frame: Entity,
+    // MONKEY (outdoor torch shadows): does a BODY carry these lights? See [`HeldLight`].
+    held: bool,
     joint: impl Fn(i16) -> Option<Entity>,
 ) {
     for l in lights {
         if !l.def.casts() {
             continue; // directionals feed an ambient term; a static `0` visibility key is dark
         }
-        let (parent, local) = match joint(l.def.bone) {
+        // MONKEY (carried light stability): a SYNTHESISED light (`fire_light` — the imp's hand
+        // flames, a brazier GameObject, a fire elemental) does NOT ride its host bone; an
+        // AUTHORED one still does.
+        //
+        // The distinction is what the position MEANS. An authored light block is a fixture an
+        // artist put on a bone, and `0x718960` re-registering it through the live bone matrix is
+        // the reference's own behaviour — the held torch that tracks the swinging hand, and that
+        // case takes the boneless arm below anyway (a held item spawns no skeleton). A synthesised
+        // one is a stand-in for a whole flame VOLUME whose position we GUESSED off the emitter
+        // record: it is already approximate to within the flame's own size, and riding a hand bone
+        // through an idle animation adds high-frequency motion that every consumer downstream
+        // reads as an EVENT rather than as a wobble. The per-vertex nearest-3 in `point_light_sum`
+        // re-ranks; and the cube-shadow cache tripped its 0.1 yd staleness test
+        // (`torch_shadow::map_publishable`) every single frame and withdrew its map, which
+        // `TorchTable::pack` answers by forcing that slot's cross-fade weight to 0 with no ramp —
+        // a full-strength shadow toggling at frame rate. That is the reported "the imp produces a
+        // DISCO with its light".
+        //
+        // The rest pose is identity about the pivot ([`ModelLight::bone_pivot`]), so hanging the
+        // light off `frame` at the raw model-space `def.position` puts it EXACTLY where the bone
+        // ride puts it in the rest pose — and `frame` is the model root, so the light still
+        // follows the unit's own motion with zero lag. Only the animation is dropped.
+        let host = if l.synthetic { None } else { joint(l.def.bone) };
+        let (parent, local) = match host {
             Some(j) => (
                 j,
                 [
@@ -60,21 +117,705 @@ pub(super) fn spawn_carried_lights(
             ),
             None => (frame, l.def.position),
         };
-        let glow = commands
-            .spawn((
-                point_light(l.def.diffuse_color, l.def.diffuse_intensity),
-                Transform::from_translation(wow_to_bevy(local)),
-                Visibility::default(),
-            ))
-            .id();
+        // MONKEY (spell light): a SPELL/FIREWORK-derived light is not a carried FIXTURE and does
+        // not take this lane's rules. It has an onset, a lifecycle envelope and a budget, and it
+        // never flickers — all of which live on [`SpellLight`]. The branch is here because the
+        // firework GameObject arrives HERE: its shell (`World\Goober\G_Firework0*`) is a GO model
+        // like any other, so the entity lane is the only place its light can be born.
+        if let Some(fx) = l.spell {
+            spawn_spell_light_child(
+                commands,
+                parent,
+                local,
+                l,
+                fx,
+                // A GameObject that carries a spell light IS a one-shot: a firework shell, a
+                // trigger's effect model. Nothing on this lane holds.
+                SpellLightMode::Burst {
+                    span: SPELL_BURST_SPAN,
+                },
+            );
+            continue;
+        }
+        let mut glow = commands.spawn((
+            point_light(l.def.diffuse_color, l.def.diffuse_intensity),
+            Transform::from_translation(wow_to_bevy(local)),
+            Visibility::default(),
+        ));
+        // MONKEY (fire GO lights): a light we DERIVED from the model's flame emitter is tagged, so
+        // the packer can ride the live `fireLightGain` over it (and only over it). The entity lanes
+        // take synthetic lights: a placed brazier GameObject, a fire elemental, a flaming helm have
+        // no MOLT fixture standing beside them the way a WMO's own wall torches do.
+        if l.synthetic {
+            glow.insert(SyntheticFireLight);
+        }
+        // MONKEY (outdoor torch shadows): the exterior shadow lane's refusal marker (see
+        // [`HeldLight`]). Tagged at the SPAWN site because that is the only place that knows who
+        // owns the light — downstream all a query sees is a `PointLight` with a `ChildOf`, which a
+        // placed brazier GameObject has just as much as a guard's torch does.
+        if held {
+            glow.insert(HeldLight);
+        }
+        // MONKEY (torch owner exclusion): and the light's OWNER — the model frame it belongs to.
+        // Same bug as the placed lane's (`terrain_stream::spawn`'s `tag_light_owner`): the flame
+        // sits INSIDE the thing that burns it, so a placed brazier GameObject was the nearest
+        // occluder on all six of its own cube faces and stamped a black disc on the ground under
+        // itself. No `WorldObject` exists at this spawn site — a carried light's host is a net
+        // entity, not a placement — so the identity is the FRAME, and the caster gather asks
+        // "is this part a descendant of it?" (`LightOwner::Instance`).
+        glow.insert(LightOwner::Instance(frame));
+        // MONKEY (flame flicker): a carried flame breathes like any other — the imp's hand fire, a
+        // held torch, a brazier GameObject. It is safe on THIS lane specifically because the
+        // modulation touches neither position nor reach: the settle/claim logic
+        // ([`CarriedLightMotion`], `carried_light_claims`) and the shadow slot's staleness test all
+        // key on where the light IS, and none of them can see a brightness change. The seed mixes
+        // the light's model-space offset with its PARENT, so two imps in one room never burn in
+        // step (position alone would give every copy of a model the same phase).
+        if let Some(kind) = benilla_world::lighting::flame_kind_for(
+            l.flame,
+            l.synthetic,
+            l.def.diffuse_color,
+            l.def.diffuse_intensity,
+        ) {
+            let seed = benilla_world::lighting::flicker_seed(wow_to_bevy(local))
+                ^ parent.to_bits().rotate_left(11) as u32;
+            glow.insert(benilla_world::lighting::FlameFlicker::new(kind, seed));
+        }
+        let glow = glow.id();
         commands.entity(parent).add_child(glow);
     }
 }
 
+/// MONKEY (spell light): spawn the ONE spell light a luminous effect model carries, as a child of
+/// that effect's root. `false` when the model carries none — which is the great majority of the
+/// corpus (frost, nature, arcane, shadow and everything unnamed synthesise nothing at all), and
+/// when the env kill switch `WOW_SPELL_LIGHT=0` is set.
+///
+/// `root` is the effect INSTANCE's root entity — the kit instance's attach node, the missile, the
+/// dest-anchored plant, the firework's GameObject frame. That parentage is the whole lifetime
+/// contract: every one of those lanes despawns its root when the effect ends (the reap, the
+/// arrival, the expiry), and a child light goes with it. There is no separate reaping path to get
+/// wrong, and no `on_owner_loss` case to answer — a light is not a particle pool and never drains.
+///
+/// The light hangs at the emitter's own model-space position, exactly as a synthesised fire light
+/// does, and does NOT ride a bone: a synthesised light stands for a whole flame VOLUME whose
+/// position was inferred, and riding an animating joint adds motion that the shadow/claim lanes
+/// read as an event (the same reasoning [`spawn_carried_lights`] gives for its `l.synthetic` arm).
+pub(super) fn spawn_spell_light(
+    commands: &mut Commands,
+    lights: &[benilla_assets::ModelLight],
+    root: Entity,
+    mode: SpellLightMode,
+) -> bool {
+    let Some((l, fx)) = lights.iter().find_map(|l| l.spell.map(|fx| (l, fx))) else {
+        return false;
+    };
+    spawn_spell_light_child(commands, root, l.def.position, l, fx, mode).is_some()
+}
+
+/// The shared body of the two spawn sites (the effect lanes' [`spawn_spell_light`] and the
+/// entity lane's firework branch): one `PointLight` child at `local` (WoW model space, relative to
+/// `parent`), carrying the tags every spell light must have.
+///
+/// The tag set is three separate promises, and each one is load-bearing:
+/// - [`SyntheticFireLight`] — this light was INVENTED, not authored, so the packer's synthetic gain
+///   owns it and the `WOW_POINTS_DUMP` census counts it as one.
+/// - [`SpellFxLight`] — MONKEY (spellLightGain): the world-side twin of [`SpellLight`], and the
+///   one thing benilla-world is told about a spell light. It OVERRIDES the tag above in the
+///   packer's gain fold: a spell row takes `spellLightGain`, never `fireLightGain` (they compose
+///   nowhere — see [`benilla_world::lighting::SpellFxLight`] for why the marker is world-side
+///   rather than `SpellLight` itself moving down).
+/// - [`HeldLight`] — **never** an exterior torch-shadow caster. A spell light moves (a missile), is
+///   born and dies inside a second, and would churn the cube-shadow cache at frame rate for a
+///   shadow nobody could resolve in the time it exists. The marker is that lane's refusal.
+/// - [`SpellLight`] — the envelope and the budget ([`advance_spell_lights`] /
+///   [`budget_spell_lights`]), the handle any future per-school gain targets, and (MONKEY (spell
+///   light lane)) what [`claim_carried_light_rooms`] reads to let this light claim rooms while it
+///   MOVES: a missile can never settle, and a light with no claims takes the exterior lane, which
+///   the room shaders never read.
+///
+/// No [`FlameFlicker`](benilla_world::lighting::FlameFlicker), deliberately: the flicker makes a
+/// fire breathe, and a spell light already has a shape of its own. The two together read as the
+/// effect stuttering rather than as fire.
+///
+/// `None` when the kill switch is off — so a caller can tell "disabled" from "this model has no
+/// light", though neither has any further consequence.
+fn spawn_spell_light_child(
+    commands: &mut Commands,
+    parent: Entity,
+    local: [f32; 3],
+    l: &benilla_assets::ModelLight,
+    fx: benilla_assets::SpellLightInfo,
+    mode: SpellLightMode,
+) -> Option<Entity> {
+    if !spell_lights_enabled() {
+        return None;
+    }
+    let lit = point_light(l.def.diffuse_color, l.def.diffuse_intensity);
+    // Born DARK and raised by the envelope: the onset is real time (a firework's fuse), and a
+    // light that showed its full strength on its first frame and only then ramped would flash
+    // once before every effect it belongs to.
+    let base = lit.intensity;
+    let glow = commands
+        .spawn((
+            WorldPointLight {
+                intensity: 0.0,
+                ..lit
+            },
+            Transform::from_translation(wow_to_bevy(local)),
+            Visibility::default(),
+            SyntheticFireLight,
+            SpellFxLight,
+            HeldLight,
+            SpellLight::new(base, fx.onset, mode),
+            // The same owner exclusion every carried light takes: the flame sits INSIDE the thing
+            // that burns it, so the effect's own meshes must not occlude their own light.
+            LightOwner::Instance(parent),
+        ))
+        .id();
+    commands.entity(parent).add_child(glow);
+    if benilla_assets::trace::enabled() {
+        benilla_assets::trace::line(
+            "fx",
+            &format!(
+                "spell light e={glow} school={} onset={:.2} base={base:.1}",
+                fx.kind.label(),
+                fx.onset
+            ),
+        );
+    }
+    Some(glow)
+}
+
+/// MONKEY (fire GO lights): how far up the hierarchy the room walk looks before giving up. A
+/// carried light's anchor is at most `light → joint → … → net entity`, and a rig's joint chain is
+/// the deep part; 64 clears every shipped skeleton with room to spare, and the cap is there so a
+/// malformed cycle can never hang the frame.
+const ANCHOR_WALK_DEPTH: usize = 64;
+
+/// MONKEY (carried light stability): the bearer crossfade weight at which a carried light COMMITS
+/// to its owner's room. [`InteriorAnchor::lane`] ramps at 2/s, so crossing this midpoint needs
+/// ~0.25 s of a HELD verdict; one frame of a wrong law moves the weight by `dt * 2` and can never
+/// cross it. That IS the hysteresis — no second timer, and because it is the very signal the
+/// bearer's own meshes crossfade their lighting on, the light changes lane with the body.
+const LANE_INTERIOR: f32 = 0.5;
+
+/// MONKEY (carried light stability): how far a carried light may drift and still count as standing
+/// still. Deliberately HALF `torch_shadow`'s 0.1 yd cache-staleness radius: the settle test has to
+/// be the stricter of the two, or a light could qualify as a shadow caster while already sitting
+/// far enough from its baked map to have that map withdrawn again on the next step.
+const STILL_DRIFT: f32 = 0.05;
+
+/// MONKEY (carried light stability): how long a carried light must hold still before it may cast.
+/// Long enough that a pet fidgeting between waypoints never qualifies, short enough that a placed
+/// brazier GameObject is eligible well inside the first second it exists.
+const STILL_HOLD: f32 = 0.75;
+
+/// MONKEY (carried light stability): how long a carried light has been standing still, so the
+/// torch-shadow lane can refuse a MOVING one.
+///
+/// The cube-shadow cache is built for fixtures that do not move: a slot keeps its baked depth only
+/// while its fixture stays within 0.1 yd of where the map was baked
+/// (`torch_shadow::map_publishable`), and a slot whose map is withdrawn has its cross-fade weight
+/// forced to 0 with no ramp (`static_gx::torch_depth`'s `TorchTable::pack`). A walking bearer
+/// crossed that threshold every frame, which is a full-strength shadow blinking at frame rate —
+/// and worse, it burned the lane's global two-rebuilds-a-frame budget re-baking a mesh that was
+/// stale again immediately, starving the STATIC candles around it so those flickered too. One
+/// pet's shadow is not worth that.
+///
+/// A carried light is not excluded outright, because the same `ChildOf` spawn path carries the
+/// stationary cases the shadow lane was written for: a GM-placed brazier GameObject in the Lion's
+/// Pride Inn, a campfire. Those settle within [`STILL_HOLD`] and cast normally; only things that
+/// actually move are refused. Refusal is a *candidacy* verdict, so an incumbent that starts
+/// walking is cross-faded out by the lane's own eviction path rather than cut.
+#[derive(Component)]
+pub(crate) struct CarriedLightMotion {
+    /// World position at the last frame the light was judged to have MOVED. Not re-anchored while
+    /// it is still, so a slow creep accumulates and eventually trips the test — which is right,
+    /// because the shadow cache's own staleness test is likewise absolute from the bake point.
+    last: Vec3,
+    /// Seconds held within [`STILL_DRIFT`] of `last`, capped at [`STILL_HOLD`]. The cap is what
+    /// keeps a settled light a pure READ: no field write, so no change tick, so nothing
+    /// downstream is woken by a light that is doing nothing.
+    still_for: f32,
+}
+
+impl CarriedLightMotion {
+    /// Has this light held still long enough to be trusted with a cached cube shadow?
+    pub(crate) fn settled(&self) -> bool {
+        self.still_for >= STILL_HOLD
+    }
+}
+
+/// MONKEY (carried light stability): maintain [`CarriedLightMotion`] for every carried light.
+///
+/// `PostUpdate`, **after transform propagation**, for the same reason the packer is there: a
+/// carried light is a child of a moving parent, so its `GlobalTransform` is only this frame's once
+/// `Propagate` has run. `update_torch_shadows` reads the verdict in `Last`, i.e. later in the same
+/// frame — never one stale.
+pub(crate) fn track_carried_light_motion(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut lights: Query<
+        (Entity, &GlobalTransform, Option<&mut CarriedLightMotion>),
+        (With<WorldPointLight>, With<ChildOf>, Without<ShadowProxyLight>),
+    >,
+) {
+    let dt = time.delta_secs();
+    for (light, gt, motion) in &mut lights {
+        let p = gt.translation();
+        match motion {
+            Some(mut m) => {
+                if p.distance_squared(m.last) > STILL_DRIFT * STILL_DRIFT {
+                    m.last = p;
+                    m.still_for = 0.0;
+                } else if m.still_for < STILL_HOLD {
+                    m.still_for += dt;
+                }
+            }
+            // Born moving: a light that spawns mid-stride must not be eligible on its first frame
+            // merely because it has no history yet.
+            None => {
+                commands.entity(light).try_insert(CarriedLightMotion {
+                    last: p,
+                    still_for: 0.0,
+                });
+            }
+        }
+    }
+}
+
+/// The bearer state a carried light's claim is derived from — the room its [`InteriorAnchor`]
+/// names and that anchor's crossfade WEIGHT — walked up the hierarchy from the light itself,
+/// because the light hangs off a BONE JOINT (or the model frame) and the anchor is the model's
+/// net-entity root several links above it (`interior::part_interior_lit`: "`anchor` is the model's
+/// NET ENTITY root for every caller").
+fn owner_lane(
+    light: Entity,
+    parents: &Query<&ChildOf>,
+    anchors: &Query<&InteriorAnchor>,
+) -> (Option<WmoRoom>, f32) {
+    let mut e = light;
+    for _ in 0..ANCHOR_WALK_DEPTH {
+        if let Ok(anchor) = anchors.get(e) {
+            return (anchor.room(), anchor.lane());
+        }
+        match parents.get(e) {
+            Ok(c) => e = c.parent(),
+            Err(_) => break,
+        }
+    }
+    // No anchor above us at all (a bearer with neither a lit part nor a lit emitter): exterior,
+    // and settled there — the same answer the old walk's `None` produced.
+    (None, 0.0)
+}
+
+/// The room a light's [`LightRooms`] claim currently stands for — our own record of it, because
+/// `LightRooms` wraps a `WmoGroupVis` whose fields are benilla-world-private and cannot be read
+/// back for a comparison. Absent = never claimed.
+#[derive(Component, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct ClaimedRoom {
+    /// What the light's `LightRooms` / `LightLane` currently stand for. `None` = exterior lane.
+    applied: Option<WmoRoom>,
+    /// MONKEY (carried light stability): the last room the bearer's anchor actually NAMED. Held
+    /// across the exterior ramp: the frame a bearer's law flips to `Exterior` its `room` goes
+    /// `None` at once, while the lane weight the claim is judged on takes ~0.25 s to fall past
+    /// [`LANE_INTERIOR`]. Without this there would be no room left to keep claiming during that
+    /// window, and the light would drop to the exterior lane on the raw flip — exactly the
+    /// one-frame verdict the weight exists to smooth.
+    seen: Option<WmoRoom>,
+    /// MONKEY (GO room claims): the [`LightLane`] currently on the light. The lane used to be a
+    /// pure function of `applied` (`is_some()`), so it needed no record; it is now also a function
+    /// of the CLAIM SET (a light standing in an exterior-class group that claims a real room moves
+    /// onto the interior lane — see [`CarriedClaims`]), and those two move independently. Recorded
+    /// so the `LightLane` insert stays change-gated: an insert is an archetype write, and the
+    /// render extraction behind it wakes on every one.
+    lane: bool,
+}
+
+/// MONKEY (GO room claims): how far a carried light may drift (yd) before its claim set is
+/// rebuilt. Ten times [`STILL_DRIFT`] on purpose — the settle test is about whether a CACHE of the
+/// light's surroundings is still valid frame to frame, this one is about whether a set of ROOMS is
+/// still the right set, and a room is yards across. Half a yard is well inside the smallest shipped
+/// doorway, so a light cannot cross a portal without tripping it.
+const CLAIM_DRIFT: f32 = 0.5;
+
+/// MONKEY (GO room claims): a carried light's [`LightLitRooms`] claim set, plus the three inputs
+/// the rebuild is gated on. Our own record, for the same reason [`ClaimedRoom`] is one:
+/// `LightLitRooms` wraps a crate-private `WmoGroupVis` and cannot be read back for a comparison.
+#[derive(Component)]
+pub(crate) struct CarriedClaims {
+    /// The set currently applied — `None` when the light carries no claims at all (outdoors, or
+    /// moving, or standing in no building's authored box).
+    set: Option<CarriedClaimSet>,
+    /// The world position the set was decided at. Absolute, not re-anchored: a light that creeps
+    /// out of the room it claimed must eventually rebuild, and the drift budget is the room's.
+    at: Vec3,
+    /// The [`WmoResidency`] generation it was decided under — a light that claimed nothing because
+    /// its building had not streamed in yet has to be re-asked once it has, and the reverse (the
+    /// placement entity a claim is keyed to is gone) is a stale instance id in the GPU claim head.
+    generation: u32,
+    /// The bearer room it was decided under: the light walked through a door, so the claim seed
+    /// (and the preferred placement) moved even if the light itself barely did.
+    room: Option<WmoRoom>,
+}
+
+impl CarriedClaims {
+    /// MONKEY (GO room claims): **the recompute gate.** `true` = the applied set still stands for
+    /// this position, this residency and this bearer room, so the whole claim walk is skipped.
+    ///
+    /// Split out as a pure function so it can be tested without a world: the walk it guards is the
+    /// expensive half of this system (an O(groups) box scan per resident placement), and a gate
+    /// that silently stopped firing would show up not as a wrong picture but as a stale one.
+    fn fresh(&self, at: Vec3, generation: u32, room: Option<WmoRoom>) -> bool {
+        self.generation == generation
+            && self.room == room
+            && self.at.distance_squared(at) <= CLAIM_DRIFT * CLAIM_DRIFT
+    }
+}
+
+/// MONKEY (GO room claims): does this claim set justify moving the light onto the INTERIOR lane?
+///
+/// Two conditions, and the second is the safety half.
+///
+/// 1. **It must name an interior-class group.** Claims are read by exactly one function,
+///    `static_gx.wgsl`'s `interior_room_light`, and that function skips every table entry whose
+///    colour-row `.w < 0.5` — i.e. every EXTERIOR-lane light. So on the exterior lane a claim set
+///    is inert: it is packed as the UNGATED head (`build_light_data` only calls `RoomClaim::build`
+///    on the interior arm) and no shader ever looks at it. A light that claims a real room and
+///    stays exterior has therefore gained nothing, which is the whole reason the lane moves.
+/// 2. **Every claim must be exterior-lane eligible** (no `LIT_ROOM_EXT_DENY` bit). Moving onto the
+///    interior lane is a TRADE: the light leaves `point_light_sum` (terrain, doodads, NPCs) and
+///    `wmo_exterior_point_sum` (a WMO's exterior-class walls and cobbles) and joins
+///    `interior_room_light`, which reaches an exterior-class surface only through the strict
+///    exterior-batch room term — and that term admits a claim only when it carries `CLAIM_EXT_OK`.
+///    A district-scale shell claim (Orgrimmar's whole valley, Stormwind's districts) carries the
+///    deny bit, so a light standing in one would be taken off the very cobbles it lights today and
+///    given nothing back that reached them. Those keep the exterior lane and behave exactly as
+///    before; a BUILDING-scale exterior group (the Goldshire inn's shell, the canyon nook a shop
+///    door opens onto) is eligible, so its floor keeps the light through the strict term while the
+///    interior rooms one portal hop away gain it.
+///
+/// The trade the rule still accepts, stated plainly: a brazier that moves onto the interior lane
+/// stops feeding the nearest-3 exterior term, so ADT TERRAIN under it and the NPCs standing beside
+/// it lose that light and gain the room lane instead. That is the correct side for a fixture
+/// genuinely inside a building's claimable volume — it is what a MOLT fixture in the same spot
+/// already does — and condition 2 is what keeps it from happening out on a district-scale street.
+fn lane_worthy(set: &CarriedClaimSet) -> bool {
+    set.any_interior && set.all_ext_ok()
+}
+
+/// MONKEY (GO room claims): the claim set of a light at `at`, from the first resident WMO placement
+/// whose authored MOGI boxes hold it.
+///
+/// `prefer` is tried in order before the scan — the bearer's own anchor placement and the one the
+/// light claimed last time. In the steady state one of those two always wins on the first probe,
+/// which is what keeps a residency-generation tick (a building streaming in three streets away
+/// re-gates every carried light in the world) from turning into a full scan per light. The scan is
+/// the cold path: a GameObject standing in an EXTERIOR-class group has no anchor room at all, so
+/// its very first claim has nowhere else to come from.
+fn claims_at(
+    wmos: &Assets<benilla_assets::WmoModel>,
+    placements: &Query<(Entity, &WmoPortalInstance)>,
+    prefer: [Option<Entity>; 2],
+    at: Vec3,
+    reach: f32,
+) -> Option<CarriedClaimSet> {
+    let one = |e: Entity| {
+        let (e, inst) = placements.get(e).ok()?;
+        carried_light_claims(wmos.get(&inst.handle)?, e, inst.world_from_local, at, reach)
+    };
+    for e in prefer.into_iter().flatten() {
+        if let Some(set) = one(e) {
+            return Some(set);
+        }
+    }
+    placements.iter().find_map(|(e, inst)| {
+        if prefer.contains(&Some(e)) {
+            return None; // already probed above
+        }
+        carried_light_claims(wmos.get(&inst.handle)?, e, inst.world_from_local, at, reach)
+    })
+}
+
+/// MONKEY (spell light lane): **may this light claim rooms this frame?**
+///
+/// The settle rule ([`CarriedLightMotion::settled`]) exists to keep an O(groups) box scan per
+/// resident placement off a WALKING bearer: a pet's torch would rebuild its set every frame for a
+/// set that is about to be wrong again, so an unsettled carried light simply carries no claims and
+/// falls back to the single-anchor-room behaviour it had before claims existed.
+///
+/// A SPELL light inverts every term of that trade, so it is exempt:
+///
+/// * **It never settles, by construction.** A missile flies from the caster's hand to the target
+///   and is despawned on arrival; it can never hold still for [`STILL_HOLD`], so under the settle
+///   rule it could never claim a room for a single frame of its life. The gap is not a tuning
+///   question — an indoor fireball lit *nothing* on the way down a corridor, and only the impact's
+///   own burst (which IS momentarily still, at a dest anchor) ever reached a wall.
+/// * **The fallback it would take is empty.** An unsettled carried light still has its bearer's
+///   anchor room to fall back on; a missile is a FREE world entity with no `InteriorAnchor`
+///   anywhere above it ([`owner_lane`] walks to the top and answers `(None, 0.0)`), so "no claims"
+///   means the EXTERIOR lane — and the exterior lane is the one `interior_room_light` never reads,
+///   which is why the bolt lit no walls at all.
+/// * **The cost it was protecting against is bounded.** Spell lights are capped at
+///   [`SPELL_LIGHTS_MAX`](super::spell_fx::SPELL_LIGHTS_MAX) = 24 across every lane, and each lives
+///   for about a second. The claim walk is still change-gated by [`CarriedClaims::fresh`] — a light
+///   that has not drifted past [`CLAIM_DRIFT`] since it was measured keeps its set — so the worst
+///   case is 24 lights × (resident placements) containment scans in a frame, each of which
+///   early-outs on an AABB test per group and does no portal work at all unless some box holds the
+///   light. That is the same walk ~150 of Orgrimmar's brazier GameObjects run on their first frame.
+///
+/// Settling is still what the SHADOW lane reads, and this function does not touch it: a spell light
+/// is [`HeldLight`] and unsettled, so it is refused a cube-shadow slot exactly as before.
+fn may_claim(spell: bool, motion: Option<&CarriedLightMotion>) -> bool {
+    spell || motion.is_some_and(CarriedLightMotion::settled)
+}
+
+/// MONKEY (fire GO lights): give a CARRIED light the room its owner was classified into.
+///
+/// A world-baked light gets its rooms at spawn from the building's own MODR/MOLR tables. An
+/// entity's light cannot: a GameObject walks (or is placed) into a building the tables know nothing
+/// about, and its room is only ever known from the interior classifier's down-ray. So this system
+/// copies that verdict onto the light, and two things follow from it:
+///
+/// - **The faithful gate.** A torch in a portal-culled room stops lighting the hillside outside it
+///   ([`LightRooms`], decision 0689) — until now a placed brazier GameObject lit through walls
+///   because it claimed no room at all and `room_admits` admits `None` unconditionally.
+/// - **Shadow eligibility.** `torch_shadow`'s caster query is `With<WorldPointLight>, With<LightRooms>`,
+///   so a roomless light can never be promoted to a cube-map caster however deep indoors it stands.
+///   A GM-placed brazier in the Lion's Pride Inn now throws real shadows like a MOLT fixture.
+///
+/// Applies to synthetic and authored carried lights alike — the room is a fact about the OWNER,
+/// not about where the light's colour came from.
+///
+/// MONKEY (carried light stability): the verdict is taken from the anchor's crossfade WEIGHT, not
+/// from its raw per-frame law. The law alternates: `WOW_INTERIOR_LOG` from the 2026-09-09 run has
+/// anchor `320v2` resolving `matte`↔`bake` on ten consecutive frames (t 73.75 … t 74.14), and
+/// the same threshold noise puts an `Exterior` between two interior verdicts at a doorway. A light
+/// that re-decided on that raw answer would hand itself back and forth between two DIFFERENT
+/// consumer families every frame — the exterior `point_light_sum` and the interior room lane —
+/// which is an on/off strobe of the pool, not a subtle difference. Reading `lane >= LANE_INTERIOR`
+/// costs nothing and cannot be crossed by a blip (see [`LANE_INTERIOR`]).
+///
+/// MONKEY (GO room claims): **and it now builds the light's [`LightLitRooms`] too** — the rooms it
+/// may LIGHT, as opposed to the one it must be VISIBLE from. The bearer's anchor answers "which
+/// group is this standing in", singular, and one group was the whole gate: a brazier inside the
+/// Lion's Pride Inn lit its own room and stopped dead at the doorway, and a brazier in one of
+/// Orgrimmar's 123 canyon placements named no group at all (`MOGP & 0x48` ⇒ the anchor is `None`)
+/// so it could never reach the shops the canyon opens onto. The fix is not a second classifier: it
+/// is the SAME claim rule the WMO's own MOLT fixtures and MODD props run
+/// (`benilla_world::terrain_stream::carried_light_claims` → `benilla_formats::room_claims`:
+/// containment tightest-first, then one portal hop within reach), asked at the light's world
+/// position. Reach is the M2 intensity bucket scaled by the DEFAULT `interiorAttenScale`, exactly
+/// as the prop lane sizes its own hop — the live cvar must not be able to open a doorway that was
+/// gated when the set was built, or every claim in the world would rebuild on a slider drag.
+///
+/// **Gated on four things**, because the walk is an O(groups) box scan per resident placement and
+/// Orgrimmar has ~150 of these lights: the light must be allowed to claim ([`may_claim`] — SETTLED
+/// for an ordinary carried light, so a walking pet's light re-claims no more often than the settle
+/// cadence and while it is unsettled and off its build point it carries NO claims, i.e. exactly the
+/// single-anchor-room behaviour it had before this change; a SPELL light is exempt and claims while
+/// it flies), and the set is rebuilt only when the light drifts past [`CLAIM_DRIFT`], when
+/// [`WmoResidency`] ticks, or when the bearer's room changes ([`CarriedClaims::fresh`]).
+///
+/// MONKEY (spell light lane): and the LANE half is what makes a moving claim worth anything. A
+/// missile has no [`InteriorAnchor`] above it at all, so `want` is `None` and the bearer half of
+/// the lane verdict can never fire; it reaches the interior lane purely through [`lane_worthy`]'s
+/// claim half, which is the path an anchorless GameObject in an exterior-class canyon group already
+/// took. Without it the bolt packs on the EXTERIOR lane, whose entries `interior_room_light` skips
+/// outright (`static_gx.wgsl` drops every row with colour-row `.w < 0.5`) — the room's walls never
+/// see it, and only the impact's own burst, which lands still at a dest anchor, ever lit anything.
+///
+/// Every component write below is change-gated on [`ClaimedRoom`]/[`CarriedClaims`]: a settled
+/// light is one hierarchy walk and three compares per frame, and nothing is written, so the light's
+/// archetype (and the render extraction behind it) stays quiet while an NPC stands still in a room.
+#[allow(clippy::type_complexity)]
+pub(crate) fn claim_carried_light_rooms(
+    mut commands: Commands,
+    // Carried lights only — `With<ChildOf>` IS the distinction: a world-baked doodad/MOLT light
+    // spawns as a free root with its rooms already correct, and re-deciding them from a hierarchy
+    // it isn't in would clear them.
+    mut lights: Query<
+        (
+            Entity,
+            // MONKEY (GO room claims): the light's own WORLD position (the claim rule's input) and
+            // its intensity (which sizes the portal hop). `Update` reads last frame's propagation,
+            // which is this frame's answer for anything settled.
+            // MONKEY (spell light lane): a MOVING spell light now claims too, so for that one case
+            // this position is one frame stale — at a missile's ~25 yd/s that is ~0.4 yd at 60 Hz.
+            // Accepted rather than re-scheduled: the answer it feeds is ROOM MEMBERSHIP, whose
+            // smallest feature is a doorway a yard wide, and the light's brightness at a wall
+            // changes by nothing measurable over that distance. The alternative — moving this
+            // system into `PostUpdate` between `Propagate` and the packer — would put a full
+            // O(placements) walk for every carried light in the world (Orgrimmar: ~150) into the
+            // frame's tightest stage to buy 0.4 yd on 24 of them.
+            &GlobalTransform,
+            &WorldPointLight,
+            Option<&CarriedLightMotion>,
+            Option<&mut ClaimedRoom>,
+            Option<&mut CarriedClaims>,
+            // MONKEY (spell light lane): is this a spell light? It is the one carried light that
+            // claims while MOVING — see [`may_claim`].
+            Has<SpellLight>,
+        ),
+        (With<ChildOf>, Without<ShadowProxyLight>),
+    >,
+    parents: Query<&ChildOf>,
+    anchors: Query<&InteriorAnchor>,
+    // MONKEY (GO room claims): the resident placements + their models — the claim rule's tables.
+    placements: Query<(Entity, &WmoPortalInstance)>,
+    wmos: Res<Assets<benilla_assets::WmoModel>>,
+    residency: Res<WmoResidency>,
+) {
+    let generation = residency.generation();
+    for (light, gt, pl, motion, mut claimed, mut claims, spell) in &mut lights {
+        let (room, lane) = owner_lane(light, &parents, &anchors);
+        // The room to claim IF we are on the interior lane: the one the anchor names this frame,
+        // else the last one it named (the ramp-down window described on `ClaimedRoom::seen`).
+        let seen = room.or_else(|| claimed.as_deref().and_then(|c| c.seen));
+        let want = seen.filter(|_| lane >= LANE_INTERIOR);
+
+        // MONKEY (GO room claims): the LIT-room claim set, rebuilt only on the gates above.
+        // `None` below means "keep what is already applied"; `Some(x)` means "apply x".
+        let at = gt.translation();
+        let fresh = claims
+            .as_deref()
+            .is_some_and(|c| c.fresh(at, generation, want));
+        let set = if fresh {
+            None
+        } else if may_claim(spell, motion) {
+            // The prop lane's own sizing: the intensity bucket (`PointLight` premultiplied 4π at
+            // spawn, so this inverts it exactly) through the DEFAULT atten scale.
+            let reach = benilla_formats::room_claim::claim_reach(
+                benilla_formats::room_claim::m2_light_reach(
+                    pl.intensity / (4.0 * std::f32::consts::PI),
+                ),
+            );
+            // MONKEY (spell light lane): for a spell light the FIRST entry is usually `None` —
+            // a missile has no bearer anchor to name a placement — so the steady-state probe is
+            // the SECOND: the building it claimed last frame. A bolt flying down a corridor stays
+            // in the building it was cast in, so that probe hits on every frame after the first
+            // and the full placement scan runs once per spell light, at birth.
+            let prefer = [
+                want.map(|r| r.instance),
+                claims
+                    .as_deref()
+                    .and_then(|c| c.set.as_ref())
+                    .map(|s| s.instance),
+            ];
+            Some(claims_at(&wmos, &placements, prefer, at, reach))
+        } else {
+            // Moved off its build point and not standing still: drop to the pre-claims behaviour
+            // rather than assert a set for a position it was not measured at. A SPELL light never
+            // reaches here ([`may_claim`]) — for it the "position it was measured at" is simply
+            // re-measured, one frame late (see the `GlobalTransform` note on the query).
+            Some(None)
+        };
+        // The set that stands THIS frame: the one just decided, else the one already applied. Read
+        // from the local rather than back off the component, because on a light's first frame the
+        // component is still a queued command and re-reading it would see `None` and remove the
+        // very `LightLitRooms` this pass is inserting.
+        let had = claims.as_deref().and_then(|c| c.set.as_ref());
+        let next_set: Option<&CarriedClaimSet> = match &set {
+            Some(next) => next.as_ref(),
+            None => had,
+        };
+        let set_changed = match (next_set, had) {
+            (None, None) => false,
+            // MONKEY (soft portal claims): the FADES are part of the set. A light that drifts
+            // across a room keeps claiming the same groups while the reach it has left past each
+            // doorway shrinks — comparing ids alone would leave it faded by the distances it had
+            // at its first build point, for as long as it never changed rooms.
+            (Some(next), Some(had)) => {
+                next.instance != had.instance
+                    || next.groups != had.groups
+                    || next.fades != had.fades
+            }
+            _ => true,
+        };
+        // MONKEY (GO room claims): the lane is the OR of the two halves — the bearer's own room,
+        // and (new) a claim set that earns the interior lane on its own (see [`lane_worthy`]).
+        let want_lane = want.is_some() || next_set.is_some_and(lane_worthy);
+
+        // What the light already carries, so each insert below is earned.
+        let (had_room, had_lane) = claimed
+            .as_deref()
+            .map_or((None, None), |c| (Some(c.applied), Some(c.lane)));
+
+        let mut e = commands.entity(light);
+        // MONKEY (light lane by position): the carried lane's own lane verdict. A bearer's room
+        // came from the interior classifier's ray at the bearer's own feet, so "my owner is in a
+        // room" IS "I am physically inside one" — no second ray, and the static classifier
+        // (`classify_light_lanes`) deliberately skips `With<ChildOf>` so the two never fight.
+        // MONKEY (GO room claims): plus the claim half — a light standing in an EXTERIOR-class
+        // group (so: no anchor room) that nonetheless claims a real interior room through a portal
+        // has to be on the interior lane for those claims to be read at all (see [`lane_worthy`]).
+        if had_lane != Some(want_lane) {
+            e.insert(LightLane::carried(want_lane));
+        }
+        if had_room != Some(want) {
+            match want {
+                Some(room) => {
+                    e.insert(LightRooms::new(WmoGroupVis::single(room.instance, room.group)));
+                }
+                // Back outdoors (or the anchor went away): drop the claim rather than leave a
+                // stale room, which would gate the light on a building it has walked out of.
+                None => {
+                    e.remove::<LightRooms>();
+                }
+            }
+        }
+        if set_changed {
+            match next_set {
+                Some(next) => {
+                    e.insert(next.component());
+                }
+                None => {
+                    e.remove::<LightLitRooms>();
+                }
+            }
+        }
+
+        // Bookkeeping LAST — every verdict above borrows it. `seen` is a record, not a component:
+        // updating it must not touch the light's COMPONENTS, or a bearer walking a corridor would
+        // churn the archetype for nothing.
+        match claimed.as_mut() {
+            Some(c) => {
+                let (applied, lane) = (c.applied, c.lane);
+                c.set_if_neq(ClaimedRoom { applied, seen, lane });
+                c.applied = want;
+                c.lane = want_lane;
+            }
+            None => {
+                e.try_insert(ClaimedRoom {
+                    applied: want,
+                    seen,
+                    lane: want_lane,
+                });
+            }
+        }
+        if let Some(next) = set {
+            let next = CarriedClaims {
+                set: next,
+                at,
+                generation,
+                room: want,
+            };
+            match claims.as_mut() {
+                Some(c) => **c = next,
+                None => {
+                    e.try_insert(next);
+                }
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
     use benilla_formats::M2Light;
+    use std::time::Duration;
 
     fn light(light_type: u16, bone: i16, position: [f32; 3], visibility_off: bool) -> ModelLight {
         ModelLight {
@@ -92,6 +833,9 @@ mod tests {
                 visibility_off,
             },
             bone_pivot: [1.0, 0.0, 0.5],
+            synthetic: false,
+            flame: false,
+            spell: None,
         }
     }
 
@@ -114,7 +858,7 @@ mod tests {
         ];
         app.world_mut().commands().queue(move |world: &mut World| {
             let mut q = world.commands();
-            spawn_carried_lights(&mut q, &lights, frame, move |bone| {
+            spawn_carried_lights(&mut q, &lights, frame, true, move |bone| {
                 (bone == 3).then_some(joint)
             });
         });
@@ -124,7 +868,7 @@ mod tests {
             .world_mut()
             .query::<(
                 Entity,
-                &benilla_world::lighting::WorldPointLight,
+                &WorldPointLight,
                 &Transform,
                 &ChildOf,
             )>()
@@ -150,7 +894,7 @@ mod tests {
         let pl = app
             .world()
             .entity(spawned[0].0)
-            .get::<benilla_world::lighting::WorldPointLight>()
+            .get::<WorldPointLight>()
             .unwrap();
         let recovered = pl.intensity / (4.0 * std::f32::consts::PI);
         assert!(
@@ -158,4 +902,255 @@ mod tests {
             "colour × intensity survives the packing"
         );
     }
+
+    /// MONKEY (outdoor torch shadows). The [`HeldLight`] marker is written at the SPAWN site and
+    /// nowhere else, because the spawn site is the only place that knows who owns the light: after
+    /// this, a guard's torch and a placed brazier are both just a `PointLight` under a `ChildOf`.
+    /// It is a pure ADDITION — the light's own components (colour, intensity, flicker, synthetic
+    /// tag) and its parenting are identical either way, so nothing about how it LIGHTS the world
+    /// moves; only the exterior shadow lane reads it.
+    #[test]
+    fn a_body_carried_light_is_marked_and_a_placed_one_is_not() {
+        for held in [true, false] {
+            let mut app = App::new();
+            let frame = app.world_mut().spawn(Transform::IDENTITY).id();
+            let lights = [light(1, -1, [0.0, 0.0, 4.0], false)];
+            app.world_mut().commands().queue(move |world: &mut World| {
+                let mut q = world.commands();
+                spawn_carried_lights(&mut q, &lights, frame, held, |_| None);
+            });
+            app.world_mut().flush();
+            let marked = app
+                .world_mut()
+                .query::<(&WorldPointLight, Has<HeldLight>)>()
+                .iter(app.world())
+                .map(|(_, h)| h)
+                .collect::<Vec<_>>();
+            assert_eq!(marked, vec![held], "held = {held}");
+        }
+    }
+
+    /// GOLDEN — MONKEY (carried light stability). A SYNTHESISED light does NOT ride its host
+    /// bone even when the instance carries that joint: it hangs off the model FRAME at the raw
+    /// model-space position, i.e. exactly where the bone ride would put it in the REST pose. The
+    /// frame is the model root, so the light still follows the unit with zero lag; what is dropped
+    /// is the per-frame animation swing that made the imp's green pool strobe (it re-ranked the
+    /// shaders' per-vertex nearest-3 and invalidated the cube-shadow cache every frame).
+    #[test]
+    fn a_synthetic_light_stays_on_the_rest_pose_pivot() {
+        let mut app = App::new();
+        let frame = app.world_mut().spawn(Transform::IDENTITY).id();
+        let joint = app.world_mut().spawn(Transform::IDENTITY).id();
+        let mut synth = light(1, 3, [2.0, 0.0, 1.5], false);
+        synth.synthetic = true;
+        synth.flame = true; // MONKEY (flame flicker): the flame route — the imp's hand fire
+        let lights = [synth];
+        app.world_mut().commands().queue(move |world: &mut World| {
+            let mut q = world.commands();
+            spawn_carried_lights(&mut q, &lights, frame, true, move |bone| {
+                (bone == 3).then_some(joint)
+            });
+        });
+        app.world_mut().flush();
+
+        let spawned: Vec<(Vec3, Entity)> = app
+            .world_mut()
+            .query::<(&WorldPointLight, &Transform, &ChildOf)>()
+            .iter(app.world())
+            .map(|(_, t, c)| (t.translation, c.parent()))
+            .collect();
+        assert_eq!(spawned.len(), 1);
+        assert_eq!(spawned[0].1, frame, "the frame, never the joint");
+        assert_eq!(
+            spawned[0].0,
+            wow_to_bevy([2.0, 0.0, 1.5]),
+            "raw model-space position, NOT rebased by the bone pivot"
+        );
+        // The tag still rides it: the packer must keep folding `fireLightGain` over this one.
+        assert!(app
+            .world_mut()
+            .query::<&SyntheticFireLight>()
+            .iter(app.world())
+            .next()
+            .is_some());
+    }
+
+    /// GOLDEN — MONKEY (carried light stability). A carried light earns its cube-shadow
+    /// eligibility by HOLDING STILL for [`STILL_HOLD`], and loses it the instant it moves further
+    /// than [`STILL_DRIFT`]. This is what keeps a walking bearer out of `torch_shadow`'s candidate
+    /// set: a moving fixture invalidates its cached depth map every frame, and a withdrawn map
+    /// zeroes that slot's cross-fade weight with no ramp — a shadow blinking at frame rate.
+    #[test]
+    fn a_carried_light_casts_only_after_it_holds_still() {
+        let mut app = App::new();
+        app.insert_resource(Time::<()>::default());
+        app.add_systems(Update, track_carried_light_motion);
+        let bearer = app.world_mut().spawn(Transform::IDENTITY).id();
+        let light = app
+            .world_mut()
+            .spawn((
+                WorldPointLight {
+                    color: [1.0, 1.0, 1.0],
+                    intensity: 0.0,
+                    range: 48.0,
+                },
+                Transform::IDENTITY,
+                GlobalTransform::IDENTITY,
+                ChildOf(bearer),
+            ))
+            .id();
+
+        // First sight of it: history exists, but nothing has been HELD yet.
+        app.update();
+        let settled = |app: &App, e: Entity| {
+            app.world()
+                .entity(e)
+                .get::<CarriedLightMotion>()
+                .is_some_and(CarriedLightMotion::settled)
+        };
+        assert!(!settled(&app, light), "born moving is not settled");
+
+        // A second of standing still clears the hold.
+        app.world_mut()
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_secs_f32(1.0));
+        app.update();
+        assert!(settled(&app, light), "held still past STILL_HOLD");
+
+        // One stride and it is disqualified again, with no credit for the second it banked.
+        *app.world_mut().entity_mut(light).get_mut::<GlobalTransform>().unwrap() =
+            GlobalTransform::from_translation(Vec3::new(1.0, 0.0, 0.0));
+        app.world_mut()
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_secs_f32(1.0 / 60.0));
+        app.update();
+        assert!(!settled(&app, light), "moved further than STILL_DRIFT");
+    }
+
+    /// GOLDEN — MONKEY (GO room claims). The claim-set RECOMPUTE GATE. Building a carried light's
+    /// lit-room set is an O(groups) authored-box scan per resident WMO placement, and Orgrimmar
+    /// alone places ~150 of these lights, so the walk must run on a change and never on a frame.
+    /// All three inputs invalidate, and none of them alone is enough to be left out:
+    /// residency (a building streamed in under a light that had claimed nothing), the bearer's room
+    /// (it walked through a door, so the claim seed moved even though the light barely did), and
+    /// drift past [`CLAIM_DRIFT`] (it is no longer where the set was measured).
+    #[test]
+    fn a_claim_set_is_rebuilt_only_on_residency_room_or_drift() {
+        let room = |group| {
+            Some(WmoRoom {
+                instance: Entity::PLACEHOLDER,
+                group,
+            })
+        };
+        let held = CarriedClaims {
+            set: None,
+            at: Vec3::new(10.0, 2.0, -4.0),
+            generation: 7,
+            room: room(3),
+        };
+        assert!(
+            held.fresh(held.at, 7, room(3)),
+            "nothing moved: no walk this frame"
+        );
+        assert!(
+            held.fresh(held.at + Vec3::X * (CLAIM_DRIFT * 0.9), 7, room(3)),
+            "a wobble inside the drift budget still stands"
+        );
+        assert!(
+            !held.fresh(held.at + Vec3::X * (CLAIM_DRIFT * 1.1), 7, room(3)),
+            "past CLAIM_DRIFT the set was measured somewhere else"
+        );
+        assert!(
+            !held.fresh(held.at, 8, room(3)),
+            "a placement streamed in or out: the claim's instance key may be stale"
+        );
+        assert!(
+            !held.fresh(held.at, 7, room(4)),
+            "the bearer changed room"
+        );
+        assert!(
+            !held.fresh(held.at, 7, None),
+            "the bearer left the building"
+        );
+    }
+
+    /// GOLDEN — MONKEY (spell light lane). A SPELL light claims rooms **while it is moving**; every
+    /// other carried light must hold still first.
+    ///
+    /// This is the whole of the missile fix in one predicate. A projectile is despawned on arrival
+    /// and can never satisfy [`STILL_HOLD`], so under the settle rule it claimed nothing for its
+    /// entire life — and with no [`InteriorAnchor`] above it either, "no claims" left it on the
+    /// EXTERIOR lane, which `interior_room_light` never reads. An indoor fireball therefore lit no
+    /// wall at any point of its flight; only its impact, which lands still, ever did.
+    ///
+    /// The exemption is deliberately NOT "everything unsettled claims": the settle rule still keeps
+    /// a walking pet's torch from rebuilding an O(groups) scan per resident placement every frame.
+    /// It is bought for the spell lane alone, where the population is capped
+    /// ([`super::spell_fx::SPELL_LIGHTS_MAX`]) and each light lives about a second.
+    #[test]
+    fn a_spell_light_claims_while_it_flies_and_a_torch_still_must_settle() {
+        let moving = CarriedLightMotion {
+            last: Vec3::ZERO,
+            still_for: 0.0,
+        };
+        let parked = CarriedLightMotion {
+            last: Vec3::ZERO,
+            still_for: STILL_HOLD,
+        };
+        assert!(
+            may_claim(true, Some(&moving)),
+            "a missile's light claims mid-flight — the whole point"
+        );
+        assert!(
+            may_claim(true, None),
+            "and on its very first frame, before the motion tracker has seen it at all"
+        );
+        assert!(
+            !may_claim(false, Some(&moving)),
+            "a walking bearer's torch still waits: the scan it would run is about to be stale"
+        );
+        assert!(
+            may_claim(false, Some(&parked)),
+            "a placed brazier settles and claims exactly as before"
+        );
+        assert!(
+            !may_claim(false, None),
+            "born moving is not a licence to claim"
+        );
+    }
+
+    /// GOLDEN — MONKEY (spell light lane). The LANE half: a claim set with no bearer room behind it
+    /// still earns the INTERIOR lane, which is the only lane whose entries the room shaders read.
+    ///
+    /// A missile is a free world entity — [`owner_lane`] finds no [`InteriorAnchor`] above its
+    /// light and answers `(None, 0.0)` — so `want` is `None` and the bearer half of the lane
+    /// verdict can never fire for it. Everything therefore rests on [`lane_worthy`], and on both of
+    /// its conditions holding their meaning: a real room moves the light onto the interior lane,
+    /// and a district-scale exterior shell (Stormwind's districts, Orgrimmar's valley) does NOT —
+    /// a bolt flying over open cobbles must keep lighting them through `point_light_sum` rather
+    /// than be handed to a lane that would not reach them.
+    #[test]
+    fn an_anchorless_spell_light_takes_the_interior_lane_from_its_claims_alone() {
+        let set = |groups: &[u16], any_interior| CarriedClaimSet {
+            instance: Entity::PLACEHOLDER,
+            groups: groups.to_vec().into(),
+            fades: Vec::new().into(),
+            any_interior,
+        };
+        assert!(
+            lane_worthy(&set(&[3, 4], true)),
+            "a corridor and the room past its doorway: the walls must see the bolt"
+        );
+        assert!(
+            !lane_worthy(&set(&[3, 4], false)),
+            "an all-exterior set reaches no room lane, so moving onto it would only lose the pool"
+        );
+        assert!(
+            !lane_worthy(&set(
+                &[3, 4 | benilla_world::lighting::LIT_ROOM_EXT_DENY],
+                true
+            )),
+            "one district-scale shell in the set and the light stays on the cobbles it lights"
+        );
+    }
 }
diff --git a/crates/benilla-app/src/entities/dest_fx.rs b/crates/benilla-app/src/entities/dest_fx.rs
index 21d4f03b..4051a0a2 100644
--- a/crates/benilla-app/src/entities/dest_fx.rs
+++ b/crates/benilla-app/src/entities/dest_fx.rs
@@ -313,6 +313,22 @@ pub(super) fn attach_ground_fx_models(
                 continue; // model still building — attach on a later pass
             }
             inst.spawned = true;
+            // MONKEY (spell light): the IMPACT flash. A dest-anchored effect is the one lane whose
+            // light must not hold — a Fire Nova lights the ground it lands on and is gone. The
+            // burst span is the model's own first-sequence duration where it authors one (so the
+            // light fades with the effect rather than on a guess), the shared default otherwise;
+            // a LOOPING plant (a persistent ground aura) takes the default too, because "as long
+            // as the aura lasts" is exactly what a burst must not be.
+            let span = dm
+                .first_seq_span
+                .filter(|_| !inst.looping)
+                .unwrap_or(super::spell_fx::SPELL_BURST_SPAN);
+            super::spawn_spell_light(
+                &mut commands,
+                &dm.lights,
+                entity,
+                super::spell_fx::SpellLightMode::Burst { span },
+            );
             if !inst.looping {
                 // One pass of the first sequence — the kit pipeline's completion-callback
                 // stand-in (`spell_fx`'s span clock, same law).
diff --git a/crates/benilla-app/src/entities/equipment/spawn.rs b/crates/benilla-app/src/entities/equipment/spawn.rs
index d69b8123..acf79447 100644
--- a/crates/benilla-app/src/entities/equipment/spawn.rs
+++ b/crates/benilla-app/src/entities/equipment/spawn.rs
@@ -848,7 +848,9 @@ fn spawn_slot(
     // the emitters and for the same reason (the item poses at rest, so its model space IS
     // the bone-local frame), which walks it through the hand's swing; the fence rails and
     // grass around the bearer then gather it like any other scene point light.
-    spawn_carried_lights(commands, &dm.lights, root, |_| None);
+    // MONKEY (outdoor torch shadows): `held = true` — this is THE held torch, the canonical
+    // body-carried light (see `carried_light::HeldLight`): it may not cast an outdoor shadow.
+    spawn_carried_lights(commands, &dm.lights, root, true, |_| None);
     // The item's ribbon trails (weapon enchant streaks): ride the item root — a held item
     // poses at rest, so the bone-local origin is model-space (no pivot rebase). A held item
     // rests in Stand (anim 0): a thrown weapon's trail is keyed dark there, so the flight
diff --git a/crates/benilla-app/src/entities/missile.rs b/crates/benilla-app/src/entities/missile.rs
index a152cda9..e8bc8851 100644
--- a/crates/benilla-app/src/entities/missile.rs
+++ b/crates/benilla-app/src/entities/missile.rs
@@ -783,6 +783,17 @@ pub(super) fn attach_missile_models(
         ) {
             continue;
         }
+        // MONKEY (spell light): a luminous projectile carries its light with it — the Fireball's
+        // core lights the road it flies over, and the flash at the end is the impact effect's own
+        // (`dest_fx` / the kit on the target), not this one's. `Missile` = constant: a projectile
+        // has no lifecycle to follow and no fade to run, because its ending is the arrival despawn
+        // that takes the light with it.
+        super::spawn_spell_light(
+            &mut commands,
+            &dm.lights,
+            entity,
+            super::spell_fx::SpellLightMode::Missile,
+        );
         missile.parts_spawned = true;
     }
 }
diff --git a/crates/benilla-app/src/entities/spell_fx/lifecycle.rs b/crates/benilla-app/src/entities/spell_fx/lifecycle.rs
index 883c1415..ef9866ba 100644
--- a/crates/benilla-app/src/entities/spell_fx/lifecycle.rs
+++ b/crates/benilla-app/src/entities/spell_fx/lifecycle.rs
@@ -59,6 +59,8 @@ use benilla_assets::ModelAnimations;
 use bevy::animation::{graph::AnimationNodeIndex, RepeatAnimation};
 use bevy::prelude::*;
 
+use benilla_world::lighting::WorldPointLight;
+
 use crate::creature_anim::FxStage;
 
 /// `AnimationData.dbc` **158 `Hold`** — the sustained pulse leg (`0x9e` at `0x5ff188`/`0x5ff1bb`).
@@ -217,6 +219,188 @@ pub(crate) fn decay_span(anims: Option<&ModelAnimations>) -> Option<f32> {
     anims?.find(ANIM_DECAY).map(|c| c.duration)
 }
 
+// -------------------------------------------------------------------------------------------
+// MONKEY (spell light): the LIGHT a luminous effect throws, and the envelope it throws it on.
+// -------------------------------------------------------------------------------------------
+//
+// The synthesis — which effects are luminous at all (fire / holy / fel, never frost, nature,
+// arcane or shadow), what colour they burn and how far they reach — is
+// [`benilla_formats::fire_light`]'s spell route, decided once per MODEL at asset load. What lives
+// here is everything that is per-INSTANCE: when the light comes up, how it goes out, and how many
+// of them may exist at once.
+//
+// It sits in this file rather than beside the other carried lights because it is a LIFECYCLE, and
+// this file is where an effect instance's lifecycle lives (`Stand` → `Hold` → `Decay`). The light
+// is a child of the effect's own root, so the reap that despawns the root takes the light with it
+// and there is no orphaning path to get wrong; the envelope below only shapes the brightness
+// inside that life.
+
+/// Seconds a spell light takes to come up. Short enough to read as a flash rather than a fade-in —
+/// the point is only that a light never appears at full strength on a single frame, which reads as
+/// a rendering fault rather than as a spell.
+pub(crate) const SPELL_LIGHT_RAMP: f32 = 0.1;
+
+/// The default burst fade ([`SpellLightMode::Burst`]) when the caller knows no better span: an
+/// impact's flash. Long enough to see, short enough that a volley of them never overlaps into a
+/// standing glow.
+pub(crate) const SPELL_BURST_SPAN: f32 = 0.6;
+
+/// How fast a KIT light goes dark once its instance is reaped ([`FxDecay`]). Deliberately quicker
+/// than the model's own `Decay` sequence: the aura is over the moment the server said so, and a
+/// light that outlived the visual by a second would read as a stuck effect.
+pub(crate) const SPELL_REAP_FADE: f32 = 0.25;
+
+/// How many spell lights may be alive at once, across every lane. The shared point-light table is
+/// 512 rows packed from the 256 nearest sources every frame, and the whole feature is worth
+/// nothing if a raid's worth of casts can evict a city's torches: 24 is a generous ceiling for
+/// what one camera can see cast at once and still a small fraction of the pack.
+pub(crate) const SPELL_LIGHTS_MAX: usize = 24;
+
+/// MONKEY (spell light): the env kill switch, `WOW_SPELL_LIGHT=0`. Read ONCE — the value is
+/// latched on first call, so it cannot change under a running frame and costs one atomic load at
+/// each spawn site thereafter.
+///
+/// An env var and STILL not a cvar, now that `spellLightGain` exists beside `fireLightGain`
+/// (MONKEY (spellLightGain) — `cvars.rs`, folded at pack time in
+/// `benilla_world::lighting::global_light::build_light_data`). The two are different tools and both
+/// are wanted: the cvar is the live BRIGHTNESS dial, and its `0` darkens a spell light that is
+/// still spawned, still parented, still aged and still counted against
+/// [`SPELL_LIGHTS_MAX`]; this switch stops the lights being CREATED at all, which is what an A/B
+/// against the pre-feature build needs (`WOW_SPELL_LIGHT=0` costs the frame nothing, and takes the
+/// claim walk in `carried_light::claim_carried_light_rooms` with it).
+pub(crate) fn spell_lights_enabled() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| !matches!(std::env::var("WOW_SPELL_LIGHT").as_deref(), Ok("0")))
+}
+
+/// Which lifecycle a spell light follows — the one thing its spawn site knows that the model
+/// cannot.
+#[derive(Clone, Copy, PartialEq, Debug)]
+pub(crate) enum SpellLightMode {
+    /// A kit/aura effect attached to a unit: up on the ramp, HELD for as long as the instance
+    /// stands, out on the reap ([`FxDecay`] → [`SPELL_REAP_FADE`]). Ice Barrier's shield holds,
+    /// Immolate burns for its duration, a precast glows while it is cast.
+    Kit,
+    /// A missile: constant while it flies. The light rides the projectile root, so it sweeps the
+    /// ground and the walls on the way — and the missile's own arrival despawn ends it, which is
+    /// the only ending a projectile has.
+    Missile,
+    /// An impact / destination effect / firework shell: full at onset, gone `span` seconds later.
+    /// The one shape whose *whole point* is that it does not persist.
+    Burst { span: f32 },
+}
+
+/// MONKEY (spell light): one live spell light. A child of the effect root it belongs to, so the
+/// effect's own despawn reaps it; this component only shapes its brightness while it lives.
+#[derive(Component)]
+pub(crate) struct SpellLight {
+    /// The `PointLight::intensity` this light sits at when the envelope is at full — captured at
+    /// spawn from the synthesised colour/intensity, never recomputed. The envelope only ever
+    /// SCALES this, so nothing downstream can drift the calibration.
+    base: f32,
+    /// Seconds from spawn before the light comes up — the emitter's own rate-track onset
+    /// (`benilla_formats::fire_light::emit_onset`). A firework shell detonates half a second into
+    /// its model's clip and a rocket that lit the sky on the way UP would be exactly backwards.
+    onset: f32,
+    /// The lifecycle ([`SpellLightMode`]).
+    mode: SpellLightMode,
+    /// Seconds alive. Also the budget's age ordering — the OLDEST spell light is the one dropped
+    /// when the ceiling is hit, because it is the one whose moment has most passed.
+    age: f32,
+    /// Seconds this light's HOST instance has been reaped ([`FxDecay`]), i.e. how far into
+    /// [`SPELL_REAP_FADE`] it is. Only ticks in [`SpellLightMode::Kit`].
+    reaped: f32,
+}
+
+impl SpellLight {
+    /// A fresh light at `base` intensity, coming up `onset` seconds from now.
+    pub(crate) fn new(base: f32, onset: f32, mode: SpellLightMode) -> Self {
+        Self {
+            base,
+            onset,
+            mode,
+            age: 0.0,
+            reaped: 0.0,
+        }
+    }
+
+    /// The envelope's current multiplier, `0..=1` — pure, so the shape is testable without a
+    /// world. Ramp in, then the mode's own decay, then the reap fade, multiplied.
+    fn envelope(&self) -> f32 {
+        let t = self.age - self.onset;
+        if t <= 0.0 {
+            return 0.0; // the flame this light stands for does not exist yet
+        }
+        let up = (t / SPELL_LIGHT_RAMP).min(1.0);
+        let down = match self.mode {
+            // The fade starts where the ramp ended, so a burst's peak is a real (if brief) plateau
+            // rather than a single-frame spike that a low frame rate could skip entirely.
+            SpellLightMode::Burst { span } => {
+                (1.0 - (t - SPELL_LIGHT_RAMP).max(0.0) / span.max(1e-3)).clamp(0.0, 1.0)
+            }
+            SpellLightMode::Kit | SpellLightMode::Missile => 1.0,
+        };
+        let reap = (1.0 - self.reaped / SPELL_REAP_FADE).clamp(0.0, 1.0);
+        up * down * reap
+    }
+}
+
+/// MONKEY (spell light): run every live spell light's envelope.
+///
+/// `Update`, beside the rest of the effect lane, and it writes `PointLight::intensity` ONLY — the
+/// packer reads that in `PostUpdate` (`lighting::build_light_data`), so a light's brightness is
+/// always this frame's. Deliberately NOT a `FlameFlicker`: that modulation exists to make a fire
+/// breathe, and a spell light already has a shape of its own; the two together read as the effect
+/// stuttering.
+///
+/// The KIT arm is the only one that has to look outside itself: a reaped instance
+/// ([`FxDecay`] on the effect root, written by the reap) must take its light down with it, and the
+/// light's parent IS that root.
+pub(crate) fn advance_spell_lights(
+    time: Res<Time>,
+    mut lights: Query<(&mut SpellLight, &mut WorldPointLight, Option<&ChildOf>)>,
+    reaped: Query<Has<FxDecay>>,
+) {
+    let dt = time.delta_secs();
+    for (mut light, mut point, parent) in &mut lights {
+        light.age += dt;
+        if light.mode == SpellLightMode::Kit
+            && parent.is_some_and(|c| reaped.get(c.parent()).unwrap_or(false))
+        {
+            light.reaped += dt;
+        }
+        let want = light.base * light.envelope();
+        // Write only on a real change: a held kit light sits at its plateau for the whole aura,
+        // and a per-frame write there would wake every change-detection consumer of `PointLight`
+        // for nothing.
+        if (point.intensity - want).abs() > 1e-3 {
+            point.intensity = want;
+        }
+    }
+}
+
+/// MONKEY (spell light): the ceiling ([`SPELL_LIGHTS_MAX`]) — drop the OLDEST beyond it.
+///
+/// Oldest rather than dimmest or furthest, for one reason: the lane exists to light what is
+/// HAPPENING, and the newest cast is the one the player is looking at. A dimness rule would evict
+/// the burst that is mid-fade (i.e. exactly the flash being watched) and a distance rule would
+/// fight the packer, which already sorts by distance and would then be given a hole it had no say
+/// in. Age is also the only ordering that is stable frame to frame, so the set does not churn.
+///
+/// Despawning the light alone never disturbs its effect: the light is a leaf child of the effect
+/// root and nothing reads back from it.
+pub(crate) fn budget_spell_lights(mut commands: Commands, lights: Query<(Entity, &SpellLight)>) {
+    let live = lights.iter().count();
+    if live <= SPELL_LIGHTS_MAX {
+        return;
+    }
+    let mut by_age: Vec<(Entity, f32)> = lights.iter().map(|(e, s)| (e, s.age)).collect();
+    by_age.sort_by(|a, b| b.1.total_cmp(&a.1)); // oldest first
+    for (light, _) in by_age.into_iter().take(live - SPELL_LIGHTS_MAX) {
+        commands.entity(light).try_despawn();
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -306,6 +490,50 @@ mod tests {
         assert_eq!(decay_span(None), None);
     }
 
+    /// MONKEY (spell light) — GOLDEN: the envelope's four legs, on the pure function so the shape
+    /// is pinned without a world. The ONSET leg is the one with a real bug behind it: a firework
+    /// shell detonates half a second into its clip, and a light lit at spawn flashes the rocket's
+    /// flight instead of its burst.
+    #[test]
+    fn the_spell_envelope_ramps_holds_and_bursts() {
+        let at = |mut l: SpellLight, age: f32| {
+            l.age = age;
+            l.envelope()
+        };
+
+        // A kit light: dark before its onset, ramped over SPELL_LIGHT_RAMP, then HELD.
+        let kit = || SpellLight::new(100.0, 0.0, SpellLightMode::Kit);
+        assert_eq!(at(kit(), 0.0), 0.0, "nothing on the spawn frame");
+        assert!((at(kit(), SPELL_LIGHT_RAMP * 0.5) - 0.5).abs() < 1e-3);
+        assert_eq!(at(kit(), SPELL_LIGHT_RAMP), 1.0);
+        assert_eq!(at(kit(), 30.0), 1.0, "an aura holds for as long as it stands");
+
+        // A missile is the same minus any ending of its own — the arrival despawn is the ending.
+        assert_eq!(at(SpellLight::new(1.0, 0.0, SpellLightMode::Missile), 5.0), 1.0);
+
+        // A burst peaks at the ramp's end and is gone `span` later; the plateau is real, not a
+        // one-frame spike a low frame rate could step over.
+        let burst = || SpellLight::new(1.0, 0.0, SpellLightMode::Burst { span: 0.6 });
+        assert_eq!(at(burst(), SPELL_LIGHT_RAMP), 1.0);
+        assert!((at(burst(), SPELL_LIGHT_RAMP + 0.3) - 0.5).abs() < 1e-3);
+        assert_eq!(at(burst(), SPELL_LIGHT_RAMP + 0.6), 0.0);
+        assert_eq!(at(burst(), 10.0), 0.0, "and stays gone");
+
+        // The ONSET: a firework's fuse. Dark for the whole flight, up at the detonation.
+        let fuse = || SpellLight::new(1.0, 1.5, SpellLightMode::Burst { span: 0.6 });
+        assert_eq!(at(fuse(), 1.4), 0.0);
+        assert_eq!(at(fuse(), 1.5 + SPELL_LIGHT_RAMP), 1.0);
+
+        // The reap fade: a kit light goes dark on its instance's `FxDecay`, quicker than the
+        // model's own Decay sequence — the aura is over the moment the server said so.
+        let mut reaped = kit();
+        reaped.age = 5.0;
+        reaped.reaped = SPELL_REAP_FADE * 0.5;
+        assert!((reaped.envelope() - 0.5).abs() < 1e-3);
+        reaped.reaped = SPELL_REAP_FADE;
+        assert_eq!(reaped.envelope(), 0.0);
+    }
+
     fn test_anims(clips: &[AnimClip]) -> ModelAnimations {
         ModelAnimations {
             graph: Handle::default(),
diff --git a/crates/benilla-app/src/entities/spell_fx/mod.rs b/crates/benilla-app/src/entities/spell_fx/mod.rs
index bb3ecceb..8a082bec 100644
--- a/crates/benilla-app/src/entities/spell_fx/mod.rs
+++ b/crates/benilla-app/src/entities/spell_fx/mod.rs
@@ -79,6 +79,14 @@ use benilla_world::vis_chain::VisChainOnly;
 
 use super::{BoneAttach, DisplayModel, EntityPart, ModelHandle};
 pub(super) use lifecycle::advance_fx_anim;
+// MONKEY (spell light): the luminous-effect light's lifecycle — its envelope, its budget, its kill
+// switch and the mode each lane spawns it in. Exported at `pub(crate)` because the spawners live
+// outside this module: `entities::carried_light` holds the one spawn helper (and the firework
+// GameObject's own branch), and `entities.rs` registers the two systems.
+pub(crate) use lifecycle::{
+    advance_spell_lights, budget_spell_lights, spell_lights_enabled, SpellLight, SpellLightMode,
+    SPELL_BURST_SPAN,
+};
 use lifecycle::{decay_span, FxAnimLife, FxDecay};
 
 /// The client's attach fallback cascade when a model lacks the requested point (wow-re
@@ -1140,6 +1148,12 @@ pub(super) fn attach_spell_fx(
                 &mut palettes,
                 None, // an attach-point kit effect opens on its model's own `Stand`
             );
+            // MONKEY (spell light): and the light the effect throws, if its school is a luminous
+            // one (fire / holy / fel — never frost, nature, arcane or shadow). A child of the
+            // instance root, so the reap that despawns the root takes it. `Kit` because that is
+            // this lane's lifecycle exactly: up on the ramp, held for the aura's life, out when
+            // `FxDecay` lands.
+            super::spawn_spell_light(&mut commands, &dm.lights, root, SpellLightMode::Kit);
             inst.root = Some(root);
             if !inst.persistent {
                 // The client's completion-callback moment: one full pass of the sequence the
diff --git a/crates/benilla-app/src/entities/wmo_props.rs b/crates/benilla-app/src/entities/wmo_props.rs
index 11a7ab34..59cc2261 100644
--- a/crates/benilla-app/src/entities/wmo_props.rs
+++ b/crates/benilla-app/src/entities/wmo_props.rs
@@ -202,10 +202,11 @@ pub(super) fn spawn_wmo_gameobject_props(
     time: Res<Time>,
     mut hosts: Query<(Entity, &GlobalTransform, &mut WmoProps)>,
 ) {
-    let Some((mat_cache, materials, light)) = mats.pieces() else {
-        return; // no shared light buffer yet
+    let Some((mat_cache, materials, light, torch)) = mats.pieces() else {
+        return; // no shared light buffer / torch bindings yet
     };
     let light = &light;
+    let torch = &torch;
     // The animated-prop clock origin (decision 0130) — per-instance phase = spawn time.
     let now = time.elapsed_secs();
     for (entity, host_gt, mut props) in &mut hosts {
@@ -329,6 +330,7 @@ pub(super) fn spawn_wmo_gameobject_props(
                 mat_cache,
                 materials,
                 light,
+                torch,
                 &m.submeshes,
                 forms.slices(&prop.handle),
                 prop.local, // doodad-LOCAL — the parent composes the world pose
@@ -468,19 +470,36 @@ pub(super) fn spawn_wmo_gameobject_props(
                 }
                 // M2 point lights (the lantern's glow source): a CHILD at the prop-local
                 // position — propagation carries the source with the hull.
-                for l in m.lights.iter().map(|l| &l.def) {
-                    if !l.casts() {
+                for l in m.lights.iter() {
+                    if !l.def.casts() {
                         continue; // directional lights feed an ambient term; a static `0` visibility key is dark
                     }
-                    let glow = commands
-                        .spawn((
-                            point_light(l.diffuse_color, l.diffuse_intensity),
-                            Transform::from_translation(
-                                prop.local.transform_point(wow_to_bevy(l.position)),
-                            ),
-                            Visibility::default(),
-                        ))
-                        .id();
+                    let local = prop.local.transform_point(wow_to_bevy(l.def.position));
+                    let mut glow = commands.spawn((
+                        point_light(l.def.diffuse_color, l.def.diffuse_intensity),
+                        Transform::from_translation(local),
+                        Visibility::default(),
+                    ));
+                    // MONKEY (fire GO lights): a transport prop takes SYNTHESISED lights like the
+                    // other entity lanes (the deck braziers on a zeppelin/boat author none), tagged
+                    // so the live `fireLightGain` reaches them.
+                    if l.synthetic {
+                        glow.insert(benilla_world::lighting::SyntheticFireLight);
+                    }
+                    // MONKEY (flame flicker): a deck brazier on a moving zeppelin burns too. The
+                    // seed is the prop-LOCAL position (the hull moves; the phase must not) mixed
+                    // with the host, so two identical decks don't beat together.
+                    if let Some(kind) = benilla_world::lighting::flame_kind_for(
+                        l.flame,
+                        l.synthetic,
+                        l.def.diffuse_color,
+                        l.def.diffuse_intensity,
+                    ) {
+                        let seed = benilla_world::lighting::flicker_seed(local)
+                            ^ entity.to_bits().rotate_left(11) as u32;
+                        glow.insert(benilla_world::lighting::FlameFlicker::new(kind, seed));
+                    }
+                    let glow = glow.id();
                     commands.entity(entity).add_child(glow);
                     lights += 1;
                 }
diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs
index 6ad9e665..623a2a0c 100644
--- a/crates/benilla-app/src/game_plugins.rs
+++ b/crates/benilla-app/src/game_plugins.rs
@@ -133,7 +133,10 @@ impl PluginGroup for GamePlugins {
             .add(CreatureAnimPlugin)
             // The unit blob shadow: the dark ground oval under every unit, sized from the playing
             // animation's box (the byte-verified law — wow-re unit-blob-shadow RE), on the same
-            // surface-decal projector as the selection ring.
+            // surface-decal projector as the selection ring. `worldShadows 0` — the shipped default,
+            // the faithful 1.12 frame — draws it exactly as the reference does; while `worldShadows 1`
+            // the realtime shadow-map path owns unit shadows and this lane hides (the gate inside
+            // `update_shadows`), so a unit never wears the oval underneath its cast shadow.
             .add(BlobShadowPlugin)
             // Footprint decals (B212, decision 1006): the prints a walking unit leaves on snow/sand,
             // spawn-once projections on the same decal projector, fading off the effect stream.
@@ -225,6 +228,17 @@ impl PluginGroup for GamePlugins {
             // The video knobs the CVar host writes into (today: `gxVSync`). Before CvarPlugin so the
             // resource exists when `load_config` applies the saved value at Startup.
             .add(crate::video::VideoPlugin)
+            // MONKEY (shadows): the shared rig (loads first) + the independent lane plugins. Here,
+            // between `VideoPlugin` and `RealmlistPlugin`, because every one of them registers cvars
+            // that `CvarPlugin` (two lines down) must already see when `load_config` applies the
+            // saved values at Startup — the same edge that pins the two knob plugins around them.
+            .add(crate::shadow_core::ShadowCorePlugin)
+            .add(crate::character_shadow::CharacterShadowPlugin)
+            .add(crate::world_shadow::WorldShadowPlugin)
+            .add(crate::torch_shadow::TorchShadowPlugin)
+            // MONKEY (dynamic interiors): the fixture-lit interior lane's cvar bridge — independent
+            // of the shadow lanes, a plain drop-in.
+            .add(crate::dynamic_interior::DynamicInteriorPlugin)
             // The realmlist (decision 1667) — the logon address the login screen edits. Same reason as
             // VideoPlugin above: it is a CVar knob, so its resource has to exist before `load_config`.
             .add(crate::realmlist::RealmlistPlugin)
@@ -866,7 +880,38 @@ pub(crate) mod schedule_tests {
     }
 
     /// `PostUpdate`, 181 systems: `GlobalTransform` and the particle `EffectQuads` are most of it.
-    const POST_UPDATE_CEILING: usize = 351;
+    ///
+    /// **375 (MONKEY, the dynamic light and shadow system)** — upstream's own number is 351; this
+    /// branch adds **+24**, and the pairs were READ off the dump rather than reasoned about (the
+    /// lesson the `UPDATE_ACTIONABLE_CEILING` paragraphs paid for). `WOW_AMBIGUITY_DUMP_POST=1`
+    /// on this test prints them; three systems carry every one:
+    ///
+    /// - `entities::carried_light::track_carried_light_motion` (12 pairs) — the system that walks
+    ///   a torch's light to its carrier's hand. It meets `billboard::face_billboards`,
+    ///   `billboard_joint_palette`, `particles::{sim, model}`, `ribbons::simulate_ribbons`,
+    ///   `rig_anim::compose::finalize_rig_worlds`, the four sky/sun/moon/star followers,
+    ///   `nameplates::place_nameplates` and `raid_marks::place_raid_marks`.
+    /// - `lighting::global_light::classify_light_lanes` (12 pairs) — the interior/exterior lane
+    ///   classifier, against the same family for the same reason.
+    /// - `bevy_pbr::material::check_entities_needing_specialization` for the two shadow-proxy
+    ///   materials (`shadow_core::ShadowCasterMaterial`, `world_shadow::CutoutShadowCasterMaterial`)
+    ///   against `straddle::sync_straddle_twins` (2 pairs).
+    ///
+    /// **Every one of the 24 is over `GlobalTransform` (22) or `Mesh3d` (2), and both of ours are
+    /// READS.** Neither lighting system writes a transform: they ask where a light already is and
+    /// then write their own state (a `WorldPointLight`'s position, a `LightLane`). So the
+    /// undeclared order decides only whether a light is placed from this frame's pose or the last
+    /// one — the `AreaSpiritHealer` poll's class exactly (the 3,288 paragraph): both are
+    /// **level**-triggered, re-deriving from scratch every frame, so a frame-late read is a light
+    /// trailing a walking carrier by one stride, re-corrected on the next frame and invisible at
+    /// any frame rate the client runs at. The `Mesh3d` pair is Bevy's own specialization check
+    /// against a straddle twin, which is a read of the mesh handle on both sides.
+    ///
+    /// Declaring the orders instead would mean pinning two lighting systems after eleven unrelated
+    /// animation, particle and celestial-follow systems to buy a one-frame-fresher transform that
+    /// nothing can see — a real serialisation cost for no observable difference. Raised, with the
+    /// reason, as the failure message offers.
+    const POST_UPDATE_CEILING: usize = 375;
     const POST_UPDATE_SLACK: usize = 20;
     /// The **actionable** pairs in `Update` — two systems with conflicting access and no
     /// declared order, where [`Classes`] explains none of what they share, so the executor
@@ -1024,6 +1069,33 @@ pub(crate) mod schedule_tests {
                 eprintln!("{r}");
             }
         }
+        // MONKEY (lighting): the `PostUpdate` half of the dump, which upstream's `Update`-only
+        // lever had no equivalent of — and without which `POST_UPDATE_CEILING` could only ever be
+        // raised by reasoning about what the new pairs must be, the exact mistake the ceiling's
+        // own comments record. Its own env var, not `WOW_AMBIGUITY_DUMP`, because `PostUpdate`
+        // prints every pair (there is no `Classes` pass over it) and 375 rows would bury the
+        // actionable `Update` list this test is usually run for.
+        if std::env::var_os("WOW_AMBIGUITY_DUMP_POST").is_some() {
+            let mut rows: Vec<String> = post
+                .conflicts
+                .iter()
+                .map(|(a, b, what)| {
+                    format!(
+                        "POST  {}  <->  {}\n      on {}",
+                        post.name(*a),
+                        post.name(*b),
+                        what.iter()
+                            .map(|id| post.component(*id))
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    )
+                })
+                .collect();
+            rows.sort();
+            for r in rows {
+                eprintln!("{r}");
+            }
+        }
         ratchet(
             "Update (actionable)",
             actionable.len(),
diff --git a/crates/benilla-app/src/lib.rs b/crates/benilla-app/src/lib.rs
index 67a5107c..093dd2ce 100644
--- a/crates/benilla-app/src/lib.rs
+++ b/crates/benilla-app/src/lib.rs
@@ -71,6 +71,8 @@ mod debug_panel;
 /// rule, in one file. Always compiled; what it *holds* is not.
 mod dev;
 mod doodad_events;
+/// MONKEY (dynamic interiors): the cvar → benilla-world bridge for the fixture-lit interior lane.
+mod dynamic_interior;
 mod entities;
 mod fishing_line;
 mod footprints;
@@ -93,6 +95,7 @@ mod npc_text;
 mod pending_item_ops;
 /// Ships in part: the FPS journal and the clocks it reads (2008); the rest is `dev` (1173).
 mod perf;
+mod character_shadow;
 mod pipe_warm;
 mod player;
 mod poi_marker;
@@ -111,6 +114,7 @@ mod run_mode;
 mod screen_fade;
 mod screenshot;
 mod shaders;
+mod shadow_core;
 
 mod game_tip;
 mod name_persist;
@@ -202,8 +206,10 @@ mod ui_unit;
 mod ui_world_map;
 mod video;
 mod vplates;
+mod torch_shadow;
 mod weapon_trail;
 mod world_backdrop;
+mod world_shadow;
 mod world_state;
 mod world_state_ui;
 
diff --git a/crates/benilla-app/src/pipe_warm/menagerie.rs b/crates/benilla-app/src/pipe_warm/menagerie.rs
index 3af254a1..079ee8ed 100644
--- a/crates/benilla-app/src/pipe_warm/menagerie.rs
+++ b/crates/benilla-app/src/pipe_warm/menagerie.rs
@@ -13,7 +13,7 @@ use bevy::mesh::{Indices, MeshTag, PrimitiveTopology};
 use bevy::prelude::*;
 use bevy::render::render_resource::Buffer;
 
-use benilla_assets::materials::{LiquidMaterial, WowModelMaterial};
+use benilla_assets::materials::{LiquidMaterial, TorchBinds, WowModelMaterial};
 use benilla_world::clouds::CloudMaterial;
 use benilla_world::model_render::{
     far_twin_of, model_material, zfill_material, MaterialCache, ShadeSel,
@@ -103,6 +103,8 @@ pub(super) fn spawn_menagerie(
     lanes: &mut WarmLanes,
     cache: &mut MaterialCache,
     light: &Buffer,
+    // MONKEY (torch shadows Phase 3A): the shared torch bindings, beside the light buffer.
+    torch: &TorchBinds,
 ) -> usize {
     // The four vertex layouts the model lane ships (0837 dump: strides 32/48/56/72): static ×
     // {plain, vertex-colours} and their skinned twins. Statics are RENDER_WORLD-only, so their
@@ -162,6 +164,7 @@ pub(super) fn spawn_menagerie(
                         false,
                         false, // warms the WORLD lane; the sky lane warms with its own model
                         light,
+                        torch,
                         // The pipeline menagerie warms the SHARED batch material; the
                         // per-placement lane (1408) builds an identical pipeline, so a clone
                         // needs no row of its own here.
@@ -205,6 +208,7 @@ pub(super) fn spawn_menagerie(
                         false,
                         false, // warms the WORLD lane; the sky lane warms with its own model
                         light,
+                        torch,
                         // The pipeline menagerie warms the SHARED batch material; the
                         // per-placement lane (1408) builds an identical pipeline, so a clone
                         // needs no row of its own here.
@@ -216,7 +220,7 @@ pub(super) fn spawn_menagerie(
         // The depth-prime twin (colour writes masked off), plain and cutout.
         for cutout in [false, true] {
             mats.push(zfill_material(
-                cache, materials, None, two_sided, cutout, light,
+                cache, materials, None, two_sided, cutout, light, torch,
             ));
         }
         // The **WMO-skybox lane** (decision 1264): `sky_depth` is a `WowModelKey` axis — it
@@ -259,6 +263,7 @@ pub(super) fn spawn_menagerie(
                     false,
                     true, // the sky lane
                     light,
+                    torch,
                     None, // the shared lane — see the note above
                 ));
             }
@@ -301,6 +306,7 @@ pub(super) fn spawn_menagerie(
                 false,
                 false, // warms the WORLD lane; the sky lane warms with its own model
                 light,
+                torch,
                 None, // the shared lane — see the note above
             );
             // The warmer reads what it builds (`model_render::lazy` parks a built material
@@ -353,6 +359,7 @@ pub(super) fn spawn_menagerie(
                         false,
                         false, // warms the WORLD lane; the sky lane warms with its own model
                         light,
+                        torch,
                         None, // the shared lane — see the note above
                     );
                     benilla_world::model_render::lazy::realize_all(materials);
diff --git a/crates/benilla-app/src/pipe_warm/mod.rs b/crates/benilla-app/src/pipe_warm/mod.rs
index 526bc00e..57385b0b 100644
--- a/crates/benilla-app/src/pipe_warm/mod.rs
+++ b/crates/benilla-app/src/pipe_warm/mod.rs
@@ -428,6 +428,8 @@ fn run_warm_pass(
     mut gizmos: Gizmos,
     mut cache: Local<MaterialCache>,
     shared_light: Option<Res<benilla_world::lighting::SharedLightBuffer>>,
+    // MONKEY (torch shadows Phase 3A): the shared torch bindings every warmed material takes.
+    torch: benilla_world::static_gx::TorchShared,
 ) {
     // `EntryCover` already IS "a loading cover is up and we are in world", counted once for the
     // whole client (see its doc); this used to spell the pair out for itself.
@@ -463,6 +465,9 @@ fn run_warm_pass(
         let Some(light) = shared_light.as_ref() else {
             return;
         };
+        let Some(torch) = torch.binds() else {
+            return;
+        };
         if !cover.presented() {
             return;
         }
@@ -499,6 +504,7 @@ fn run_warm_pass(
             &mut lanes,
             &mut cache,
             &light.0,
+            &torch,
         );
         info!("pipeline warm: menagerie up ({count} variants, {WARM_REVEAL_PER_FRAME}/frame)");
         return;
diff --git a/crates/benilla-app/src/portrait/glue_booth.rs b/crates/benilla-app/src/portrait/glue_booth.rs
index a65d3dae..fe45ec9d 100644
--- a/crates/benilla-app/src/portrait/glue_booth.rs
+++ b/crates/benilla-app/src/portrait/glue_booth.rs
@@ -2153,6 +2153,9 @@ mod tests {
                 visibility_off: false,
             },
             bone_pivot: [0.0; 3],
+            synthetic: false,
+            flame: false,
+            spell: None,
         }
     }
 
diff --git a/crates/benilla-app/src/shaders.rs b/crates/benilla-app/src/shaders.rs
index 07eb4b88..55ab58a5 100644
--- a/crates/benilla-app/src/shaders.rs
+++ b/crates/benilla-app/src/shaders.rs
@@ -24,6 +24,8 @@ pub(crate) fn plugin(app: &mut App) {
     bevy::asset::embedded_asset!(app, "shaders/ui_gamma.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/ui_node_gamma.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/ui_slice_gamma.wgsl");
+    bevy::asset::embedded_asset!(app, "shaders/shadow_caster.wgsl");
+    bevy::asset::embedded_asset!(app, "shaders/shadow_caster_cutout_prepass.wgsl");
 }
 
 #[cfg(test)]
@@ -59,6 +61,6 @@ mod tests {
                  `shaders::plugin`, or was registered from a file that is not directly under src/"
             );
         }
-        assert_eq!(found, 5, "the game's shader set changed size");
+        assert_eq!(found, 7, "the game's shader set changed size");
     }
 }
diff --git a/crates/benilla-app/src/shaders/shadow_caster.wgsl b/crates/benilla-app/src/shaders/shadow_caster.wgsl
new file mode 100644
index 00000000..47dedcc1
--- /dev/null
+++ b/crates/benilla-app/src/shaders/shadow_caster.wgsl
@@ -0,0 +1,7 @@
+// The proxy is deliberately invisible in the camera's forward pass. Its material remains
+// opaque, so Bevy still queues it for the depth-only directional-light shadow pass.
+@fragment
+fn fragment() -> @location(0) vec4<f32> {
+    discard;
+    return vec4<f32>(0.0);
+}
diff --git a/crates/benilla-app/src/shaders/shadow_caster_cutout_prepass.wgsl b/crates/benilla-app/src/shaders/shadow_caster_cutout_prepass.wgsl
new file mode 100644
index 00000000..bc709a82
--- /dev/null
+++ b/crates/benilla-app/src/shaders/shadow_caster_cutout_prepass.wgsl
@@ -0,0 +1,63 @@
+// MONKEY (world shadows): alpha-tested foliage shadow caster — the PREPASS fragment.
+//
+// The proxy caster is invisible in the camera's forward pass (its forward fragment `discard`s every
+// fragment — `shadow_caster.wgsl`). Its material is `AlphaMode::Mask`, which sets Bevy's
+// `MAY_DISCARD` pipeline key; paired with this EXPLICIT prepass fragment shader that decides Bevy
+// runs a fragment during the directional-light SHADOW pass (which is otherwise depth-only). So a
+// leaf card can discard its transparent texels and cast a leaf-SHAPED silhouette instead of the
+// solid rectangular box a positions-only proxy throws.
+//
+// The leaf sheet is bound as the material's own texture at group `MATERIAL_BIND_GROUP` — the
+// prepass material slot (index 3; substituted by the prepass pipeline). Sampling the SAME image the
+// forward pass draws keeps the clamp/repeat address mode identical, so the shadow silhouette
+// matches the visible foliage exactly (a cutout card's UVs run outside 0..1 into the transparent
+// border — sampled with the wrong wrap mode the margin wraps back into the opaque middle and the
+// card casts solid again).
+//
+// Structure mirrors Bevy's own `pbr_prepass.wgsl`: a `FragmentOutput`-returning entry under
+// `PREPASS_FRAGMENT` (the unclipped-depth-emulation path for GPUs without `depth_clip_control`) and
+// a void entry otherwise (the common desktop depth-only path); both run the same cutout discard.
+
+#import bevy_pbr::prepass_io
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(0) var leaf_texture: texture_2d<f32>;
+@group(#{MATERIAL_BIND_GROUP}) @binding(1) var leaf_sampler: sampler;
+
+// WoW ≤ WotLK alpha-test key (`benilla_assets::materials::VANILLA_ALPHA_KEY_REF` = 224/255): the
+// value below which a cutout fragment is discarded. The exact ref the forward cutout pass uses.
+const VANILLA_ALPHA_KEY: f32 = 0.8784314;
+
+// Sample the leaf sheet at the interpolated UV and discard transparent texels, exactly as the
+// forward cutout does. Sampled BEFORE any `discard` so the texture access stays in uniform control
+// flow. A caster mesh always carries `UV_0` (`VERTEX_UVS_A`); lacking it, nothing discards (the
+// card falls back to a solid cast rather than vanishing).
+fn cutout_discard(in: prepass_io::VertexOutput) {
+#ifdef VERTEX_UVS_A
+    let alpha = textureSample(leaf_texture, leaf_sampler, in.uv).a;
+    if alpha < VANILLA_ALPHA_KEY {
+        discard;
+    }
+#endif
+}
+
+#ifdef PREPASS_FRAGMENT
+// A GPU without `depth_clip_control`: Bevy emulates the directional-shadow view's unclipped depth
+// by writing `frag_depth` in the fragment (`prepass/mod.rs`, `UNCLIPPED_DEPTH_ORTHO_EMULATION`).
+// Mirror the default prepass fragment's single field so that depth-clamp fix still applies here.
+@fragment
+fn fragment(in: prepass_io::VertexOutput) -> prepass_io::FragmentOutput {
+    cutout_discard(in);
+    var out: prepass_io::FragmentOutput;
+#ifdef UNCLIPPED_DEPTH_ORTHO_EMULATION
+    out.frag_depth = in.unclipped_depth;
+#endif // UNCLIPPED_DEPTH_ORTHO_EMULATION
+    return out;
+}
+#else
+// The common desktop path: the shadow pass is depth-only (no color targets), so the fragment
+// returns nothing and exists ONLY to run the cutout discard against the depth write.
+@fragment
+fn fragment(in: prepass_io::VertexOutput) {
+    cutout_discard(in);
+}
+#endif // PREPASS_FRAGMENT
diff --git a/crates/benilla-app/src/shadow_core.rs b/crates/benilla-app/src/shadow_core.rs
new file mode 100644
index 00000000..9028d4df
--- /dev/null
+++ b/crates/benilla-app/src/shadow_core.rs
@@ -0,0 +1,933 @@
+//! The shared **shadow rig** — the framework both shadow lanes plug into.
+//!
+//! A realtime shadow needs three things: something to CAST (a lane's caster geometry), a LIGHT +
+//! shadow map to cast INTO, and RECEIVERS that read the map and darken. This module owns the middle
+//! part — one directional "sun" on a private render layer, that layer's membership on the world
+//! camera, the shadow-map resource, the invisible proxy caster material, and the sun aiming — plus
+//! the geometry-collection helpers the lanes share. The receivers live in benilla's own shaders.
+//!
+//! The two lanes ([`super::character_shadow`], [`super::world_shadow`]) are EQUAL and independent:
+//! each is its own plugin that depends only on this core, never on the other. They coordinate with
+//! the rig through two resources, with a deliberate one-frame handshake:
+//! - [`ShadowDemand`] — each active lane ORs `true` in (in the [`ShadowSet::Lanes`] set); the rig
+//!   reads it next frame to decide whether the sun should exist. A lane that is removed simply stops
+//!   contributing demand — the core needs no edit.
+//! - [`ShadowFrame`] — the rig publishes the shared per-frame facts (is it active, the caster
+//!   material, the camera/light position, the sun direction, the two collection reaches) for the
+//!   lanes to read when they build their casters.
+//!
+//! Why ONE shared light and not one per lane: benilla's custom receiver shaders sample a SINGLE
+//! directional light (they assign, not accumulate, over the light loop). Two lights would double the
+//! shadow-pass cost and the last would win the receiver. So the lanes share this rig and each merely
+//! contributes its own caster geometry into the one map.
+//!
+//! The rig deliberately does NOT put a directional light on the normal world layer: that would make
+//! every existing WoW material enter Bevy's shadow-prepass path, the source of the pipeline
+//! corruption seen during the first experiment. Only the private-layer proxy casts.
+
+use bevy::asset::RenderAssetUsages;
+use bevy::camera::visibility::{NoFrustumCulling, RenderLayers};
+use bevy::light::{
+    CascadeShadowConfigBuilder, DirectionalLight, DirectionalLightShadowMap, NotShadowReceiver,
+    ShadowFilteringMethod,
+};
+use bevy::mesh::{Indices, PrimitiveTopology};
+use bevy::pbr::{Material, MaterialPipeline, MaterialPlugin, MeshMaterial3d};
+use bevy::prelude::*;
+use bevy::reflect::TypePath;
+use bevy::render::render_resource::{
+    AsBindGroup, RenderPipelineDescriptor, SpecializedMeshPipelineError,
+};
+use bevy::shader::ShaderRef;
+
+use benilla_assets::coords::wow_to_bevy;
+use benilla_assets::materials::WowModelMaterial;
+use benilla_formats::ModelBlend;
+use benilla_world::billboard::BillboardCard;
+use benilla_world::interact::PickMesh;
+use benilla_world::lighting::{ShadowDistance, ShadowFilterGaussian, WowLighting};
+use benilla_world::model_render::{ModelKind, ModelPart, ShadowOccluder};
+use benilla_world::rig_palette::{RigPalettes, RigPart, RigSkin};
+use benilla_world::view::WorldCamera;
+
+use crate::char_select::ClientState;
+use crate::video::VideoConfig;
+
+/// Layer 31 is deliberately private to this feature. Bevy supports 32 render layers; the normal
+/// world is layer 0 and the UI/portrait layers occupy the low numbered slots.
+pub(crate) const PLAYER_SHADOW_LAYER: usize = 31;
+
+/// Shipped realtime-shadow render distance in yards — the `shadowDistance` default. How far from the
+/// camera the shadow map RESOLVES (the single cascade's `maximum_distance`). Collection reaches
+/// farther than this (a caster's body may stand outside the cascade while its shadow lands inside).
+pub(crate) const DEFAULT_SHADOW_DISTANCE: f32 = 80.0;
+
+/// The `shadowDistance` slider range (yd). Min keeps a useful near shadow; max is bounded because
+/// the ONE shadow map spreads thinner (softer) over a larger area and the caster-collection cost
+/// grows with distance. (The map's edge is no longer the fixed 4096 this note was written against —
+/// it is `shadowMapSize`, default 2048 — which makes the softening at long range twice as quick.)
+pub(crate) const SHADOW_DISTANCE_RANGE: std::ops::RangeInclusive<f32> = 40.0..=200.0;
+
+/// How far the camera may drift before a cached caster-collection pass must refresh. The collection
+/// reach carries this as margin so coverage holds everywhere between refreshes.
+pub(crate) const STATIC_REBUILD_STEP: f32 = 16.0;
+
+// -------------------------------------------------------------------------------------------
+// MONKEY (sun shadow perf): the five live dials over this rig's cost. Measured on an RTX 3070 at
+// 1080p in the Lion's Pride Inn: 45-47 fps with both lanes on, 60-62 with `characterShadows 0`,
+// 68-73 with `worldShadows 0` too — i.e. ~5 ms/frame in the sun lanes, the renderer's single
+// biggest line item. The cost splits three ways and each dial takes one of them:
+//   * the shadow PASS's fill + its depth texture .... `shadowMapSize` (quadratic in the edge)
+//   * the RECEIVERS' PCF fetches ..................... `shadowFilter`  (9 samples vs 1)
+//   * the CPU caster rebuild + GPU re-upload ......... `characterShadowRate` / `worldShadowRate`
+// and `shadowCasterReach` trims the caster POPULATION those rebuilds walk. All live: nothing here
+// is latched at boot, so the user A/Bs the whole set from one chat line.
+// -------------------------------------------------------------------------------------------
+
+/// The `shadowMapSize` ladder. Powers of two only — Bevy's `validate_shadow_map_size` rounds a
+/// non-power-of-two up with a warning, so an off-ladder value would silently become a different
+/// (and larger) map than the one the user typed.
+pub(crate) const SHADOW_MAP_SIZES: [u32; 3] = [1024, 2048, 4096];
+
+/// The shipped shadow-map edge. **2048**, down from the rig's original 4096 literal: the pass is
+/// quadratic in this, and over ONE 80 yd cascade 2048 is ~26 texels/yd — finer than the Gaussian
+/// receiver kernel resolves. The softer edge is the accepted trade; `shadowMapSize 4096` restores
+/// the old crispness at the old price.
+pub(crate) const DEFAULT_SHADOW_MAP_SIZE: u32 = 2048;
+
+/// `shadowFilter` default: **1 = Gaussian**, the look the rig has always had. The cheap arm (0 =
+/// Hardware2x2) is one comparison sample instead of nine and is where the receiver-side win is,
+/// but it stair-steps edges, so it ships OFF and the user judges it.
+pub(crate) const DEFAULT_SHADOW_FILTER: u32 = 1;
+
+/// The `shadowFilter` ladder's top. Bevy also has `Temporal`, which is deliberately NOT offered:
+/// it is a randomized filter that only resolves under `TemporalAntiAliasing`, which benilla's
+/// world camera does not run — it would read as noise.
+pub(crate) const MAX_SHADOW_FILTER: u32 = 1;
+
+/// The shipped Hz cap on both lanes' per-frame caster rebuild. **30** — half of a 60 Hz frame's
+/// rebuilds for a silhouette that lags at most 33 ms, which is under the reaction threshold for a
+/// shadow you are not looking directly at.
+pub(crate) const DEFAULT_SHADOW_RATE: u32 = 30;
+
+/// The rate ladder's top. Above the frame rate the cap is inert, so 120 is "off" with headroom for
+/// a high-refresh panel; `0` is the explicit "every frame" (the pre-cvar behaviour).
+pub(crate) const MAX_SHADOW_RATE: u32 = 120;
+
+/// The `shadowCasterReach` multiplier range. `1` is the untouched reach law. The floor is 0.25 and
+/// not 0 because a 0 reach admits nothing and would read as "shadows broke", which is what
+/// `worldShadows 0` / `characterShadows 0` are for.
+pub(crate) const CASTER_REACH_RANGE: std::ops::RangeInclusive<f32> = 0.25..=2.0;
+
+/// Snap a requested `shadowMapSize` onto [`SHADOW_MAP_SIZES`] — nearest in LOG space, so 1500 lands
+/// on 1024 and 3000 on 4096 (halfway in ratio, not in texels, is what "one step" means here).
+pub(crate) fn clamp_shadow_map_size(asked: u32) -> u32 {
+    let asked = asked.clamp(SHADOW_MAP_SIZES[0], SHADOW_MAP_SIZES[SHADOW_MAP_SIZES.len() - 1]);
+    *SHADOW_MAP_SIZES
+        .iter()
+        .min_by(|a, b| {
+            let d = |v: u32| ((v as f32).ln() - (asked as f32).ln()).abs();
+            d(**a).total_cmp(&d(**b))
+        })
+        .unwrap_or(&DEFAULT_SHADOW_MAP_SIZE)
+}
+
+/// A lane's rebuild cadence gate. Holds the timestamp of the last rebuild and answers "may I
+/// rebuild now?" against a live Hz cap.
+///
+/// Deliberately time-based rather than frame-counted: the point is to bound the rebuild WORK per
+/// second, and a frame counter would tighten the real cadence exactly when the frame rate is
+/// already high (where the work is affordable) and loosen it when it drops (where it is not).
+///
+/// `rate == 0` means "every frame" — the pre-cvar behaviour, kept reachable so the cap can be
+/// ruled out as the cause of any artefact in one keystroke.
+#[derive(Default)]
+pub(crate) struct RebuildRate {
+    last: Option<f32>,
+}
+
+impl RebuildRate {
+    /// True when a rebuild is due at `now` (seconds since app start) for a cap of `rate` Hz; the
+    /// timestamp is taken on the way out, so a `true` consumes the slot. The FIRST call is always
+    /// due — a lane that has never built has nothing to show.
+    pub(crate) fn due(&mut self, now: f32, rate: u32) -> bool {
+        if rate == 0 {
+            self.last = Some(now);
+            return true;
+        }
+        let interval = 1.0 / rate as f32;
+        // `now < last` (a time reset) is treated as due rather than as a very long wait.
+        let due = self.last.is_none_or(|last| now - last >= interval || now < last);
+        if due {
+            self.last = Some(now);
+        }
+        due
+    }
+
+    /// Forget the last rebuild, so the lane's next frame rebuilds immediately. Called when a lane
+    /// tears its caster down — the mesh it was pacing no longer exists.
+    pub(crate) fn reset(&mut self) {
+        self.last = None;
+    }
+}
+
+/// The tallest COMMON caster the reach law budgets for (the big Elwynn/Duskwood tree class, in world
+/// units). Not a clamp on what casts — only on how far past the resolve range collection hunts.
+const MAX_CASTER_HEIGHT: f32 = 35.0;
+
+/// Ceiling on the shadow-reach extension: a degenerate near-horizontal sun must not explode the
+/// collection radius (and with it the rebuild cost) unbounded.
+const SHADOW_REACH_CAP: f32 = 120.0;
+
+/// How far the LIVE sun may drift from the last-written direction before the shadow light snaps to
+/// it — about one game minute of travel. The basis is quantised because a light that rotates EVERY
+/// frame defeats the cascade fit's texel snap and crawls every shadow edge at WoW map coordinates
+/// (~9,300 units out). Held between snaps the basis is bit-stable; only the shadow basis steps.
+const SUN_SNAP_RADIANS: f32 = 8.0e-4;
+
+/// The daytime elevation band (radians above the horizon) the shadow sun is clamped to. The visible
+/// celestial sun sweeps roughly −10°..+85° and dips below the horizon at night; unclamped that would
+/// INVERT the shadow (a set sun's travel points upward) or DEGENERATE the `looking_to` basis at high
+/// noon (travel nearly ∥ up). Pinning to ~18°..65° keeps shadows visible, right-way-up and bounded
+/// while the AZIMUTH still tracks the real sun — so shadows sweep through the day ("moving sun").
+const MIN_SHADOW_SUN_ELEVATION: f32 = 0.314; // ~18°
+const MAX_SHADOW_SUN_ELEVATION: f32 = 1.134; // ~65°
+
+fn shadow_reach_extension(sun_travel: Vec3) -> f32 {
+    // `sun_travel` is the direction the light TRAVELS (downward): -y is the vertical drop.
+    let down = -sun_travel.y;
+    if down <= 1e-3 {
+        return SHADOW_REACH_CAP;
+    }
+    let horizontal = Vec3::new(sun_travel.x, 0.0, sun_travel.z).length();
+    (MAX_CASTER_HEIGHT * horizontal / down).min(SHADOW_REACH_CAP)
+}
+
+/// The collection law for a lane that can contribute a TALL caster (a doodad/WMO exile, or the whole
+/// static world): resolve range + rebuild margin + the sun-dependent shadow reach.
+pub(crate) fn static_collection_reach(sun_travel: Vec3, distance: f32) -> f32 {
+    distance + STATIC_REBUILD_STEP + shadow_reach_extension(sun_travel)
+}
+
+/// `WOW_SHADOW_TRACE=1` — log the caster population when it CHANGES, to attribute a vanished shadow
+/// to a lane rather than the map/receiver.
+pub(crate) fn shadow_trace() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| std::env::var("WOW_SHADOW_TRACE").is_ok_and(|v| v != "0"))
+}
+
+fn sun_snap_due(held: Option<Vec3>, live: Vec3) -> bool {
+    match held {
+        None => true,
+        Some(held) => held.angle_between(live) > SUN_SNAP_RADIANS,
+    }
+}
+
+/// The shadow sun's TRAVEL direction (light propagation — points AWAY from the sun) from the visible
+/// celestial TO-sun direction, elevation clamped to [`MIN_SHADOW_SUN_ELEVATION`,
+/// `MAX_SHADOW_SUN_ELEVATION`]. Azimuth is preserved so shadows sweep with the real sun; only the
+/// height is tamed so a set/zenith sun can't invert or degenerate the basis.
+fn shadow_sun_travel(to_sun: Vec3) -> Vec3 {
+    let s = to_sun.normalize_or_zero();
+    if s == Vec3::ZERO {
+        return Vec3::NEG_Z;
+    }
+    let horizontal = Vec3::new(s.x, 0.0, s.z);
+    let bearing = if horizontal.length() > 1e-4 {
+        horizontal.normalize()
+    } else {
+        Vec3::NEG_Z
+    };
+    let elevation = s
+        .y
+        .clamp(-1.0, 1.0)
+        .asin()
+        .clamp(MIN_SHADOW_SUN_ELEVATION, MAX_SHADOW_SUN_ELEVATION);
+    let to_sun_clamped = bearing * elevation.cos() + Vec3::Y * elevation.sin();
+    -to_sun_clamped
+}
+
+/// Marks a layer-31 caster mesh (either lane's). Kept for teardown/inspection symmetry.
+#[derive(Component)]
+pub(crate) struct ShadowCaster;
+
+#[derive(Component)]
+struct ShadowSun;
+
+#[derive(Component)]
+struct ShadowCameraLayer {
+    had_layers: bool,
+}
+
+/// The two ordered phases of the shadow feature within `Last`: the rig runs FIRST (spawns/aims the
+/// sun, publishes [`ShadowFrame`]), then every lane runs in [`ShadowSet::Lanes`] — reading the frame
+/// to build its casters and ORing its demand back in for the rig to read next frame.
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) enum ShadowSet {
+    Rig,
+    Lanes,
+}
+
+/// Each active lane ORs `true` here (in [`ShadowSet::Lanes`]); the rig reads it the next frame to
+/// decide whether the sun should exist, then resets it. A removed lane just stops contributing —
+/// the core needs no edit to notice a lane is gone.
+#[derive(Resource, Default)]
+pub(crate) struct ShadowDemand(pub bool);
+
+/// The rig's per-frame publication for the lanes: whether the rig is live, the shared proxy caster
+/// material, and the shared collection inputs (camera/light position, sun direction, and the two
+/// reaches). A lane builds nothing until `active` and only with the `material` here.
+#[derive(Resource, Default)]
+pub(crate) struct ShadowFrame {
+    pub active: bool,
+    pub light_position: Vec3,
+    pub sun_direction: Vec3,
+    /// Reach for short casters (creatures/gameobjects — at most a body tall).
+    pub entity_reach: f32,
+    /// Reach for tall casters (doodads/WMO/static world) — carries the sun-dependent shadow reach.
+    pub tall_reach: f32,
+    pub material: Option<Handle<ShadowCasterMaterial>>,
+}
+
+/// The rig's own retained state — private to the core.
+#[derive(Resource, Default)]
+struct ShadowRigState {
+    sun: Option<Entity>,
+    /// The direction the sun was LAST GIVEN — the held shadow basis (see [`SUN_SNAP_RADIANS`]).
+    sun_written: Option<Vec3>,
+    /// The invisible proxy material shared by every lane's SOLID caster.
+    material: Option<Handle<ShadowCasterMaterial>>,
+    /// The cascade's currently-applied `maximum_distance` (the `shadowDistance` slider). The
+    /// `CascadeShadowConfig` is only re-inserted when this changes — rebuilding it every frame would
+    /// re-fit the cascade and defeat the texel snap (crawling every shadow edge).
+    cascade_distance: Option<f32>,
+    /// MONKEY (sun shadow perf): the last (map size, gaussian, character Hz, world Hz, reach)
+    /// [`shadow_trace`] reported. Purely the trace's change detector — the values themselves are
+    /// applied straight from [`VideoConfig`], never cached here.
+    traced_quality: Option<(u32, bool, u32, u32, f32)>,
+}
+
+pub(crate) struct ShadowCorePlugin;
+
+/// Opaque to Bevy's shadow pass, discarded by the forward pass — the private-layer proxy that lets a
+/// caster participate in the real shadow map without drawing a second copy of the world. Shared by
+/// every lane's SOLID caster.
+#[derive(Asset, AsBindGroup, TypePath, Debug, Clone, Default)]
+pub(crate) struct ShadowCasterMaterial {}
+
+impl Material for ShadowCasterMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "embedded://benilla_app/shaders/shadow_caster.wgsl".into()
+    }
+
+    fn specialize(
+        _pipeline: &MaterialPipeline,
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+        _key: bevy::pbr::MaterialPipelineKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        // WoW batches are frequently two-sided; keep both faces so a mixed-winding batch's
+        // projected silhouette has no holes.
+        descriptor.primitive.cull_mode = None;
+        Ok(())
+    }
+}
+
+impl Plugin for ShadowCorePlugin {
+    fn build(&self, app: &mut App) {
+        // MONKEY (sun shadow perf): the shipped edge is now 2048, and it is a LIVE cvar
+        // (`apply_shadow_quality` writes this resource) rather than the 4096 boot literal this
+        // line used to be. Bevy re-extracts the resource on change and `prepare_lights` re-keys
+        // the texture cache with the new descriptor, so the map is genuinely re-created.
+        app.insert_resource(DirectionalLightShadowMap {
+            size: DEFAULT_SHADOW_MAP_SIZE as usize,
+        })
+            .add_plugins(MaterialPlugin::<ShadowCasterMaterial>::default())
+            .init_resource::<ShadowRigState>()
+            .init_resource::<ShadowDemand>()
+            .init_resource::<ShadowFrame>()
+            // The rig runs before the lanes every frame; the lanes read the frame it publishes.
+            .configure_sets(Last, (ShadowSet::Rig, ShadowSet::Lanes).chain())
+            // MONKEY (sun shadow perf): the quality dials land BEFORE the rig each frame, and
+            // unconditionally — a `shadowMapSize` write must take even while the lanes are off, so
+            // turning shadows back on doesn't render one frame at the previous size.
+            .add_systems(
+                Last,
+                (apply_shadow_quality, manage_rig)
+                    .chain()
+                    .in_set(ShadowSet::Rig),
+            );
+    }
+}
+
+/// MONKEY (sun shadow perf): push the "how expensive is a shadow" QUALITY dials from [`VideoConfig`]
+/// to the places that own them, every frame, whether or not the lanes are up.
+///
+/// Three destinations, because Bevy spreads the shadow cost over three unrelated mechanisms:
+/// - **`shadowMapSize`** → the [`DirectionalLightShadowMap`] resource. Bevy's `extract_lights`
+///   re-publishes it into the render world on change and `prepare_lights` asks the texture cache
+///   for a descriptor carrying the new edge — a different descriptor is a different cache entry, so
+///   the depth texture is really re-created. Written through `ResMut` only on a genuine difference:
+///   touching it every frame would re-extract (and re-validate) it every frame for nothing.
+/// - **`shadowFilter`** → the world camera's [`ShadowFilteringMethod`], which keys the mesh
+///   pipeline for every Bevy-material receiver (terrain, `wow_model`). Bevy has no "default"
+///   component here — absent means Gaussian — but the component is inserted either way so the
+///   value on the camera always names what is actually running.
+/// - the same **`shadowFilter`** → [`ShadowFilterGaussian`], which `static_gx`'s hand-specialized
+///   retained pipeline reads in the render world. Both must move together or the ground and the
+///   buildings on it filter differently.
+///
+/// The rate dials need no push at all: each lane reads `VideoConfig` directly.
+fn apply_shadow_quality(
+    video: Res<VideoConfig>,
+    mut rig: ResMut<ShadowRigState>,
+    mut shadow_map: ResMut<DirectionalLightShadowMap>,
+    mut filter_out: ResMut<ShadowFilterGaussian>,
+    mut commands: Commands,
+    cameras: Query<(Entity, Option<&ShadowFilteringMethod>), With<WorldCamera>>,
+) {
+    let size = clamp_shadow_map_size(video.shadow_map_size) as usize;
+    if shadow_map.size != size {
+        shadow_map.size = size;
+    }
+
+    let gaussian = video.shadow_filter != 0;
+    let method = if gaussian {
+        ShadowFilteringMethod::Gaussian
+    } else {
+        ShadowFilteringMethod::Hardware2x2
+    };
+    for (entity, current) in &cameras {
+        if current != Some(&method) {
+            commands.entity(entity).insert(method);
+        }
+    }
+    if filter_out.0 != gaussian {
+        filter_out.0 = gaussian;
+    }
+
+    if shadow_trace() {
+        let now = (
+            size as u32,
+            gaussian,
+            video.character_shadow_rate,
+            video.world_shadow_rate,
+            video.shadow_caster_reach,
+        );
+        if rig.traced_quality != Some(now) {
+            info!(
+                "shadow-trace: quality — map {}² | filter {} | rebuild caps character {} / world {} Hz | caster reach ×{:.2}",
+                now.0,
+                if gaussian { "gaussian(9)" } else { "hardware2x2(1)" },
+                if now.2 == 0 { "every-frame".to_string() } else { now.2.to_string() },
+                if now.3 == 0 { "every-frame".to_string() } else { now.3.to_string() },
+                now.4,
+            );
+            rig.traced_quality = Some(now);
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn manage_rig(
+    state: Res<State<ClientState>>,
+    video: Res<VideoConfig>,
+    lighting: Res<WowLighting>,
+    mut demand: ResMut<ShadowDemand>,
+    mut frame: ResMut<ShadowFrame>,
+    mut rig: ResMut<ShadowRigState>,
+    // MONKEY (distance slider): bridge the app-side `shadowDistance` to benilla-world so
+    // `global_light` can pack it for the receivers' edge fade (which must fade at THIS distance).
+    mut shadow_distance_out: ResMut<ShadowDistance>,
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ShadowCasterMaterial>>,
+    mut cameras: Query<
+        (Entity, Option<&mut RenderLayers>, Option<&ShadowCameraLayer>),
+        With<WorldCamera>,
+    >,
+    mut suns: Query<&mut Transform, With<ShadowSun>>,
+    cameras_for_position: Query<&GlobalTransform, With<WorldCamera>>,
+) {
+    let in_world = *state.get() == ClientState::InWorld;
+    // The `shadowDistance` slider (already clamped by the cvar). Publish it to benilla-world every
+    // frame so the receiver edge fade tracks it.
+    let distance = video.shadow_distance;
+    if shadow_distance_out.0 != distance {
+        shadow_distance_out.0 = distance;
+    }
+    // Read the demand the lanes accumulated LAST frame, then reset so they re-accumulate this frame
+    // (they run after us, in ShadowSet::Lanes). One-frame lag on rig spawn — imperceptible.
+    let wanted = demand.0 && in_world;
+    demand.0 = false;
+
+    if !wanted {
+        if let Some(entity) = rig.sun.take() {
+            commands.entity(entity).despawn();
+        }
+        // Forget the held basis with the light, so a re-enable aims the fresh sun immediately.
+        rig.sun_written = None;
+        if let Some(handle) = rig.material.take() {
+            materials.remove(handle.id());
+        }
+        for (entity, layers, marker) in &mut cameras {
+            let Some(marker) = marker else { continue };
+            if marker.had_layers {
+                if let Some(mut layers) = layers {
+                    *layers = layers.clone().without(PLAYER_SHADOW_LAYER);
+                }
+            } else {
+                commands.entity(entity).remove::<RenderLayers>();
+            }
+            commands.entity(entity).remove::<ShadowCameraLayer>();
+        }
+        frame.active = false;
+        frame.material = None;
+        return;
+    }
+
+    if rig.material.is_none() {
+        rig.material = Some(materials.add(ShadowCasterMaterial {}));
+    }
+    if rig.sun.is_none() {
+        let sun = commands
+            .spawn((
+                DirectionalLight {
+                    // The light exists to populate a shadow map; WoW's shader lighting stays
+                    // authoritative, so it must not add a second diffuse term.
+                    illuminance: 0.0,
+                    shadows_enabled: true,
+                    shadow_depth_bias: 0.02,
+                    shadow_normal_bias: 0.8,
+                    ..default()
+                },
+                CascadeShadowConfigBuilder {
+                    num_cascades: 1,
+                    minimum_distance: 0.1,
+                    maximum_distance: distance,
+                    ..default()
+                }
+                .build(),
+                Transform::IDENTITY,
+                Visibility::Visible,
+                RenderLayers::layer(PLAYER_SHADOW_LAYER),
+                ShadowSun,
+            ))
+            .id();
+        rig.sun = Some(sun);
+        rig.sun_written = None;
+        rig.cascade_distance = Some(distance);
+    }
+    // Re-fit the cascade only when the slider changed (not every frame — that would defeat the
+    // texel snap and crawl every shadow edge).
+    if rig.cascade_distance != Some(distance) {
+        if let Some(sun) = rig.sun {
+            commands.entity(sun).insert(
+                CascadeShadowConfigBuilder {
+                    num_cascades: 1,
+                    minimum_distance: 0.1,
+                    maximum_distance: distance,
+                    ..default()
+                }
+                .build(),
+            );
+        }
+        rig.cascade_distance = Some(distance);
+    }
+
+    for (entity, layers, marker) in &mut cameras {
+        if marker.is_some() {
+            if let Some(mut layers) = layers {
+                *layers = layers.clone().with(PLAYER_SHADOW_LAYER);
+            }
+        } else if let Some(mut layers) = layers {
+            *layers = layers.clone().with(PLAYER_SHADOW_LAYER);
+            commands
+                .entity(entity)
+                .insert(ShadowCameraLayer { had_layers: true });
+        } else {
+            commands.entity(entity).insert((
+                RenderLayers::default().with(PLAYER_SHADOW_LAYER),
+                ShadowCameraLayer { had_layers: false },
+            ));
+        }
+    }
+
+    let light_position = cameras_for_position
+        .iter()
+        .next()
+        .map(GlobalTransform::translation)
+        .unwrap_or(Vec3::ZERO);
+
+    // MONKEY (moving sun): aim at the VISIBLE celestial sun (rises/sets), clamped in elevation.
+    let sun_direction = shadow_sun_travel(lighting.celestial_dir());
+    // MONKEY (sun shadow perf): `shadowCasterReach` scales BOTH reaches by the same factor, after
+    // the reach law rather than inside it — the law's terms (resolve range, rebuild margin, the
+    // sun-elevation extension) each mean something, and a dial that rewrote one of them would
+    // change what the others compensate for. A flat multiplier is honestly just "collect less".
+    let reach_scale = video
+        .shadow_caster_reach
+        .clamp(*CASTER_REACH_RANGE.start(), *CASTER_REACH_RANGE.end());
+    let entity_reach = (distance + STATIC_REBUILD_STEP) * reach_scale;
+    let tall_reach = static_collection_reach(sun_direction, distance) * reach_scale;
+
+    if let Some(sun) = rig.sun {
+        // Only the rotation matters; QUANTISED to hold the cascade texel snap (see SUN_SNAP_RADIANS).
+        if sun_snap_due(rig.sun_written, sun_direction) {
+            if let Ok(mut current) = suns.get_mut(sun) {
+                *current = Transform::IDENTITY.looking_to(sun_direction, Vec3::Y);
+                rig.sun_written = Some(sun_direction);
+            }
+        }
+    }
+
+    frame.active = true;
+    frame.light_position = light_position;
+    frame.sun_direction = sun_direction;
+    frame.entity_reach = entity_reach;
+    frame.tall_reach = tall_reach;
+    frame.material = rig.material.clone();
+}
+
+// ---------------------------------------------------------------------------------------------
+// Shared caster-building helpers, used by both lanes.
+// ---------------------------------------------------------------------------------------------
+
+/// Spawn a SOLID caster entity on the private shadow layer with the shared proxy material.
+pub(crate) fn spawn_solid_caster(
+    commands: &mut Commands,
+    mesh: Handle<Mesh>,
+    material: Handle<ShadowCasterMaterial>,
+) -> Entity {
+    commands
+        .spawn((
+            Mesh3d(mesh),
+            MeshMaterial3d(material),
+            Transform::IDENTITY,
+            Visibility::Visible,
+            RenderLayers::layer(PLAYER_SHADOW_LAYER),
+            NoFrustumCulling,
+            NotShadowReceiver,
+            ShadowCaster,
+        ))
+        .id()
+}
+
+/// Append a triangle list, dropping WHOLE triangles whose indices exceed the vertex range (filtering
+/// single indices out of a `TriangleList` rewires the rest of the submesh into garbage).
+pub(crate) fn append_triangles(source: &[u32], vertex_count: u32, base: u32, indices: &mut Vec<u32>) {
+    for triangle in source.chunks_exact(3) {
+        if triangle.iter().all(|index| *index < vertex_count) {
+            indices.extend(triangle.iter().map(|index| base + *index));
+        }
+    }
+}
+
+/// Take a caster mesh's own buffers so a rebuild reuses their allocations. The mesh is left
+/// attribute-less until [`restore_mesh_buffers`] puts them back.
+pub(crate) fn take_mesh_buffers(mesh: &mut Mesh) -> (Vec<[f32; 3]>, Vec<u32>) {
+    let mut positions = match mesh.remove_attribute(Mesh::ATTRIBUTE_POSITION) {
+        Some(bevy::mesh::VertexAttributeValues::Float32x3(values)) => values,
+        _ => Vec::new(),
+    };
+    let mut indices = match mesh.remove_indices() {
+        Some(Indices::U32(values)) => values,
+        _ => Vec::new(),
+    };
+    positions.clear();
+    indices.clear();
+    (positions, indices)
+}
+
+pub(crate) fn restore_mesh_buffers(mesh: &mut Mesh, positions: Vec<[f32; 3]>, indices: Vec<u32>) {
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+    mesh.insert_indices(Indices::U32(indices));
+}
+
+pub(crate) fn empty_shadow_mesh() -> Mesh {
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, Vec::<[f32; 3]>::new());
+    mesh.insert_indices(Indices::U32(Vec::new()));
+    mesh
+}
+
+/// A cutout caster mesh: like [`empty_shadow_mesh`] but carrying a `UV_0` lane, because the
+/// alpha-tested prepass fragment samples the leaf sheet at these UVs. The mesh MUST declare UV_0
+/// (even empty) so Bevy's prepass specializer sets `VERTEX_UVS_A` and the fragment's `in.uv` exists.
+pub(crate) fn empty_cutout_mesh() -> Mesh {
+    let mut mesh = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    );
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, Vec::<[f32; 3]>::new());
+    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, Vec::<[f32; 2]>::new());
+    mesh.insert_indices(Indices::U32(Vec::new()));
+    mesh
+}
+
+/// Collect the per-frame ENTITY caster geometry a lane wants into its buffers. `want_creatures` /
+/// `want_environment` select which kinds this caster admits — the CHARACTER lane wants creatures,
+/// the WORLD lane wants entity-resident environment (gameobjects, faded doodads, WMO props). Returns
+/// `(admitted, occluder-rejected)` for the trace. Range-gates before any vertex work. The `parts`
+/// query is written inline (not aliased) so a lane can pass its own identically-typed query.
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn collect_entity_geometry(
+    parts: &Query<
+        (
+            &PickMesh,
+            &ModelPart,
+            Option<&GlobalTransform>,
+            Option<&RigPart>,
+            &ShadowOccluder,
+            Option<&MeshMaterial3d<WowModelMaterial>>,
+        ),
+        Without<BillboardCard>,
+    >,
+    rigs: &Query<&RigSkin>,
+    palettes: &RigPalettes,
+    want_creatures: bool,
+    want_environment: bool,
+    light_position: Vec3,
+    creature_reach: f32,
+    doodad_reach: f32,
+    positions: &mut Vec<[f32; 3]>,
+    indices: &mut Vec<u32>,
+) -> (u32, u32) {
+    let (mut admitted, mut rejected) = (0u32, 0u32);
+    for (pick, part, global, rig_part, occluder, _material) in parts.iter() {
+        if !casts_realtime_shadow(part.kind, part.blend, want_creatures, want_environment) {
+            continue;
+        }
+        // The content half of the visibility law (toggles, far clip, distance fade, material
+        // alpha) — NOT `InheritedVisibility`, which folds camera-orientation verdicts a shadow
+        // caster must ignore (a tree behind the camera still blocks the sun).
+        if !occluder.0 {
+            rejected += 1;
+            continue;
+        }
+        let reach = match part.kind {
+            ModelKind::Creature | ModelKind::GameObject => creature_reach,
+            ModelKind::Doodad | ModelKind::Wmo => doodad_reach,
+        };
+        let anchor = global.map(GlobalTransform::translation).or_else(|| {
+            rig_part
+                .and_then(|rig_part| rigs.get(rig_part.0).ok())
+                .and_then(|rig| palettes.slot_origin(rig.slot))
+        });
+        let Some(anchor) = anchor else { continue };
+        if anchor.distance_squared(light_position) > reach * reach {
+            continue;
+        }
+        admitted += 1;
+        let base = positions.len() as u32;
+        if let Some(rig_part) = rig_part {
+            append_skinned(pick, rig_part, rigs, palettes, positions);
+        } else if let Some(global) = global {
+            positions.extend(
+                pick.0
+                    .positions
+                    .iter()
+                    .map(|p| global.transform_point(wow_to_bevy(*p)).to_array()),
+            );
+        }
+        let added = positions.len() as u32 - base;
+        if added != 0 {
+            append_triangles(&pick.0.indices, added, base, indices);
+        }
+    }
+    (admitted, rejected)
+}
+
+/// The per-frame entity caster's admit law. CHARACTERS (creatures/players/mounts) are opaque +
+/// alpha-test (hair/fringe cards are small, so casting them solid doesn't box out). Entity-resident
+/// ENVIRONMENT (gameobjects, faded doodads, WMO props) is OPAQUE only — a foliage leaf-card cast
+/// solid becomes a box; retained-world cutout is cast leaf-shaped by the world lane's alpha-tested
+/// material instead. Additive/transparent geometry never casts a solid shadow.
+fn casts_realtime_shadow(
+    kind: ModelKind,
+    blend: ModelBlend,
+    want_creatures: bool,
+    want_environment: bool,
+) -> bool {
+    match kind {
+        ModelKind::Creature => {
+            want_creatures && matches!(blend, ModelBlend::Opaque | ModelBlend::AlphaTest)
+        }
+        _ => want_environment && matches!(blend, ModelBlend::Opaque),
+    }
+}
+
+fn append_skinned(
+    pick: &PickMesh,
+    rig_part: &RigPart,
+    rigs: &Query<&RigSkin>,
+    palettes: &RigPalettes,
+    positions: &mut Vec<[f32; 3]>,
+) {
+    let Ok(rig) = rigs.get(rig_part.0) else {
+        return;
+    };
+    let Some(palette) = palettes.world_palette(rig.slot, rig.bones() as usize) else {
+        return;
+    };
+    for (index, position) in pick.0.positions.iter().enumerate() {
+        // A vertex without skinning data still gets an entry, or `positions` shortens against the
+        // index buffer and rewires later triangles. Seat it on the root matrix.
+        let (Some(joints), Some(weights)) = (pick.0.joints.get(index), pick.0.weights.get(index))
+        else {
+            let fallback = palette
+                .get(0)
+                .map(|matrix| matrix.transform_point3(wow_to_bevy(*position)))
+                .unwrap_or(Vec3::ZERO);
+            positions.push(fallback.to_array());
+            continue;
+        };
+        let mut skinned = Vec3::ZERO;
+        for lane in 0..4 {
+            if weights[lane] > 0.0 {
+                if let Some(matrix) = palette.get(joints[lane] as usize) {
+                    skinned += matrix.transform_point3(wow_to_bevy(*position)) * weights[lane];
+                }
+            }
+        }
+        positions.push(skinned.to_array());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        append_triangles, casts_realtime_shadow, clamp_shadow_map_size, shadow_reach_extension,
+        shadow_sun_travel, static_collection_reach, sun_snap_due, RebuildRate,
+        DEFAULT_SHADOW_DISTANCE, DEFAULT_SHADOW_MAP_SIZE, MAX_CASTER_HEIGHT,
+        MAX_SHADOW_SUN_ELEVATION, MIN_SHADOW_SUN_ELEVATION, SHADOW_MAP_SIZES, SHADOW_REACH_CAP,
+        STATIC_REBUILD_STEP, SUN_SNAP_RADIANS,
+    };
+    use benilla_formats::ModelBlend;
+    use benilla_world::model_render::ModelKind;
+    use bevy::prelude::{Quat, Vec3};
+
+    #[test]
+    fn each_lane_admits_only_its_own_kinds() {
+        // The character lane wants creatures (opaque + alpha-test), not environment.
+        assert!(casts_realtime_shadow(ModelKind::Creature, ModelBlend::Opaque, true, false));
+        assert!(casts_realtime_shadow(ModelKind::Creature, ModelBlend::AlphaTest, true, false));
+        assert!(!casts_realtime_shadow(ModelKind::Creature, ModelBlend::Blend, true, false));
+        assert!(!casts_realtime_shadow(ModelKind::Doodad, ModelBlend::Opaque, true, false));
+        // The world lane wants environment (opaque only), not creatures.
+        for kind in [ModelKind::GameObject, ModelKind::Doodad, ModelKind::Wmo] {
+            assert!(casts_realtime_shadow(kind, ModelBlend::Opaque, false, true));
+            assert!(!casts_realtime_shadow(kind, ModelBlend::AlphaTest, false, true));
+        }
+        assert!(!casts_realtime_shadow(ModelKind::Creature, ModelBlend::Opaque, false, true));
+    }
+
+    #[test]
+    fn the_moving_sun_is_clamped_in_elevation_but_keeps_its_bearing() {
+        // A SET sun (to-sun below the horizon) is lifted to the floor; travel still points DOWN.
+        let set = Vec3::new(0.6, -0.5, 0.6).normalize();
+        let t = shadow_sun_travel(set);
+        assert!(t.y < 0.0, "travel points down even for a set sun");
+        assert!(
+            ((-t.y).asin() - MIN_SHADOW_SUN_ELEVATION).abs() < 1e-3,
+            "a set sun is pinned to the floor elevation"
+        );
+        // A near-ZENITH sun is capped so `looking_to(travel, Y)` never degenerates.
+        let high = Vec3::new(0.02, 0.999, 0.02).normalize();
+        assert!(
+            ((-shadow_sun_travel(high).y).asin() - MAX_SHADOW_SUN_ELEVATION).abs() < 1e-2,
+            "a near-zenith sun is capped at the ceiling elevation"
+        );
+        // AZIMUTH preserved: a sun bearing due +X throws its travel toward -X.
+        let east = Vec3::new(1.0, 0.4, 0.0).normalize();
+        let te = shadow_sun_travel(east);
+        assert!(
+            te.x < 0.0 && te.z.abs() < 1e-3,
+            "travel points away from the sun's horizontal bearing"
+        );
+        assert_eq!(shadow_sun_travel(Vec3::ZERO), Vec3::NEG_Z);
+    }
+
+    #[test]
+    fn the_shadow_sun_snaps_on_first_write_holds_under_drift_and_rearms() {
+        let held = Vec3::new(0.3, -0.8, 0.52).normalize();
+        assert!(sun_snap_due(None, held), "first write always fires");
+        let axis = Vec3::Y;
+        let small = Quat::from_axis_angle(axis, SUN_SNAP_RADIANS * 0.5) * held;
+        assert!(!sun_snap_due(Some(held), small), "sub-threshold drift holds");
+        let large = Quat::from_axis_angle(axis, SUN_SNAP_RADIANS * 2.0) * held;
+        assert!(sun_snap_due(Some(held), large), "over-threshold snaps");
+        assert!(!sun_snap_due(Some(large), large), "identical direction never rewrites");
+    }
+
+    #[test]
+    fn shadow_reach_follows_the_sun_and_is_capped() {
+        let diagonal = Vec3::new(1.0, -1.0, 0.0).normalize();
+        assert!((shadow_reach_extension(diagonal) - MAX_CASTER_HEIGHT).abs() < 1e-3);
+        assert_eq!(shadow_reach_extension(Vec3::NEG_Y), 0.0);
+        assert_eq!(shadow_reach_extension(Vec3::NEG_Z), SHADOW_REACH_CAP);
+        assert!(
+            static_collection_reach(Vec3::NEG_Y, DEFAULT_SHADOW_DISTANCE)
+                >= DEFAULT_SHADOW_DISTANCE + STATIC_REBUILD_STEP
+        );
+    }
+
+    #[test]
+    fn an_out_of_range_index_drops_its_whole_triangle_and_no_others() {
+        let mut out = Vec::new();
+        append_triangles(&[0, 1, 2, 1, 2, 9, 2, 0, 1], 3, 10, &mut out);
+        assert_eq!(out, vec![10, 11, 12, 12, 10, 11]);
+    }
+
+    /// MONKEY (sun shadow perf): the rate gate's arithmetic, which is the whole of the two lanes'
+    /// new behaviour. Three properties, each one a way the cap could go wrong in a way you would
+    /// only notice as a stuttering or frozen shadow:
+    /// 1. the FIRST call is always due (a lane with no mesh yet must not wait a frame-interval),
+    /// 2. a due call CONSUMES the slot (otherwise a 30 Hz cap rebuilds every frame forever),
+    /// 3. the interval is measured from the last GRANT, not from the last ask.
+    #[test]
+    fn the_rebuild_gate_paces_from_the_last_grant_and_first_call_is_always_due() {
+        let mut gate = RebuildRate::default();
+        assert!(gate.due(10.0, 30), "first call has nothing to show yet");
+        assert!(!gate.due(10.01, 30), "10 ms later is inside a 33 ms interval");
+        assert!(!gate.due(10.03, 30), "still inside, measured from the grant");
+        assert!(gate.due(10.04, 30), "past 1/30 s — due again");
+        assert!(!gate.due(10.05, 30), "the grant reset the clock");
+        // A reset (the lane tore its caster down) re-arms immediately.
+        gate.reset();
+        assert!(gate.due(10.051, 30));
+    }
+
+    /// `rate == 0` is the documented "every frame" escape hatch, and a backwards clock (a time
+    /// reset) must read as due rather than as a very long wait — a lane frozen until the clock
+    /// catches up would look exactly like a broken shadow.
+    #[test]
+    fn the_rebuild_gate_has_an_every_frame_arm_and_survives_a_clock_reset() {
+        let mut gate = RebuildRate::default();
+        for t in 0..5 {
+            assert!(gate.due(100.0 + t as f32 * 0.001, 0), "rate 0 never gates");
+        }
+        let mut gate = RebuildRate::default();
+        assert!(gate.due(100.0, 15));
+        assert!(!gate.due(100.01, 15));
+        assert!(gate.due(0.0, 15), "a clock that went backwards is due, not stuck");
+    }
+
+    /// The map-size ladder snaps in LOG space, so "halfway" means halfway in ratio (1448 = √2·1024)
+    /// rather than in texels — and every answer is a power of two, because Bevy silently rounds a
+    /// non-power-of-two UP and the user would get a bigger, slower map than the one they typed.
+    #[test]
+    fn the_shadow_map_size_snaps_onto_the_power_of_two_ladder() {
+        assert_eq!(clamp_shadow_map_size(2048), 2048);
+        assert_eq!(clamp_shadow_map_size(1024), 1024);
+        assert_eq!(clamp_shadow_map_size(4096), 4096);
+        assert_eq!(clamp_shadow_map_size(0), 1024, "clamped to the floor");
+        assert_eq!(clamp_shadow_map_size(99_999), 4096, "clamped to the ceiling");
+        assert_eq!(clamp_shadow_map_size(1500), 2048, "1500 is above the 1448 log midpoint");
+        assert_eq!(clamp_shadow_map_size(1400), 1024, "1400 < 1448");
+        assert!(SHADOW_MAP_SIZES.iter().all(|s| s.is_power_of_two()));
+        assert!(SHADOW_MAP_SIZES.contains(&DEFAULT_SHADOW_MAP_SIZE));
+    }
+}
diff --git a/crates/benilla-app/src/torch_shadow.rs b/crates/benilla-app/src/torch_shadow.rs
new file mode 100644
index 00000000..26d8f3d7
--- /dev/null
+++ b/crates/benilla-app/src/torch_shadow.rs
@@ -0,0 +1,1829 @@
+//! MONKEY (torch shadows, Phase 1) — the interior point-light shadow lane, a plug-in on
+//! [`super::shadow_core`], independent of [`super::world_shadow`]/[`super::character_shadow`].
+//!
+//! **Why this is not Bevy's point shadows.** benilla's world camera sets
+//! `bevy::light::cluster::ClusterConfig::None`, which disables Bevy's point/spot clustering AND
+//! starves the point-light shadow-map prep — so `fetch_point_shadow` / `clusterable_objects` are
+//! DEAD here. The old design (promote the nearest fixtures to shadow-casting `PointLight` proxies and
+//! sample their cube maps) could never fire, so it is gone. In its place: this lane picks the
+//! interior fixtures that actually LIGHT the player, computes a down-looking reverse-Z `view_proj` for each, builds the
+//! retained interior caster geometry, and publishes it all as [`TorchShadowViews`] (an
+//! [`ExtractResource`]). The render world then renders a depth map per fixture
+//! (`benilla_world::static_gx::torch_depth`) and `static_gx.wgsl`'s interior surface lane samples
+//! it so a pillar throws a radial shadow.
+//!
+//! **MONKEY (torch caster selection).** Which fixtures get maps used to be "the four nearest the
+//! camera", recomputed and hard-switched every frame. That is the shadow POP: in Northshire Abbey
+//! (42 candelabra, ~5 yd apart) the nearest-four set churns every few steps, and every fixture
+//! outside it lit with no shadow at all, so a fixture's shadow appeared as you walked up to it and
+//! vanished as you moved on. The selection is now (a) ranked by the fixture's own DIRECT
+//! CONTRIBUTION at the player using the shaders' profile ([`fixture_score`]), (b) hysteretic
+//! (a challenger must beat an incumbent by [`TORCH_SWAP_RATIO`], one swap per
+//! [`TORCH_SWAP_COOLDOWN`]), and (c) CROSS-FADED — every slot carries a weight the receivers
+//! `mix` with, so a promotion ramps in and a demotion ramps out before the slot is reused. The
+//! budget is [`MAX_TORCH_CASTERS`] slots, of which `interiorShadowCasters` (default 12) are filled.
+//!
+//! Gated on `interiorLight` + `interiorShadows` ([`VideoConfig`]); declares demand so the shared rig
+//! stays up. Remove this module + its plugin + the `interiorShadows` cvar and the other lanes are
+//! untouched. MONKEY (static torch cache): static_gx and wow_model share the 6416-byte table.
+//! Camera distance must be <= ShadowDistance, AND player distance <= 4R+3. Contribution ranking,
+//! 1.5x hysteresis and fades choose up to twelve of sixteen resident slots; this is still a finite
+//! budget, not a promise that a room with forty eligible candles can give all forty cube maps.
+//! Rigid furniture joins the cached static geometry. Only the nearest interiorShadowDynamic
+//! promoted fixtures (default four, maximum eight, measured from the player) overlay creatures/animated parts.
+//!
+//! MONKEY (torch lane perf): what the lane costs when nothing is happening. Three fixed per-frame
+//! charges were paid regardless of every count dial — which is why `interiorShadowCasters 8` and
+//! `interiorShadowDynamic 2` measured identically to the defaults — and each now has a gate:
+//! the static-cache FINGERPRINT walks one slot a frame instead of four AND skips even that while
+//! the scene census is unchanged ([`TORCH_SCAN_PER_FRAME`], [`PartCensus`]); the moving-caster
+//! gather runs at `interiorShadowEntityRate` Hz (default 30, `0` = every frame) over each dynamic
+//! fixture's OWN reach rather than the cube's 48 yd ([`entity_gather_due`],
+//! [`entity_gather_radius`]); and the receivers skip the table scan where the fixture's direct term
+//! is already nothing (`TORCH_SKIP_EPS`, both shaders). None of it changes what is drawn: the
+//! overlay passes still run every frame from the last mesh, so a lower rate ages a POSE and never
+//! removes a shadow. `WOW_TORCH_TRACE=1` prints the three counters as `torch-perf:` lines.
+
+use std::hash::{Hash, Hasher};
+
+use bevy::math::{DMat4, DVec3, DVec4};
+use bevy::prelude::*;
+use bevy::render::extract_resource::ExtractResourcePlugin;
+
+use bevy::pbr::MeshMaterial3d;
+
+use benilla_assets::materials::WowModelMaterial;
+use benilla_assets::coords::wow_to_bevy;
+use benilla_formats::ModelBlend;
+use benilla_world::billboard::BillboardCard;
+// MONKEY (torch owner exclusion): the placement identity an entity-lane caster part carries, and
+// the model-local bound the containment fallback is decided on.
+use benilla_world::interact::{PickMesh, WorldObject};
+use bevy::camera::primitives::Aabb;
+use benilla_world::lighting::{
+    interior_reach, m2_light_reach, DaylightFixture, DynamicInteriors, FireLightGain, LightLane,
+    LightLitRooms, LightReach, LightRooms, ShadowDistance, ShadowProxyLight, SyntheticFireLight,
+    WorldPointLight, WowLighting,
+};
+// MONKEY (carried light stability): the settle verdict a carried light earns by standing still.
+// MONKEY (outdoor torch shadows): …and the marker that says a light is CARRIED BY A BODY.
+use crate::entities::{CarriedLightMotion, HeldLight};
+use benilla_world::model_render::{ModelKind, ModelPart, ShadowOccluder};
+use benilla_world::rig_palette::{RigPalettes, RigPart, RigSkin};
+use benilla_world::static_gx::{
+    torch_flame_inside_bounds, LightOwner, StaticGx, TorchShadowViews,
+};
+use benilla_world::view::WorldCamera;
+
+use crate::char_select::ClientState;
+use crate::net::SelfPlayer;
+use crate::shadow_core::{
+    empty_shadow_mesh, restore_mesh_buffers, take_mesh_buffers,
+    ShadowDemand, ShadowFrame, ShadowSet,
+};
+use crate::video::VideoConfig;
+
+/// How many interior fixtures can hold a depth map at once — the ALLOCATION. Matches
+/// `torch_depth::MAX_TORCH_MAPS`; the number actually filled is the live `interiorShadowCasters`
+/// cvar (default 12), so raising the cap does not by itself cost a frame.
+const MAX_TORCH_CASTERS: usize = 16;
+/// MONKEY (live bank rank): the cvar and resource consumer share the render allocation's cap.
+pub(crate) const MAX_TORCH_DYNAMIC: usize = TorchShadowViews::MAX_TORCH_DYNAMIC;
+/// MONKEY (torch caster reach): promote out to FOUR times the fixture's effective reach. Its
+/// pool still needs shadows when viewed across the room, long before it lights the player's body.
+const TORCH_ELIGIBLE_REACH_MULT: f32 = 4.0;
+/// MONKEY (static torch cache): minimum coarse CAMERA search; the live search is
+/// max(TORCH_SEARCH_RADIUS, ShadowDistance), so it never truncates the shadow-distance setting.
+const TORCH_SEARCH_RADIUS: f32 = TORCH_ELIGIBLE_REACH_MULT * TORCH_RANGE + TORCH_ELIGIBLE_SLACK;
+/// MONKEY (torch caster reach): extra eligibility slack beyond the expanded 4R window (yd).
+const TORCH_ELIGIBLE_SLACK: f32 = 3.0;
+/// MONKEY (torch caster selection): a challenger must beat the weakest incumbent by this FACTOR
+/// before it may take its slot. Pure "best N" thrashes: two candles a step apart trade the lead
+/// every few frames as you walk between them, and each trade used to be an instant on/off. 1.5 is
+/// wide enough that a real change of room wins immediately and a step sideways never does.
+const TORCH_SWAP_RATIO: f32 = 1.5;
+/// MONKEY (torch caster selection): and at most ONE contested swap this often (s). The ratio alone
+/// still permits a cascade — six slots could each lose their contest in the same frame, which is
+/// six shadows changing at once no matter how smooth each fade is.
+const TORCH_SWAP_COOLDOWN: f64 = 0.25;
+/// MONKEY (torch caster selection): the cross-fade rate (weight per second) — ~1/3 s to ramp a
+/// shadow fully in or out. Slow enough to read as "the light reaches you now", fast enough that
+/// the geometry is not visibly shadow-less while you stand in front of it.
+const TORCH_FADE_RATE: f32 = 3.0;
+/// MONKEY (torch caster selection): the interior direct-light profile, MIRRORED from the
+/// `interior_room_light` block that both `static_gx.wgsl` and `wow_model.wgsl` carry ("MONKEY (soft
+/// falloff)" — keep the three in sync). Ranking by the shader's OWN contribution is the whole point
+/// of this change: distance ranked a bright forge behind you below a dead candle at your feet.
+const INTERIOR_CORE_FRAC: f32 = 0.26;
+const INTERIOR_CORE_GAIN: f32 = 1.5;
+const INTERIOR_DIRECT_POW: f32 = 10.0;
+/// MONKEY (torch caster reach): unchanged fixture-centred far plane. `interior_reach` caps R at
+/// 48 yd; seeing that pool from 4R away needs earlier promotion, not a longer projection.
+const TORCH_RANGE: f32 = 48.0;
+/// MONKEY (Phase 5): six cube faces per fixture. Keep in sync with `torch_depth::CUBE_FACES`.
+const CUBE_FACES: usize = 6;
+/// MONKEY (static torch cache): how many resident slots have their source FINGERPRINT recomputed
+/// per frame. Hashing one fixture's 48 yd source set walks every resident `GxItem` and every model
+/// part; doing that for all twelve residents every frame hands the CPU back the cost the GPU cache
+/// just saved (~12 full scene scans per frame, and it is a per-frame cost even in a room where
+/// nothing ever changes).
+///
+/// MONKEY (torch lane perf): ONE, not four. Four was already the "don't scan them all" compromise,
+/// but it is still four full walks of the resident static scene AND of every model part, every
+/// frame, forever — measured as the bulk of the ~3 ms the whole lane costs at the Lion's Pride Inn,
+/// which is exactly why neither `interiorShadowCasters` nor `interiorShadowDynamic` moved the frame
+/// time: the cost was never per map. One slot a frame is a 12-frame (~0.26 s) sweep of a full
+/// resident set, which is the same order as the cross-fade a newly promoted slot ramps in over, so
+/// nothing the eye can catch waits on it. Two further things keep that honest: a slot that has
+/// never been fingerprinted JUMPS the queue (see `scan_start`), so a promotion still builds at
+/// once, and the walk itself is skipped whenever neither the retained scene nor the entity-part
+/// census has changed since that slot last looked ([`PartCensus`]).
+const TORCH_SCAN_PER_FRAME: usize = 1;
+/// MONKEY (torch lane perf): slack (yd) added to a fixture's own reach when gathering MOVING
+/// casters for it. The receivers' direct term is `interior_window(d, reach, ..)`, which is exactly
+/// zero at `d >= reach`, so a caster further than `reach` from the fixture can only shadow
+/// fragments the fixture does not light — it is invisible by construction. The margin covers the
+/// part's own extent, because the admission test is on the part's ORIGIN and a body is a couple of
+/// yards tall: without it a unit standing just inside the pool with its origin just outside would
+/// lose its shadow. (The STATIC gather is untouched at the full [`TORCH_RANGE`]: it is cached, so
+/// its radius is not a per-frame cost, and shrinking it would invalidate every cached map.)
+const TORCH_ENTITY_REACH_MARGIN: f32 = 4.0;
+/// MONKEY (static torch cache): how far (yd²) a fixture may drift from the position its cached map
+/// was rendered at before that map is WITHDRAWN. A cached map that is merely STALE (the room
+/// streamed a chair in since it was baked) keeps being published — the shadow is a few frames out
+/// of date, which is invisible. A map whose fixture MOVED is not stale but WRONG: every projection
+/// in it aims from somewhere else, and the published `view_projs` (rebuilt from the live position
+/// each frame) no longer address it. Withdrawing a merely-stale map instead was a hard on/off
+/// blink: an unready slot's `positions[i].w` is forced to 0 with no fade — precisely the pop the
+/// whole cross-fade exists to prevent — for however many frames the rebuild budget takes to reach it.
+const TORCH_STALE_DRIFT_SQ: f32 = 0.01;
+/// MONKEY (outdoor torch shadows): how far from the PLAYER an exterior fire may still be promoted
+/// (yd). The interior lane's `4R + slack` window has no meaning out here — an exterior entry packs
+/// no reach at all (`lane == 0`, the colour row's reach lane is the interior half's), and the
+/// receivers apply the un-windowed `1/(0.7d + 0.03d²)` to it. So the window is the CUBE MAP's own
+/// range: past [`TORCH_RANGE`] a fixture's whole shadow volume is outside the projection anyway,
+/// and the world fade in the shaders has already ended by then.
+const TORCH_EXT_ELIGIBLE_YD: f32 = TORCH_RANGE;
+/// MONKEY (moving fixture): how many slots may be FULLY DYNAMIC in one frame — rebuilt from
+/// scratch (static geometry AND entities, into their live layers) because their fixture is
+/// physically moving. Shared with the render plan, which keeps a matching separate rebuild budget.
+const TORCH_MOVING_MAX: usize = TorchShadowViews::MAX_TORCH_MOVING;
+/// MONKEY (moving fixture): how long a fixture must hold still before it is treated as SETTLED and
+/// handed back to the cached path. Long enough to cover a walk cycle's pauses and a pet's
+/// stop-turn-start, short enough that a brazier dropped on the ground is cached within a second.
+const TORCH_MOVING_SETTLE: f64 = 0.75;
+/// MONKEY (moving fixture): how far (yd²) a fixture must shift between two frames to count as
+/// having MOVED at all. A hand-held flame on an idling NPC jitters by millimetres with the breathe
+/// animation; at 60 fps this threshold is ~1.2 yd/s, so an idle never registers and a walk always
+/// does. It is deliberately NOT [`TORCH_STALE_DRIFT_SQ`]: that one asks "is the cached map still
+/// valid" (a question about the map), this one asks "is the fixture in motion" (a question about
+/// the fixture), and a fixture creeping 0.09 yd a frame would answer the first "yes, forever".
+const TORCH_MOVING_EPS_SQ: f32 = 0.0004;
+/// MONKEY (moving fixture): the fade rate (weight per second) for a moving slot that could NOT get
+/// the moving budget — 0.15 s to nothing, five times the normal [`TORCH_FADE_RATE`]. The normal
+/// rate exists to keep a *correct* shadow on screen while it dissolves; this one is for a shadow
+/// that is already wrong (its map is frozen at a position the light has left), so the only good
+/// answer is to get rid of it faster than the eye tracks it, and the fade is there purely so it
+/// dissolves instead of blinking.
+const TORCH_MOVING_FADE_RATE: f32 = 1.0 / 0.15;
+/// MONKEY (torch owner exclusion): how far up the `ChildOf` chain a caster part is followed while
+/// asking "is this the host model of the light that is lighting me?" — the entity-lane half of the
+/// owner test ([`benilla_world::static_gx::LightOwner::Instance`]). A part's chain to its model
+/// frame is `part → (joint → …) → frame`, and a rig's joint chain is the deep part; 64 clears every
+/// shipped skeleton (it is `carried_light`'s own `ANCHOR_WALK_DEPTH`, for the same hierarchy) and
+/// the cap is there so a malformed cycle can never hang the frame.
+const OWNER_WALK_DEPTH: usize = 64;
+/// Each cube face's FOV: 90° plus a hair, so a direction exactly on a face border still lands
+/// inside the face the shader picks for it (the projector returns "lit" outside its frustum).
+const TORCH_FACE_FOV: f32 = std::f32::consts::FRAC_PI_2 + 0.02;
+
+pub(crate) struct TorchShadowPlugin;
+
+impl Plugin for TorchShadowPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<TorchLane>()
+            .init_resource::<TorchShadowViews>()
+            // The render world reads the published fixtures/caster through this.
+            .add_plugins(ExtractResourcePlugin::<TorchShadowViews>::default())
+            .add_systems(Last, update_torch_shadows.in_set(ShadowSet::Lanes));
+    }
+}
+
+/// MONKEY (torch caster selection): one OCCUPIED caster slot — a fixture that holds (or is
+/// releasing) six depth-map layers. Slots are retained across frames, which is what makes
+/// hysteresis and cross-fading possible at all: the old lane recomputed "the nearest four" from
+/// scratch every frame and so had no notion of an incumbent to keep.
+struct TorchSlot {
+    // MONKEY (static torch cache): physical residency survives Vec compaction and rank changes.
+    cache_slot: usize,
+    mesh: Option<Handle<Mesh>>,
+    geometry_key: Option<u64>,
+    /// MONKEY (static torch cache): the fixture position `mesh` was actually gathered AT, which is
+    /// not necessarily `pos` — the cursor scans only [`TORCH_SCAN_PER_FRAME`] slots a frame, so a
+    /// slot can be published several frames after it last rebuilt. `None` until the first build.
+    /// See [`TORCH_STALE_DRIFT_SQ`] for why staleness publishes and drift does not.
+    built_at: Option<Vec3>,
+    /// The fixture entity — the identity the slot is held BY. Matching on entity rather than on
+    /// position is what lets a CARRIED torch (which moves every frame) keep its slot.
+    fixture: Entity,
+    /// Its world position this frame (absolute Bevy), the shader's correlation key.
+    pos: Vec3,
+    /// Its contribution score at the player this frame (see [`fixture_score`]).
+    score: f32,
+    /// MONKEY (torch lane perf): the fixture's EFFECTIVE reach in yards — the same `R` the light
+    /// packer writes into the receivers' colour row and the same one [`fixture_score`] ranks with.
+    /// Carried on the slot so the moving-caster gather can be sized off the light that will
+    /// actually be sampled, instead of the cube projection's flat 48 yd far plane. Exterior slots
+    /// hold [`TORCH_RANGE`]: an exterior entry packs no reach, and its receivers apply an
+    /// un-windowed falloff, so there is no smaller honest number out there.
+    reach: f32,
+    /// MONKEY (torch lane perf): the `(retained-scene generation, static-part census, position)`
+    /// this slot last FINGERPRINTED at. While all three are unchanged the source set cannot have
+    /// changed either, so the expensive walk (every resident `GxItem` in 48 yd, then every model
+    /// part) is skipped outright. `None` = never fingerprinted, which also jumps the scan queue.
+    checked: Option<(u64, u64, Vec3)>,
+    /// MONKEY (outdoor torch shadows): which LANE promoted it. Drives the exterior half of the
+    /// budget split, the emitter-owner exclusion radius its caster gather uses, and the published
+    /// `exterior` bit the receivers gate on. A slot never changes lane: a fixture is interior or
+    /// exterior by where it physically stands ([`LightLane`]), and if that verdict ever flipped the
+    /// fixture would leave `cands` and be cross-faded out like any other loss.
+    exterior: bool,
+    /// MONKEY (torch owner exclusion): WHO this fixture is part of — the identity its caster
+    /// gathers drop out of its own map, so the lamp never shadows itself. `None` for a fixture
+    /// that carries no owner tag (an authored WMO MOLT fixture, which has no model at all, and any
+    /// light source predating the tag); those fall back to the containment rule alone.
+    owner: Option<LightOwner>,
+    /// MONKEY (torch owner exclusion): how many items the LAST rebuild of this slot dropped as its
+    /// own body — `WOW_TORCH_TRACE` only. Held on the slot rather than in a per-frame counter
+    /// because the gather is cached: the answer is "at the last rebuild", not "this frame".
+    trace_excluded: (u32, u32),
+    /// MONKEY (moving fixture): where the fixture stood LAST frame, and the last time it was seen
+    /// to move further than [`TORCH_MOVING_EPS_SQ`]. `still_since` starts "long ago" (0.0) so a
+    /// freshly promoted slot takes the ordinary cached path on its first frame and only becomes a
+    /// moving slot once it has actually been observed moving — a placed brazier or a standing NPC's
+    /// torch must never spend its first three quarters of a second on the moving budget.
+    last_pos: Vec3,
+    still_since: f64,
+    /// MONKEY (moving fixture): this slot holds one of the [`TORCH_MOVING_MAX`] live rebuild
+    /// budgets this frame — its caster mesh is regathered and its six faces re-rendered EVERY
+    /// frame, from the live fixture position, with the moving entities overlaid.
+    moving_live: bool,
+    /// MONKEY (moving fixture): …and this one is moving but did NOT get a budget, so it is being
+    /// dropped at [`TORCH_MOVING_FADE_RATE`] rather than kept as a stale map.
+    fast_fade: bool,
+    /// The cross-fade weight, published as `positions[i].w` and applied as `mix(1, shadow, w)` by
+    /// both receivers.
+    w: f32,
+    /// Set once the slot has lost its contest (or its fixture went out of reach, or the budget
+    /// shrank). It keeps rendering while `w` ramps down, and the slot is freed for a challenger
+    /// only when `w` reaches 0 — "fade, not switch".
+    evicting: bool,
+}
+
+impl TorchSlot {
+    /// MONKEY (moving fixture): has the fixture left the position its cached map was baked from?
+    /// This is [`map_publishable`]'s complement with one extra condition — a slot that has NEVER
+    /// built is not "drifted", it is simply new, and belongs to the promotion path rather than to
+    /// the moving budget.
+    fn drifted(&self) -> bool {
+        self.built_at
+            .is_some_and(|p| p.distance_squared(self.pos) > TORCH_STALE_DRIFT_SQ)
+    }
+
+    /// MONKEY (moving fixture): is this fixture MOVING right now, i.e. does it need its whole cube
+    /// re-rendered this frame instead of its cached one republished?
+    ///
+    /// Two halves, and both are needed. WHO it is: an entity-hosted light ([`LightOwner::Instance`]
+    /// — `entities::carried_light`'s pet flames, NPC torches, GameObject braziers) is the only kind
+    /// that CAN move, and a fixture that has already drifted off its baked map is proof of motion
+    /// whoever owns it. WHETHER it is moving NOW: a placed campfire is `Instance`-owned and never
+    /// moves, so the owner alone would put every brazier in a village on the moving budget forever.
+    /// `still_since` is stamped by the per-frame motion test and the fixture is handed back to the
+    /// cache [`TORCH_MOVING_SETTLE`] after it stops.
+    fn moving(&self, now: f64) -> bool {
+        (matches!(self.owner, Some(LightOwner::Instance(_))) || self.drifted())
+            && now - self.still_since < TORCH_MOVING_SETTLE
+    }
+}
+
+/// MONKEY (static torch cache): stable physical slots and per-fixture source meshes.
+/// Camera drift never rebuilds static geometry; only a source-set/fixture change does.
+#[derive(Resource, Default)]
+struct TorchLane {
+    // MONKEY (static torch cache): only moving casters are rebuilt every frame. Each slot owns
+    // its own static geometry handle; a replacement gets a NEW asset id, so the render world
+    // cannot certify an old GPU mesh as the newly streamed geometry while uploads catch up.
+    entity_mesh: Option<Handle<Mesh>>,
+    rebuild_cursor: usize,
+    /// MONKEY (torch caster selection): the occupied slots, at most `interiorShadowCasters` of them
+    /// (plus any still fading out after the budget shrank). Published in this order.
+    slots: Vec<TorchSlot>,
+    /// When the last CONTESTED swap was started (seconds of `Time::elapsed`), for the cooldown.
+    last_swap: f64,
+    /// MONKEY (torch lane perf): when the moving-caster mesh was last REGATHERED, and for which
+    /// dynamic set. The mesh is retained between regathers — the six overlay passes still run every
+    /// frame from it — so this is a staleness dial on the POSE, never an on/off for the shadow.
+    /// The mask rides along because a gather is only valid for the fixtures it was gathered
+    /// around: when the dynamic set changes the cadence is overridden and the mesh rebuilt at once.
+    entity_at: f64,
+    entity_mask: u32,
+    /// MONKEY (torch lane perf): `WOW_TORCH_TRACE` accounting for the second in progress — how many
+    /// fingerprint walks actually ran, how many regathers, and the last gather's admitted-part
+    /// count and radius. Counters, not timings: they are what tells the user whether a cadence or
+    /// a gate is doing anything at all.
+    trace_scans: u32,
+    trace_gathers: u32,
+    trace_parts: u32,
+    trace_reach: f32,
+}
+
+/// MONKEY (torch lane perf): the per-frame "has anything a fingerprint would hash MOVED?" summary,
+/// computed ONCE for the whole lane instead of once per scanned slot.
+///
+/// The fingerprint it guards is order-independent and covers (a) the retained static scene and (b)
+/// every rigid opaque model part. This pair reproduces both halves cheaply: `gx` folds the retained
+/// regions' own change stamps and populations (O(regions), not O(items) — see
+/// `StaticGx::torch_residency_generation`), and `parts` folds one branch-free mix per part over its
+/// entity id, its geometry `Arc` identity, its translation AND one basis column, so an arrival, a
+/// despawn, a geometry swap, a move and a rotation each change it. It is deliberately NOT a
+/// substitute for the fingerprint — it is scene-wide where the fingerprint is fixture-local, so it
+/// can only ever say "nothing changed anywhere, don't bother looking".
+#[derive(Clone, Copy, PartialEq, Eq, Default)]
+struct PartCensus {
+    gx: u64,
+    parts: u64,
+}
+
+/// MONKEY (torch caster selection): the interior direct term this fixture delivers at distance `d`
+/// — the shaders' own profile (core inverse-square with a soft core, times the C1 window), times
+/// the fixture's luminous intensity. This is the ranking key, and it is the answer to the bug: at
+/// Northshire's candelabra spacing "nearest 4" and "the 4 that light you" are different sets, and
+/// only the second one is stable as you walk, because a fixture's contribution changes smoothly
+/// with distance while its RANK by distance changes in steps.
+///
+/// MONKEY (torch caster selection): one scored candidate — `(fixture, position, score, exterior,
+/// reach, owner)`. Named because MONKEY (torch lane perf) added the trailing REACH lane, and a
+/// `(.., x)` pattern over a bare tuple would silently have re-bound to it. MONKEY (torch owner
+/// exclusion) added the OWNER lane for the same reason it rides the slot.
+type Candidate = (Entity, Vec3, f32, bool, f32, Option<LightOwner>);
+
+/// MONKEY (torch owner exclusion): one fixture in a caster gather — `(slot, position, admission
+/// radius, owner)`. The owner rides the gather because the exclusion is per FIXTURE, not per lane:
+/// the static gather runs for one slot at a time and is therefore exact, and the shared moving
+/// gather (one mesh for the whole dynamic set) excludes a part owned by ANY of its fixtures, which
+/// is the only thing one mesh can express.
+type GatherFixture = (usize, Vec3, f32, Option<LightOwner>);
+
+/// MONKEY (torch caster reach): retain the intensity and soft inverse-square core at the player's
+/// distance, but stretch the selection window to 4R (including eligibility slack). This is a
+/// ranking extension, not a lighting change: at 3R the score is small, positive and still falling.
+/// No window floor flattens distant candidates; the window reaches zero at the eligibility edge.
+fn fixture_score(intensity: f32, d: f32, r: f32) -> f32 {
+    let r0 = (INTERIOR_CORE_FRAC * r).max(1e-3);
+    let atten = INTERIOR_CORE_GAIN / (1.0 + (d / r0) * (d / r0));
+    let extent = TORCH_ELIGIBLE_REACH_MULT * r + TORCH_ELIGIBLE_SLACK;
+    let w = (1.0 - (d / extent.max(1e-4)).clamp(0.0, 1.0).powf(INTERIOR_DIRECT_POW)).clamp(0.0, 1.0);
+    intensity * atten * w * w
+}
+
+/// MONKEY (review fixes): rank only light the interior receivers actually sample. Match the
+/// packer's unresolved-lane fallback AND its synthetic-only gain; a disabled flame or a resolved
+/// exterior fixture must score zero before it can evict a useful caster. Reach still uses the
+/// authored intensity, so dimming a flame changes its contribution without moving its pool.
+fn candidate_score(
+    intensity: f32, d: f32, r: f32, lane: Option<&LightLane>, has_rooms: bool,
+    synthetic: bool, fire_gain: f32,
+) -> f32 {
+    if !lane.map_or(has_rooms, |l| l.interior) {
+        return 0.0;
+    }
+    fixture_score(intensity, d, r) * if synthetic { fire_gain.max(0.0) } else { 1.0 }
+}
+
+/// MONKEY (outdoor torch shadows): the EXTERIOR direct term this fixture delivers at distance `d`
+/// — the exterior receivers' OWN profile (`point_light_sum` / `wmo_exterior_point_sum`:
+/// `1/(0.7d + 0.03d²)`, no soft core, no authored window), times the fixture's luminous intensity.
+/// A separate function rather than a flag on [`fixture_score`] because the two lanes genuinely
+/// light differently, and the whole point of scoring by CONTRIBUTION is that the ranking key is the
+/// number the receiver will actually compute.
+///
+/// `d` is floored at 1 yd for the ATTENUATION only: the exterior falloff has a pole at 0 and the
+/// receivers live with it (no surface is ever at the light), but a ranking key that goes to
+/// infinity would let a fixture the player is standing on outrank the entire village for one frame
+/// and then hand the slot back. The window is unfloored and reaches zero at the eligibility edge,
+/// so a candidate's score falls off smoothly instead of stepping to 0 the frame it drops out.
+fn exterior_fixture_score(intensity: f32, d: f32) -> f32 {
+    let dd = d.max(1.0);
+    let atten = 1.0 / (0.7 * dd + 0.03 * dd * dd);
+    // `INTERIOR_DIRECT_POW` only for the WINDOW's shape — the C1 shoulder that takes a candidate's
+    // score to exactly zero at the edge instead of stepping it there. It is the interior lane's
+    // constant because it is the same shoulder, not because this is an interior term; the
+    // attenuation above is the exterior receivers' own and shares nothing with that lane.
+    let w = (1.0 - (d / TORCH_EXT_ELIGIBLE_YD).clamp(0.0, 1.0).powf(INTERIOR_DIRECT_POW))
+        .clamp(0.0, 1.0);
+    intensity * atten * w * w
+}
+
+/// MONKEY (outdoor torch shadows): may an EXTERIOR fire be promoted at all? Same two camera tests
+/// as [`fixture_eligible`] (it is the same cube-map budget and the same `shadowDistance` dial);
+/// the player-distance window is the flat [`TORCH_EXT_ELIGIBLE_YD`] instead of `4R + slack`,
+/// because an exterior entry has no packed reach to take four of.
+fn exterior_eligible(player_d: f32, camera_d: f32, distance: f32) -> bool {
+    camera_d <= TORCH_SEARCH_RADIUS.max(distance)
+        && camera_d <= distance
+        && player_d <= TORCH_EXT_ELIGIBLE_YD
+}
+
+/// MONKEY (outdoor torch shadows): how many of the `interiorShadowCasters` resident slots an
+/// exterior fire may take. HALF, rounded up: a village square at night can easily author more
+/// campfires than the whole budget, and without a cap the first night in Goldshire would evict
+/// every indoor candle in the inn a step away — the interior lane's look is shipped and tuned, and
+/// this feature must not be able to take it away. Rounded UP so the smallest budgets
+/// (`interiorShadowCasters 1`) still get one outdoor shadow rather than none.
+fn exterior_budget(want: usize) -> usize {
+    want.div_ceil(2)
+}
+
+/// MONKEY (outdoor torch shadows): apply the budget split, by TRUNCATING the sorted candidate list
+/// rather than by teaching the slot machinery about lanes. Everything downstream — the incumbent
+/// refresh, the fade-out, the promotion, the contested swap — reads `cands`, so dropping the
+/// exterior tail here means an exterior incumbent that falls past the cap cross-fades out exactly
+/// like a fixture that walked away ("fade, not switch" holds for this eviction too), and no
+/// exterior fixture can ever be promoted into slot `cap + 1`. Interior candidates are untouched:
+/// the cap is a ceiling on the outdoor lane, never a floor under it, so a night indoors still fills
+/// all twelve slots with candles.
+///
+/// `cands` must already be sorted best-first — the survivors are then the BEST `cap` exterior
+/// fires, which is the same ranking rule the whole lane runs on.
+fn cap_exterior_candidates(cands: &mut Vec<Candidate>, cap: usize) {
+    let mut seen = 0usize;
+    cands.retain(|(_, _, _, exterior, ..)| {
+        if !*exterior {
+            return true;
+        }
+        seen += 1;
+        seen <= cap
+    });
+}
+
+/// MONKEY (outdoor torch shadows): the realtime-shadow day strength — a three-line mirror of
+/// `benilla_world::lighting::global_light`'s private `sun_shadow_strength` (`blob_shadow.rs` keeps
+/// the same mirror, for the same reason: it is three lines and a `pub` on it would be a wider API
+/// than the number deserves). **Exactly 1.0 above ~12° of sun elevation**, which is what makes
+/// `night_w = 1 - this` exactly 0 by day in the receivers — the daylight-is-untouched guarantee.
+fn sun_shadow_strength(sun_height: f32) -> f32 {
+    let t = (sun_height / 0.208).clamp(0.0, 1.0);
+    t * t * (3.0 - 2.0 * t)
+}
+
+/// MONKEY (static torch cache): camera distance uses the world-shadow resource's Bevy-yard
+/// yardstick. The player-centred 4R+3 window still limits/ranks useful pools; BOTH tests apply.
+/// The coarse camera search grows with shadowDistance so it can never silently shorten that dial.
+fn fixture_eligible(player_d: f32, camera_d: f32, r: f32, distance: f32) -> bool {
+    camera_d <= TORCH_SEARCH_RADIUS.max(distance)
+        && camera_d <= distance
+        && player_d <= TORCH_ELIGIBLE_REACH_MULT * r + TORCH_ELIGIBLE_SLACK
+}
+
+/// MONKEY (static torch cache): may a slot publish its cached map this frame? Yes while the
+/// fixture still stands where the map was baked from (see [`TORCH_STALE_DRIFT_SQ`]) — staleness in
+/// the SURROUNDINGS is invisible for the few frames a rebuild takes, whereas withdrawing the map
+/// zeroes the slot's weight with no fade. No when the fixture has moved: the six projections are
+/// republished from the live position every frame and would no longer address that depth.
+fn map_publishable(built_at: Option<Vec3>, pos: Vec3) -> bool {
+    built_at.is_some_and(|p| p.distance_squared(pos) <= TORCH_STALE_DRIFT_SQ)
+}
+
+/// MONKEY (moving fixture): split this frame's scored movers into the [`TORCH_MOVING_MAX`] that get
+/// a live rebuild and the rest, which are dropped (fast-faded) rather than kept as frozen maps.
+///
+/// Ranked by the SAME contribution score the whole lane ranks by, so the budget goes to the mover
+/// whose shadow the player can actually see, and tied scores fall back to slot order so the answer
+/// is deterministic frame to frame — a budget that alternated between two equally-scored pets would
+/// fast-fade each of them in turn, which is the churn the whole selection machinery exists to avoid.
+fn moving_budget(mut movers: Vec<(usize, f32)>) -> (Vec<usize>, Vec<usize>) {
+    movers.sort_by(|a, b| b.1.total_cmp(&a.1).then(a.0.cmp(&b.0)));
+    (
+        movers.iter().take(TORCH_MOVING_MAX).map(|(i, _)| *i).collect(),
+        movers.iter().skip(TORCH_MOVING_MAX).map(|(i, _)| *i).collect(),
+    )
+}
+
+/// MONKEY (static torch cache): the nearest promoted fixtures to the player receive entities.
+/// Stable physical-slot tie breaking keeps coincident/equidistant candles deterministic; this
+/// subset is independent of contribution ranking and never moves the resident static maps.
+fn dynamic_set(fixtures: &[(usize, Vec3)], anchor: Vec3, budget: usize) -> u32 {
+    let mut nearest = fixtures.to_vec();
+    nearest.sort_by(|a, b| a.1.distance_squared(anchor).total_cmp(&b.1.distance_squared(anchor))
+        .then(a.0.cmp(&b.0)));
+    // MONKEY (live bank rank): also clamp resource values that bypass the cvar setter.
+    nearest.iter().take(budget.clamp(1, MAX_TORCH_DYNAMIC)).fold(0, |mask, (i, _)| mask | (1 << i))
+}
+
+/// MONKEY (torch lane perf): the radius the MOVING-caster gather admits parts inside, for a
+/// fixture of effective reach `reach`. See [`TORCH_ENTITY_REACH_MARGIN`] for why `reach + margin`
+/// is the honest bound and not a tightening of the effect; clamped to [`TORCH_RANGE`] because
+/// nothing outside the cube projection can be recorded anyway.
+fn entity_gather_radius(reach: f32) -> f32 {
+    if !reach.is_finite() {
+        return TORCH_RANGE;
+    }
+    (reach + TORCH_ENTITY_REACH_MARGIN).clamp(TORCH_ENTITY_REACH_MARGIN, TORCH_RANGE)
+}
+
+/// MONKEY (torch lane perf): is `origin` inside ANY of the gather's fixtures' own radii — the
+/// UNION that replaced "48 yd of every dynamic fixture". Split out as a pure function because it is
+/// the whole admission rule of the gather and the one part of it worth a test.
+fn within_any_reach(fixtures: &[GatherFixture], origin: Vec3) -> bool {
+    fixtures.iter().any(|(_, p, r, _)| p.distance_squared(origin) <= r * r)
+}
+
+/// MONKEY (torch owner exclusion): is this entity-lane caster part the fixture's OWN body?
+///
+/// The entity half of `static_gx`'s `torch_item_is_emitter`, and deliberately the same two rules in
+/// the same order — a part must not cast or not cast depending on which lane happens to be drawing
+/// its placement that frame:
+///
+///  1. OWNERSHIP. A placed light names its placement by content ([`LightOwner::Placement`]), and
+///     the entity path's parts carry a CLONE of that identity, so a doodad still in its feather
+///     band (or one the retained lane never took) is excluded exactly as its retained twin is. A
+///     carried light names its host model FRAME instead ([`LightOwner::Instance`] — a GameObject
+///     brazier, an NPC's torch have no placement identity at all), and a part is its body iff it
+///     hangs under that frame.
+///  2. CONTAINMENT of the flame in the part's own bound, shared verbatim with the retained lane
+///     ([`torch_flame_inside_bounds`], including the fixture-size cap that stops a room-sized batch
+///     from claiming every candle in it).
+///
+/// Excluded if ANY fixture of the gather owns it: the moving gather feeds ONE mesh to up to eight
+/// fixtures, so per-fixture exclusion is not representable there. The cost is that a self-lit
+/// creature stops casting for the other fixtures of the same dynamic set — a shadow that is at
+/// worst missing, against a self-shadow artefact that is always visible.
+///
+/// **Rule 2 never applies to a CREATURE.** A body standing against a wall torch has that torch's
+/// flame inside its own bounding box perfectly often, and a player who walks up to a brazier and
+/// loses their shadow is a worse bug than the one this function exists to fix. A creature that
+/// really does carry its own light (an imp's hand fire, a fire elemental, a torch-bearing guard)
+/// is covered by rule 1 instead, which is exact — `entities::carried_light` tags every one of
+/// those lights with the frame it hangs under.
+fn part_is_own_body(
+    ents: &EntityCasters, fixtures: &[GatherFixture], entity: Entity, kind: ModelKind,
+    object: Option<&WorldObject>, global: Option<&GlobalTransform>, aabb: Option<&Aabb>,
+) -> bool {
+    let bound = (kind != ModelKind::Creature).then_some(()).and(global.zip(aabb));
+    fixtures.iter().any(|(_, pos, _, owner)| {
+        let owned = match owner.map(|o| (o, o.instance())) {
+            Some((_, Some(frame))) => hangs_under(ents, entity, frame),
+            Some((o, None)) => object.is_some_and(|obj| o.owns(obj)),
+            None => false,
+        };
+        owned
+            || bound.is_some_and(|(g, b)| {
+                torch_flame_inside_bounds(g.affine(), b.center.into(), b.half_extents.into(), *pos)
+            })
+    })
+}
+
+/// MONKEY (torch owner exclusion): is `entity` `frame`, or a descendant of it? See
+/// [`OWNER_WALK_DEPTH`] for the cap.
+fn hangs_under(ents: &EntityCasters, entity: Entity, frame: Entity) -> bool {
+    let mut at = entity;
+    for _ in 0..OWNER_WALK_DEPTH {
+        if at == frame {
+            return true;
+        }
+        let Ok(parent) = ents.parents.get(at) else { return false };
+        at = parent.parent();
+    }
+    false
+}
+
+/// MONKEY (torch lane perf): is a REGATHER of the moving-caster mesh due this frame?
+///
+/// `rate == 0` is the pre-feature every-frame behaviour, kept as the live A/B. A changed dynamic
+/// SET always forces one — the mesh is only valid for the fixtures it was gathered around, and
+/// keeping a stale one there would put a shadow in a room the overlay no longer serves. `elapsed`
+/// is compared against `1/rate` with a small tolerance so a 30 Hz cadence on a 60 fps frame lands
+/// on every other frame rather than alternating 1 and 3 frames as the two clocks beat.
+fn entity_gather_due(rate: u32, elapsed: f64, mask: u32, last_mask: u32) -> bool {
+    rate == 0 || mask != last_mask || elapsed >= 1.0 / f64::from(rate) - 1e-4
+}
+
+/// MONKEY (torch caster selection): the entity-caster query trio, bundled as ONE `SystemParam`.
+/// Not tidiness — [`update_torch_shadows`] sat at 15 of Bevy's 16 system params before this change
+/// added the player anchor and the interior knobs, and three separate members would not compile.
+#[derive(bevy::ecs::system::SystemParam)]
+struct EntityCasters<'w, 's> {
+    /// The SAME query the world lane passes to `collect_entity_geometry` (written inline by that
+    /// contract so a lane can pass its own).
+    parts: Query<
+        'w,
+        's,
+        (
+            Entity,
+            &'static PickMesh,
+            &'static ModelPart,
+            Option<&'static GlobalTransform>,
+            Option<&'static RigPart>,
+            &'static ShadowOccluder,
+            Option<&'static MeshMaterial3d<WowModelMaterial>>,
+            // MONKEY (torch owner exclusion): the placement identity the entity lane carries (a
+            // CLONE of the retained lane's `Arc`, which is why the owner key compares by content),
+            // and the model-local bound the containment fallback needs. Both `Option`: a part that
+            // has neither is simply never excluded, which is the safe failure direction.
+            Option<&'static WorldObject>,
+            Option<&'static Aabb>,
+        ),
+        Without<BillboardCard>,
+    >,
+    /// MONKEY (torch owner exclusion): the hierarchy walk for a CARRIED light's owner — a brazier
+    /// GameObject's light names its model frame, and its own meshes are that frame's descendants.
+    parents: Query<'w, 's, &'static ChildOf>,
+    rigs: Query<'w, 's, &'static RigSkin>,
+    palettes: Res<'w, RigPalettes>,
+    distance: Res<'w, ShadowDistance>,
+    /// MONKEY (outdoor torch shadows): the live celestial sun, for the night gate. It rides THIS
+    /// bundle rather than being a 17th system param because `update_torch_shadows` already sits at
+    /// Bevy's 16-param ceiling — the same reason `distance` is here.
+    lighting: Res<'w, WowLighting>,
+}
+
+/// The INTERIOR lane is active when the dynamic-interior lane is on AND its shadow toggle is on.
+fn interior_shadows_on(video: &VideoConfig) -> bool {
+    video.interior_light && video.interior_shadows
+}
+
+/// MONKEY (outdoor torch shadows): the EXTERIOR lane's gate — its own cvar AND night.
+///
+/// Deliberately independent of `interiorLight`: the exterior receivers (`wmo_exterior_point_sum`
+/// on a WMO's outdoor-class surfaces, `point_light_sum` on doodads/entities) have never been part
+/// of the dynamic-interior feature and are drawn with `interiorLight 0` exactly as with it, so
+/// tying their shadows to that dial would be surprising in both directions.
+///
+/// Night is a HARD gate, not a fade to zero, because it is what buys the "daytime is bit-identical"
+/// claim on the CPU side as well as in the shaders: with the sun up there are no exterior
+/// candidates, so no exterior slot, so no exterior caster mesh, no depth render, and the published
+/// `exterior` bit is 0. `sun_shadow_strength` saturates at exactly 1.0 above ~12° of elevation, so
+/// the test is the same threshold the receivers' own `night_w` crosses — the two cannot disagree.
+fn exterior_shadows_on(video: &VideoConfig, sun_strength: f32) -> bool {
+    video.exterior_shadows && sun_strength < 1.0
+}
+
+/// A reverse-Z perspective (near → 1, far → 0; wgpu clip, RH, looking down −Z) — matches the whole
+/// engine's reverse-Z convention and the torch depth pipeline's `GreaterEqual` compare. Built in f64.
+fn reverse_z_perspective(fov_y: f64, aspect: f64, near: f64, far: f64) -> DMat4 {
+    let f = 1.0 / (fov_y * 0.5).tan();
+    // Column-major columns.
+    DMat4::from_cols(
+        DVec4::new(f / aspect, 0.0, 0.0, 0.0),
+        DVec4::new(0.0, f, 0.0, 0.0),
+        DVec4::new(0.0, 0.0, near / (far - near), -1.0),
+        DVec4::new(0.0, 0.0, (far * near) / (far - near), 0.0),
+    )
+}
+
+/// MONKEY (Phase 5): the six cube-face `view_proj`s of a fixture — a 90°(+ε) reverse-Z perspective
+/// looking down each of ±X, ±Y, ±Z — so the maps cover EVERY direction around it. This replaced the
+/// single aimed cone: any single cone has an edge, and both the vertical (walk up to the forge) and
+/// lateral (stand beside the player) shadow collapses were that edge being crossed. Face order is
+/// the contract with `static_gx.wgsl`'s `torch_face`: 0 +X, 1 −X, 2 +Y, 3 −Y, 4 +Z, 5 −Z. Computed
+/// in f64 because fixtures sit at absolute Bevy world coords (~9,300 out) where f32 view-matrix
+/// arithmetic loses precision. Nothing here depends on the camera or the player any more.
+fn cube_view_projs(fixture: Vec3) -> [Mat4; CUBE_FACES] {
+    let eye = DVec3::new(fixture.x as f64, fixture.y as f64, fixture.z as f64);
+    let proj = reverse_z_perspective(TORCH_FACE_FOV as f64, 1.0, 0.1, TORCH_RANGE as f64);
+    let faces: [(DVec3, DVec3); CUBE_FACES] = [
+        (DVec3::X, DVec3::Y),
+        (DVec3::NEG_X, DVec3::Y),
+        (DVec3::Y, DVec3::NEG_Z),
+        (DVec3::NEG_Y, DVec3::NEG_Z),
+        (DVec3::Z, DVec3::Y),
+        (DVec3::NEG_Z, DVec3::Y),
+    ];
+    faces.map(|(dir, up)| {
+        let vp = proj * DMat4::look_to_rh(eye, dir, up);
+        Mat4::from_cols_array(&vp.to_cols_array().map(|v| v as f32))
+    })
+}
+
+#[allow(clippy::too_many_arguments)]
+fn update_torch_shadows(
+    video: Res<VideoConfig>,
+    state: Res<State<ClientState>>,
+    mut demand: ResMut<ShadowDemand>,
+    frame: Res<ShadowFrame>,
+    mut lane: ResMut<TorchLane>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut views: ResMut<TorchShadowViews>,
+    cameras: Query<&GlobalTransform, With<WorldCamera>>,
+    // MONKEY (torch caster selection): the RANKING ANCHOR. Shadows are for the player's own
+    // surroundings — a free-look camera swung across the room must not re-pick the casters — so
+    // scoring is done at the body, and only falls back to the camera when there is none (the glue
+    // scene, a capture fixture, the frame before the player streams in).
+    player: Query<&GlobalTransform, With<SelfPlayer>>,
+    // Interior WMO fixtures: a `PointLight` carrying a room claim. MONKEY (torch caster selection):
+    // the intensity/colour and the authored reach ride along now — the score is the light's own
+    // contribution, so the lane must read exactly what the packer reads.
+    // MONKEY (review fixes): containment is membership evidence even with no MOLR; keep the
+    // visibility membership separate so the missing-lane fallback stays identical to the packer.
+    // MONKEY (carried light stability): `Has<ChildOf>` + `Option<&CarriedLightMotion>` ride the
+    // tuple so the filter below can refuse a MOVING carried light a slot. Both are cheap table
+    // reads on a query that already walks these entities.
+    // MONKEY (outdoor torch shadows): the FILTER moved into the closure. It used to be
+    // `Or<(With<LightRooms>, With<LightLitRooms>)>` — "has a room claim" — which is exactly the set
+    // of fixtures that can be interior, and therefore excluded every outdoor campfire from the
+    // query outright. The filter is now the packer's own (`Without<ShadowProxyLight>`: a proxy is a
+    // `PointLight` that exists only to cast, never to light), and the room-claim test is applied
+    // per-candidate on the INTERIOR arm below, so the interior candidate set is unchanged
+    // member-for-member. `Has<LightLitRooms>` rides the tuple to reproduce the other half of the
+    // retired `Or`, and `Has<HeldLight>` to refuse a body-carried torch an EXTERIOR slot.
+    // MONKEY (torch owner exclusion): `Option<&LightOwner>` — who this fixture is part of, written
+    // at the two light spawn sites (`terrain_stream::spawn`'s `tag_light_owner`,
+    // `entities::carried_light`). It rides the candidate and then the slot, because the caster
+    // gathers need it and they run far downstream of this query.
+    torches: Query<
+        (Entity, &GlobalTransform, &WorldPointLight, Option<&LightReach>, Option<&LightLane>,
+         Has<LightRooms>, Has<LightLitRooms>, Has<SyntheticFireLight>, Has<ChildOf>,
+         Has<HeldLight>, Option<&crate::entities::CarriedLightMotion>, Option<&LightOwner>),
+        // MONKEY (daylight fixtures): a doorway's daylight source is NOT a caster candidate. It is
+        // an AREA source the width of the opening, standing in a hole in a wall — a point-cube
+        // shadow of it would be wrong in kind (hard radial wedges from a soft sky) — and being
+        // bright and close to the player the moment they walk in, it would outrank the room's real
+        // fixtures for the twelve cube slots and take their shadows away.
+        (Without<ShadowProxyLight>, Without<DaylightFixture>),
+    >,
+    // MONKEY (torch caster selection): `atten_scale` — a fixture's EFFECTIVE radius is its authored
+    // end times this live cvar, and the score's window is a fraction of that radius. Reading the
+    // same resource the packer folds into the shader's `.w` keeps ranking and rendering agreed.
+    interiors: Res<DynamicInteriors>,
+    fire_gain: Res<FireLightGain>,
+    gx: Option<Res<StaticGx>>,
+    // MONKEY (Phase 3B): the entity caster inputs, bundled (see [`EntityCasters`]).
+    ents: EntityCasters,
+    time: Res<Time>,
+    mut last_trace: Local<f64>,
+) {
+    // Declare demand so the shared rig stays up while on.
+    // MONKEY (outdoor torch shadows): EITHER lane keeps the lane alive — they share the sixteen
+    // cube slots, the rebuild budget and the depth bank, so there is one system, not two.
+    let sun_w = sun_shadow_strength(ents.lighting.celestial_dir().y);
+    let interior_on = interior_shadows_on(&video);
+    let exterior_on = exterior_shadows_on(&video, sun_w);
+    let on = (interior_on || exterior_on) && *state.get() == ClientState::InWorld;
+    demand.0 = demand.0 || on;
+
+    if !(frame.active && on) {
+        teardown(&mut lane, &mut meshes, &mut views);
+        return;
+    }
+    let Some(cam) = cameras.iter().next().map(GlobalTransform::translation) else {
+        return;
+    };
+
+    // (1) MONKEY (torch caster selection): who casts. Three rules, in this order.
+    //
+    //   RANK BY CONTRIBUTION, NOT DISTANCE. The old lane took the four fixtures nearest the camera
+    //   and hard-switched the set every frame. In a candle-dense room that set churns every few
+    //   steps — Northshire Abbey authors 42 candelabra about 5 yd apart — and every fixture NOT
+    //   in it lit with no shadow at all, so shadows visibly popped in as you approached a candle
+    //   and out again as you passed it. Scoring by the light's own direct term at the PLAYER makes
+    //   the ranking a smooth function of position instead of a step function, and makes it right:
+    //   a bright forge across the room outranks a guttering candle at your feet, which is what the
+    //   eye expects of a shadow.
+    //
+    //   HYSTERESIS. A smooth score still crosses. An incumbent keeps its slot unless a challenger
+    //   beats it by TORCH_SWAP_RATIO, and at most one contested swap starts per
+    //   TORCH_SWAP_COOLDOWN — so walking the candle corridor does not trade slots every step.
+    //
+    //   FADE, NOT SWITCH. A promoted slot ramps its weight 0 to 1; a losing one ramps 1 to 0 and is
+    //   only REPLACED at 0 (it keeps rendering while it fades). The receivers apply the weight as
+    //   `mix(1, shadow, w)`, so a shadow dissolves rather than blinking.
+    let anchor = player
+        .iter()
+        .next()
+        .map(GlobalTransform::translation)
+        .unwrap_or(cam);
+    let want = (video.interior_shadow_casters as usize).clamp(1, MAX_TORCH_CASTERS);
+    let dt = time.delta_secs();
+    let now = time.elapsed_secs_f64();
+    // MONKEY (moving fixture): who held a live rebuild budget LAST frame. Read before the candidate
+    // closure because the closure needs it and `lane` is borrowed mutably from (1b) on; last
+    // frame's answer is the right one anyway — the point of the test is incumbency.
+    let live_held: Vec<Entity> = lane
+        .slots
+        .iter()
+        .filter(|s| s.moving_live)
+        .map(|s| s.fixture)
+        .collect();
+
+    // (1a) MONKEY (torch caster reach): each pool is eligible from 4R + slack away. Rank with the
+    // same soft core/intensity so nearby contributors still win over pools seen across the room.
+    // MONKEY (outdoor torch shadows): the candidate tuple carries its LANE (`true` = exterior).
+    let mut cands: Vec<Candidate> = torches
+        .iter()
+        .filter_map(|(e, gt, pl, reach, light_lane, has_rooms, has_lit, synthetic, carried,
+                      held, motion, owner)| {
+            // MONKEY (carried light stability): a CARRIED light (`ChildOf` — a pet's hand flame,
+            // an NPC's torch, a transport's deck brazier) used to cast ONLY while standing still,
+            // because a cached cube is valid only while its fixture stays within
+            // `TORCH_STALE_DRIFT_SQ` of where it was baked ([`map_publishable`]) and a moving one
+            // toggled a full-strength shadow at frame rate.
+            //
+            // MONKEY (moving fixture): that ban is lifted, because the lane can now RE-RENDER a
+            // moving fixture's whole cube every frame instead of republishing a frozen one (see
+            // [`TorchSlot::moving`]). What survives of the old rule is its arithmetic: only
+            // [`TORCH_MOVING_MAX`] fixtures can be afforded that way, so a moving carried light is
+            // admitted as a candidate only if it already HOLDS one of those budgets or one is free.
+            // Doing it here, at candidacy, rather than by promoting it and evicting it a moment
+            // later, is what stops a third walking pet from churning the slot machinery: it never
+            // enters `cands`, so nothing downstream has to fade it out and refill after it.
+            //
+            // The stationary members of the same `ChildOf` family are untouched — a placed brazier
+            // GameObject or a campfire is `settled` and takes the ordinary cached path.
+            if carried
+                && !motion.is_some_and(CarriedLightMotion::settled)
+                && !live_held.contains(&e)
+                && live_held.len() >= TORCH_MOVING_MAX
+            {
+                return None;
+            }
+            let p = gt.translation();
+            let d = p.distance(anchor);
+            if p.distance(cam) > TORCH_SEARCH_RADIUS.max(ents.distance.0) {
+                return None;
+            }
+            // The packer's own recovery of authored colour x intensity (`spawn_point_light`
+            // premultiplied 4*pi), and the packer's own reach: the authored MOLT end where there is
+            // one, the intensity bucket otherwise, times the live `interiorAttenScale`.
+            let base = pl.intensity / (4.0 * std::f32::consts::PI);
+            let authored = reach
+                .map(|r| r.0)
+                .filter(|r| *r > 0.5)
+                .unwrap_or_else(|| m2_light_reach(base));
+            let r = interior_reach(authored, interiors.atten_scale);
+            // MONKEY (outdoor torch shadows): the `4R + slack` eligibility test moved DOWN into the
+            // interior arm (unchanged there). It cannot be shared: `r` is an INTERIOR reach — the
+            // authored MOLT end or the M2 intensity bucket times `interiorAttenScale` — and an
+            // exterior entry packs no reach at all, so applying it out here would size an outdoor
+            // campfire's promotion window off a number no exterior receiver ever reads.
+            let c = pl.color;
+            // Rec.709 luminance of the committed colour: ONE scalar for "how much light is this",
+            // so a dim blue magic brazier cannot outrank a bright hearth on channel count.
+            let lum = (0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]).max(0.0) * base.max(0.0);
+            // MONKEY (outdoor torch shadows): the lane split. It is the SAME verdict the light
+            // packer writes into the colour row's `.w` (`LightLane` — a light is interior iff it
+            // physically stands in an interior-class WMO group, with the old `LightRooms` rule as
+            // the pre-classification fallback), because that is what decides which receiver family
+            // reads it and therefore which shadow lane can ever be sampled for it.
+            let interior = light_lane.map_or(has_rooms, |l| l.interior);
+            if interior {
+                // The interior arm, unchanged — including the retired query filter's own
+                // membership test, so this candidate set is identical member-for-member to the one
+                // `Or<(With<LightRooms>, With<LightLitRooms>)>` produced.
+                if !interior_on || !(has_rooms || has_lit) {
+                    return None;
+                }
+                if !fixture_eligible(d, p.distance(cam), r, ents.distance.0) {
+                    return None;
+                }
+                let score =
+                    candidate_score(lum, d, r, light_lane, has_rooms, synthetic, fire_gain.0);
+                // MONKEY (torch lane perf): `r` rides along — the moving-caster gather sizes its
+                // radius off the light that will be sampled, not off the cube's 48 yd far plane.
+                return (score > 0.0).then_some((e, p, score, false, r, owner.copied()));
+            }
+            // The EXTERIOR arm — a campfire, a brazier, a lamppost, a bonfire.
+            if !exterior_on || held {
+                return None;
+            }
+            if !exterior_eligible(d, p.distance(cam), ents.distance.0) {
+                return None;
+            }
+            // Same synthetic-gain fold as the interior arm (and as the packer): dimming the
+            // invented lights with `fireLightGain 0` must take their shadows with them, or a fire
+            // that lights nothing would still carve a black wedge across the ground.
+            let gain = if synthetic { fire_gain.0.max(0.0) } else { 1.0 };
+            let score = exterior_fixture_score(lum * gain, d);
+            // MONKEY (torch lane perf): an exterior entry packs no reach and its receivers apply an
+            // un-windowed falloff, so the cube's own range is the only honest gather radius here.
+            (score > 0.0).then_some((e, p, score, true, TORCH_RANGE, owner.copied()))
+        })
+        .collect();
+    cands.sort_by(|a, b| b.2.total_cmp(&a.2));
+    let ext_cap = exterior_budget(want);
+    cap_exterior_candidates(&mut cands, ext_cap);
+
+    // (1b) Refresh the incumbents against this frame's candidates. A fixture that dropped out of
+    // the set (it moved away, despawned, its room streamed out) starts fading rather than
+    // vanishing. A slot past the live budget does the same, so lowering `interiorShadowCasters`
+    // fades its extra shadows out instead of cutting them.
+    for (i, slot) in lane.slots.iter_mut().enumerate() {
+        match cands.iter().find(|(e, ..)| *e == slot.fixture) {
+            Some((_, p, sc, _, r, owner)) => {
+                slot.pos = *p;
+                slot.score = *sc;
+                slot.reach = *r;
+                // The owner tag can only ever LAND (it is written at spawn and never removed), so
+                // refreshing it here is what lets a fixture promoted on its very first frame pick
+                // it up rather than casting its own body's shadow until it is next re-promoted.
+                slot.owner = *owner;
+            }
+            None => {
+                slot.score = 0.0;
+                slot.evicting = true;
+            }
+        }
+        if i >= want {
+            slot.evicting = true;
+        }
+    }
+
+    // (1b2) MONKEY (moving fixture): the motion test and the live-rebuild budget.
+    //
+    // The bug this answers: a carried light's slot kept publishing the cube it baked at `built_at`
+    // while the light pool followed the pet, so the imp walked around the Darkshire inn dragging a
+    // dark smear that belonged to where it had been. The eviction rule that produced it ("a drifted
+    // slot on its way out publishes from `built_at` and fades") is correct for a fixture that is
+    // LEAVING; it is simply the wrong rule for one that is merely walking, and the only right
+    // answer for that one is to re-render it.
+    //
+    // Ordering matters: this sits between the incumbent refresh (which wrote this frame's `pos` and
+    // `score`) and the weight ramp below (which needs to know who fades fast), so every slot's
+    // verdict is made from fresh positions and acted on in the same frame it is made.
+    for slot in lane.slots.iter_mut() {
+        if slot.pos.distance_squared(slot.last_pos) > TORCH_MOVING_EPS_SQ {
+            slot.still_since = now;
+        }
+        slot.last_pos = slot.pos;
+    }
+    let (live, dropped) = moving_budget(
+        lane.slots
+            .iter()
+            .enumerate()
+            .filter(|(_, s)| s.moving(now))
+            .map(|(i, s)| (i, s.score))
+            .collect(),
+    );
+    for (i, slot) in lane.slots.iter_mut().enumerate() {
+        slot.moving_live = live.contains(&i);
+        // A mover past the cap is withdrawn rather than kept: a frozen map on a fixture that is
+        // still walking is a shadow in the wrong place, which is worse than no shadow. It still
+        // FADES (over 0.15 s) rather than blinking, and it still publishes from `built_at` while it
+        // does, which is what the `evicting` flag buys it in the publish step below.
+        slot.fast_fade = dropped.contains(&i);
+        if slot.fast_fade {
+            slot.evicting = true;
+        }
+    }
+
+    // (1c) Ramp the weights, then release the slots that finished fading out.
+    let step = TORCH_FADE_RATE * dt;
+    for slot in lane.slots.iter_mut() {
+        // MONKEY (moving fixture): a dropped mover leaves five times faster — see the const.
+        let step = if slot.fast_fade { TORCH_MOVING_FADE_RATE * dt } else { step };
+        slot.w = if slot.evicting {
+            (slot.w - step).max(0.0)
+        } else {
+            (slot.w + step).min(1.0)
+        };
+    }
+    lane.slots.retain(|s| {
+        let release = s.evicting && s.w <= 0.0;
+        if release {
+            if let Some(mesh) = &s.mesh { meshes.remove(mesh.id()); }
+        }
+        !release
+    });
+
+    // (1d) Fill free slots from the best unassigned candidates. A newly filled slot starts at
+    // w = 0 and fades IN. Note this can only run once a fading slot has fully drained, which is
+    // what stops a churn from being visible even when the SELECTION churns.
+    // MONKEY (static torch cache): at most two new residents per frame, including startup.
+    let mut promotions = 0;
+    while lane.slots.len() < want && promotions < 2 {
+        let Some(&(e, p, sc, exterior, reach, owner)) = cands
+            .iter()
+            .find(|(e, ..)| !lane.slots.iter().any(|s| s.fixture == *e))
+        else {
+            break;
+        };
+        let cache_slot = (0..MAX_TORCH_CASTERS)
+            .find(|i| !lane.slots.iter().any(|s| s.cache_slot == *i)).unwrap();
+        promotions += 1;
+        lane.slots.push(TorchSlot {
+            cache_slot,
+            mesh: None,
+            geometry_key: None,
+            built_at: None,
+            fixture: e,
+            pos: p,
+            score: sc,
+            reach,
+            checked: None,
+            exterior,
+            owner,
+            trace_excluded: (0, 0),
+            // MONKEY (moving fixture): born settled — `still_since` at 0 is "moved long ago", so
+            // the first frame takes the ordinary (queue-jumping) cached build and only an observed
+            // move promotes the slot onto the live budget.
+            last_pos: p,
+            still_since: 0.0,
+            moving_live: false,
+            fast_fade: false,
+            w: 0.0,
+            evicting: false,
+        });
+    }
+
+    // (1e) The contested swap: the best unassigned candidate takes the weakest incumbent's slot
+    // only if it beats it by the ratio AND the cooldown has elapsed. Marking `evicting` rather
+    // than replacing is the whole of "fade, not switch" — (1c) drains it and (1d) refills it a
+    // fade later, by which time the challenger has been re-scored at the player's new position.
+    if now - lane.last_swap >= TORCH_SWAP_COOLDOWN {
+        let weakest = lane
+            .slots
+            .iter()
+            .enumerate()
+            .filter(|(_, s)| !s.evicting)
+            .min_by(|a, b| a.1.score.total_cmp(&b.1.score))
+            .map(|(i, s)| (i, s.score));
+        let challenger = cands
+            .iter()
+            .find(|(e, ..)| !lane.slots.iter().any(|s| s.fixture == *e))
+            .map(|(_, _, sc, ..)| *sc);
+        if let (Some((idx, weak)), Some(best)) = (weakest, challenger) {
+            if best > weak * TORCH_SWAP_RATIO {
+                lane.slots[idx].evicting = true;
+                lane.last_swap = now;
+            }
+        }
+    }
+
+    // The published set, in slot order: fixture, position, score (trace only) and fade weight,
+    // capped at the table's allocation.
+    // MONKEY (outdoor torch shadows): …and each slot's LANE, for the caster gather's self-exclusion
+    // radius, the published `exterior` bit and the trace.
+    let promoted: Vec<(usize, Entity, Vec3, f32, f32, bool)> = lane
+        .slots
+        .iter()
+        .take(MAX_TORCH_CASTERS)
+        .map(|s| (s.cache_slot, s.fixture, s.pos, s.score, s.w, s.exterior))
+        .collect();
+
+    // (2) MONKEY (static torch cache): fingerprint resident SOURCE geometry per fixture, not
+    // StaticGx's change tick (frame bookkeeping changes it continuously). This catches arrivals,
+    // removals and replacements even with a stationary camera. Entity-resident rigid furniture
+    // joins the static mesh; creatures and skinned/animated parts belong to the dynamic overlay.
+    let fixture_positions: Vec<_> = promoted.iter().map(|(i, _, p, ..)| (*i, *p)).collect();
+    // MONKEY (moving fixture): a live slot is dynamic BY DEFINITION — the moving entities are half
+    // of what makes its map wrong when it is frozen (the pet's own body is usually excluded as its
+    // own owner, but everyone it walks past is not), and the overlay is where they are drawn. OR'd
+    // in rather than folded into `dynamic_set`'s nearest-N so the cvar keeps meaning exactly what
+    // it says; `torch_cache_plan` still clamps the union to the eight-cube live bank.
+    let moving_mask = lane
+        .slots
+        .iter()
+        .filter(|s| s.moving_live)
+        .fold(0u32, |mask, s| mask | (1 << s.cache_slot));
+    let dynamic = dynamic_set(&fixture_positions, anchor, video.interior_shadow_dynamic as usize)
+        | moving_mask;
+    let mut rebuilt = 0;
+    // MONKEY (moving fixture): the live slots' own rebuild allowance, kept apart from `rebuilt`.
+    let mut moving_rebuilt = 0;
+    let mut static_rebuilt = 0u32;
+    // MONKEY (torch lane perf): how many fingerprint walks the gate actually let through this
+    // frame, folded into the lane's per-second trace below (`lane` is mutably borrowed inside the
+    // loop, so the counter cannot live on it until the loop has finished).
+    let mut lane_scans = 0u32;
+    let mut published = TorchShadowViews {
+        count: promoted.iter().map(|(i, ..)| *i as u32 + 1).max().unwrap_or(0),
+        soft: video.interior_shadow_soft,
+        // MONKEY (shadow floor): the direct-term floor, packed beside `soft` in `count.y`.
+        strength: video.torch_shadow_strength,
+        dynamic_mask: dynamic,
+        // MONKEY (moving fixture): the render plan's own budget follows the same set.
+        moving_mask,
+        // MONKEY (outdoor torch shadows): the receivers' one-bit gate — the cvar, the sun AND an
+        // actual exterior slot to sample. Keyed on the SLOTS rather than on `exterior_on` alone so
+        // that a night with the cvar on but nothing promoted (no fires in range) costs the
+        // receivers nothing at all, which is most of the outdoor world.
+        exterior: exterior_on && promoted.iter().any(|(.., ext)| *ext),
+        ..Default::default()
+    };
+    // MONKEY (static torch cache): rotate service order so two moving/carried fixtures cannot
+    // consume the rebuild budget forever and starve a newly resident room's static maps. The
+    // rotation bounds the SCAN as well as the rebuild (see TORCH_SCAN_PER_FRAME): fingerprinting a
+    // fixture's surroundings is the one part of this lane that is O(resident scene), so doing it
+    // for every slot every frame would be the new cost ceiling — and at most two of those slots
+    // could act on the answer anyway.
+    let slot_count = lane.slots.len();
+    // MONKEY (torch lane perf): the scene-wide census, computed ONCE for the whole lane rather
+    // than implicitly once per scanned slot. Everything a fingerprint hashes lives in exactly two
+    // places, and both are summarised here far more cheaply than they are hashed: the retained
+    // regions' change stamps and populations, and one branch-free mix per rigid opaque model part.
+    // While this pair is unchanged the fixture-local source set cannot have changed either, so the
+    // slot's walk is skipped outright — which is what turns "a full scene scan every frame,
+    // forever, in a room where nothing ever moves" into "a scan the frame something does".
+    let census = (slot_count > 0)
+        .then(|| PartCensus {
+            gx: gx.as_ref().map_or(0, |gx| gx.torch_residency_generation()),
+            parts: static_part_census(&ents),
+        })
+        .unwrap_or_default();
+    // A slot that has NEVER been fingerprinted jumps the queue: with one scan a frame a fresh
+    // promotion would otherwise wait a whole sweep for its first map, and a slot with no map
+    // publishes none (`map_publishable`), so that wait is a shadow that is simply missing. There
+    // are at most two promotions a frame, so this can never crowd the rotation out for long.
+    let start = lane
+        .slots
+        .iter()
+        .position(|s| s.checked.is_none())
+        .unwrap_or_else(|| if slot_count == 0 { 0 } else { lane.rebuild_cursor % slot_count });
+    let scan = slot_count.min(TORCH_SCAN_PER_FRAME);
+    // MONKEY (moving fixture): a live slot is scanned EVERY frame, in addition to (and ahead of)
+    // the cursor's window. It cannot wait its turn in a rotation that takes a dozen frames to come
+    // round: its fingerprint changes every frame by construction (`slot.pos` is hashed into it), so
+    // "wait for the cursor" and "publish a map baked somewhere else for twelve frames" are the same
+    // sentence. The two budgets stay separate below, so this never costs the resident slots their
+    // own rebuild.
+    let mut scanning: Vec<usize> = lane
+        .slots
+        .iter()
+        .enumerate()
+        .filter(|(_, s)| s.moving_live)
+        .map(|(i, _)| i)
+        .collect();
+    for offset in 0..scan {
+        let index = (start + offset) % slot_count;
+        if !scanning.contains(&index) {
+            scanning.push(index);
+        }
+    }
+    for index in scanning {
+        let slot = &mut lane.slots[index];
+        let i = slot.cache_slot;
+        // MONKEY (moving fixture): this slot's verdict, read once — it picks the gather radius,
+        // the rebuild budget and whether the mesh asset is reused in place.
+        let moving = slot.moving_live;
+        // MONKEY (moving fixture): a moving fixture gathers static geometry inside its OWN reach
+        // rather than the cube's flat 48 yd. The receivers' direct term is exactly zero past
+        // `reach` (`interior_window`), so everything between the two radii could only ever shadow
+        // fragments this fixture does not light — for a cached slot that waste is paid once and
+        // does not matter, but this slot pays it EVERY frame, and an imp's flame reaches ~10 yd
+        // where the cube reaches 48 (a hundredth of the volume). Settled slots keep the full range
+        // verbatim, so no cached key or mesh changes meaning.
+        let range = if moving { entity_gather_radius(slot.reach) } else { TORCH_RANGE };
+        // MONKEY (torch lane perf): the skip. The fixture's own position joins the census because
+        // it is hashed INTO the fingerprint (a carried torch moves without the world changing),
+        // and a slot is only ever stamped once its key is actually committed below — a rebuild
+        // deferred by the budget must come back and try again, not be certified as looked at.
+        if slot.checked == Some((census.gx, census.parts, slot.pos)) {
+            continue;
+        }
+        lane_scans += 1;
+        let mut hash = std::collections::hash_map::DefaultHasher::new();
+        slot.fixture.hash(&mut hash);
+        slot.pos.to_array().map(f32::to_bits).hash(&mut hash);
+        // MONKEY (torch owner exclusion): the owner is part of the ADMISSION, so it is part of the
+        // FINGERPRINT by construction — a key computed over a different source set than the mesh
+        // would certify the wrong geometry as current. (It needs no separate hash lane: the owner
+        // is a function of `slot.fixture`, which is hashed above, and it never changes for a slot.)
+        let owner = slot.owner;
+        let gather = [(i, slot.pos, range, owner)];
+        gx.as_ref()
+            .map(|gx| gx.torch_geometry_key(slot.pos, range, owner))
+            .hash(&mut hash);
+        let mut entity_key = 0u64;
+        for (entity, pick, part, global, rig, occluder, _, object, aabb) in &ents.parts {
+            if !static_part(part, rig.is_some()) || !occluder.0 { continue; }
+            let Some(global) = global else { continue };
+            if global.translation().distance_squared(slot.pos) > range * range { continue; }
+            // The same exclusion the gather below applies, or the key would certify a mesh that
+            // was never built from this set.
+            if part_is_own_body(&ents, &gather, entity, part.kind, object, Some(global), aabb) {
+                continue;
+            }
+            // Arc identity catches geometry replacement, transform bits catch moved furniture.
+            let mut part_hash = std::collections::hash_map::DefaultHasher::new();
+            entity.hash(&mut part_hash);
+            (std::sync::Arc::as_ptr(&pick.0) as usize).hash(&mut part_hash);
+            global.to_matrix().to_cols_array().map(f32::to_bits).hash(&mut part_hash);
+            entity_key = entity_key.wrapping_add(part_hash.finish());
+        }
+        entity_key.hash(&mut hash);
+        let key = hash.finish();
+        let dirty = slot.geometry_key != Some(key);
+        if !dirty {
+            slot.checked = Some((census.gx, census.parts, slot.pos));
+        }
+        // MONKEY (moving fixture): two budgets, not one. A moving slot asks to rebuild every
+        // frame, so sharing the resident slots' two would let one walking pet freeze every static
+        // map in the room for as long as it walked.
+        let afford = if moving { moving_rebuilt < TORCH_MOVING_MAX } else { rebuilt < 2 };
+        if dirty && afford {
+            // MONKEY (moving fixture): recycle THIS slot's own buffers when it is live, so a
+            // fixture that rebuilds sixty times a second does not allocate two Vecs a frame.
+            let (mut positions, mut indices) = slot
+                .mesh
+                .as_ref()
+                .filter(|_| moving)
+                .and_then(|h| meshes.get_mut(h))
+                .map(take_mesh_buffers)
+                .unwrap_or_default();
+            let gx_excluded = gx.as_ref().map_or(0, |gx| {
+                gx.append_torch_triangles(
+                    slot.pos, range, owner, &mut positions, &mut indices)
+            });
+            let (_, part_excluded) =
+                collect_torch_entities(&ents, true, &gather, &mut positions, &mut indices);
+            slot.trace_excluded = (gx_excluded, part_excluded);
+            // MONKEY (moving fixture): a live slot MUTATES its mesh in place and keeps its asset
+            // id; only a settled rebuild takes a fresh one. Two reasons. A new `Mesh` asset every
+            // frame churns a vertex+index GPU allocation per frame per mover. And, worse, a brand
+            // new asset is not certified resident on the frame it is added — `torch_cache_plan`
+            // answers an unready mesh by clearing the slot's ready bit, which `TorchTable::pack`
+            // turns into a zero cross-fade weight: the shadow would blink off on exactly the frames
+            // the fixture is moving. With the id stable the mesh is always ready, and the render
+            // plan rebuilds a `moving_mask` slot unconditionally instead of on an id change.
+            match slot.mesh.as_ref().filter(|_| moving).and_then(|h| meshes.get_mut(h)) {
+                Some(mesh) => restore_mesh_buffers(mesh, positions, indices),
+                None => {
+                    let mut mesh = empty_shadow_mesh();
+                    restore_mesh_buffers(&mut mesh, positions, indices);
+                    if let Some(old) = slot.mesh.replace(meshes.add(mesh)) { meshes.remove(old.id()); }
+                }
+            }
+            slot.geometry_key = Some(key);
+            slot.built_at = Some(slot.pos);
+            slot.checked = Some((census.gx, census.parts, slot.pos));
+            if moving { moving_rebuilt += 1 } else { rebuilt += 1 }
+            static_rebuilt |= 1 << i;
+        }
+    }
+    // Advance past everything scanned, not just what was rebuilt, so the window sweeps the whole
+    // resident set at a steady rate instead of re-examining the head of it.
+    lane.rebuild_cursor = (start + scan) % slot_count.max(1);
+
+    // MONKEY (static torch cache): publish EVERY slot every frame — position, fade weight and the
+    // six projections all move with the fixture and the cross-fade, and only the caster MESH is
+    // cached. A slot whose map is stale (dirty, awaiting its rebuild turn) still publishes it; a
+    // slot whose fixture has drifted away from where its map was baked publishes none, which forces
+    // its weight to zero rather than showing shadows cast from a position the light has left.
+    for slot in &lane.slots {
+        let i = slot.cache_slot;
+        // MONKEY (carried light stability): where this slot casts FROM this frame. Normally the
+        // live fixture position. A slot that has drifted off its baked map AND is on its way out
+        // publishes from `built_at` instead of withdrawing: withdrawing clears the slot's
+        // `ready_mask` bit, and `TorchTable::pack` answers that by forcing the cross-fade weight
+        // to 0 with no ramp — a hard shadow-off in one frame, which is the very pop the "fade,
+        // not switch" law of this lane exists to remove. Frozen, the shadow dissolves over
+        // `TORCH_FADE_RATE` from the last place it was correct; a third of a second later the
+        // fixture is a stride away and the shadow is already gone, which reads as a shadow being
+        // left behind rather than as a blink. A slot that is NOT evicting still withdraws — a
+        // resident fixture mid-rebuild must never show shadows cast from a position it has left.
+        let origin = if map_publishable(slot.built_at, slot.pos) {
+            Some(slot.pos)
+        } else {
+            slot.built_at.filter(|_| slot.evicting)
+        };
+        if origin.is_some() {
+            published.caster_meshes[i] = slot.mesh.as_ref().map(Handle::id);
+        }
+        let at = origin.unwrap_or(slot.pos);
+        published.positions[i] = at.extend(slot.w);
+        for (f, vp) in cube_view_projs(at).into_iter().enumerate() {
+            published.view_projs[i * CUBE_FACES + f] = vp;
+        }
+    }
+    // MONKEY (static torch cache): gather only around the dynamic subset, not every promoted
+    // fixture. A single mesh serves those N maps and contains no rigid furniture already cached.
+    //
+    // MONKEY (torch lane perf): …and only within each of those fixtures' OWN reach, not within the
+    // cube projection's flat 48 yd. The receivers' direct term is exactly zero past `reach`
+    // (`interior_window`), so a caster admitted beyond it could only ever shadow fragments this
+    // fixture does not light — it was pure cost. A candle's ~12 yd pool is a twentieth of the
+    // volume the 48 yd radius swept, and this gather CPU-SKINS every part it admits.
+    let dynamic_positions: Vec<GatherFixture> = lane
+        .slots
+        .iter()
+        .take(MAX_TORCH_CASTERS)
+        .filter(|s| dynamic & (1 << s.cache_slot) != 0)
+        .map(|s| (s.cache_slot, s.pos, entity_gather_radius(s.reach), s.owner))
+        .collect();
+    // MONKEY (torch lane perf): and only at `interiorShadowEntityRate` Hz. The gather + the
+    // `Mesh` mutation it feeds (a full vertex/index re-extraction, a GPU re-upload and an
+    // `AssetChanged<Mesh3d>` fan-out through material specialisation) were paid EVERY frame
+    // regardless of every count dial — the fixed charge that made `interiorShadowCasters 8` and
+    // `interiorShadowDynamic 2` measure identically to the defaults. The mesh is RETAINED between
+    // regathers and the six overlay passes still draw it every frame, so this ages the pose the
+    // casters were skinned at; it never removes a shadow.
+    if dynamic != 0 {
+        let fresh = lane.entity_mesh.is_none();
+        if fresh { lane.entity_mesh = Some(meshes.add(empty_shadow_mesh())); }
+        // MONKEY (moving fixture): a live slot overrides the cadence. `interiorShadowEntityRate`
+        // ages the POSE of the moving casters, which is invisible on a fixture that is standing
+        // still (the shadow is in the right place either way, a frame's stride out of date at
+        // worst). On a fixture that is itself walking it is not: the overlay is re-rendered from a
+        // NEW position every frame, so a mesh gathered two frames ago puts the room's other bodies
+        // in the wrong place relative to the light, which is the smear this change is about. The
+        // rate is untouched for the settled case, which is every other slot in the room.
+        let due = fresh
+            || moving_mask != 0
+            || entity_gather_due(
+                video.interior_shadow_entity_rate,
+                now - lane.entity_at,
+                dynamic,
+                lane.entity_mask,
+            );
+        if due {
+            if let Some(mesh) = lane.entity_mesh.as_ref().and_then(|h| meshes.get_mut(h)) {
+                let (mut positions, mut indices) = take_mesh_buffers(mesh);
+                (lane.trace_parts, _) = collect_torch_entities(
+                    &ents, false, &dynamic_positions, &mut positions, &mut indices);
+                restore_mesh_buffers(mesh, positions, indices);
+            }
+            lane.trace_gathers += 1;
+            lane.entity_at = now;
+            lane.entity_mask = dynamic;
+        }
+        published.entity_mesh = lane.entity_mesh.as_ref().map(Handle::id);
+    }
+    lane.trace_scans += lane_scans;
+    lane.trace_reach = dynamic_positions.iter().map(|(_, _, r, _)| *r).fold(0.0, f32::max);
+    *views = published;
+
+    // `WOW_TORCH_TRACE=1` — once a second, what the lane published: fixture distances + whether a
+    // caster mesh exists. The app-side half of the debug (the shader group-3 sample is the GPU half).
+    if std::env::var_os("WOW_TORCH_TRACE").is_some() {
+        if now - *last_trace >= 1.0 {
+            *last_trace = now;
+            // MONKEY (outdoor torch shadows): the header carries the lane budget too — "6 of the
+            // 12 slots may be exterior, 3 currently are, the sun is at 0.00" is the whole state of
+            // the split in one line, and it is the first thing to read when an outdoor shadow is
+            // missing (no EXT slots at sun 1.00 is correct; no EXT slots at sun 0.00 is a bug).
+            info!(
+                "torch-trace: {}/{} slots of {} (ext {}/{}, sun {:.2}, {} candidates, caster {}, {} entity casters)",
+                promoted.len(),
+                want,
+                MAX_TORCH_CASTERS,
+                promoted.iter().filter(|(.., ext)| *ext).count(),
+                ext_cap,
+                sun_w,
+                cands.len(),
+                if lane.slots.iter().any(|s| s.mesh.is_some()) {
+                    "built"
+                } else {
+                    "none"
+                },
+                lane.trace_parts,
+            );
+            // MONKEY (torch lane perf): the FIXED per-frame cost, in the two counters that bound
+            // it. `gather parts N (rate R Hz, reach X yd)` is the CPU-skinned moving-caster set and
+            // the cadence + union radius it was taken at; `fingerprint scans S` is how many full
+            // resident-scene walks the census gate actually let through in the last second (a
+            // still room should read 0, a streaming one a handful). Both are per SECOND, so they
+            // are directly comparable to the frame rate beside them: `gathers` equal to the fps is
+            // `interiorShadowEntityRate 0`, and `scans` equal to the fps is the old behaviour with
+            // the gate defeated.
+            info!(
+                "torch-perf: gather parts {} (rate {} Hz, {} gathers/s, reach {:.0} yd), fingerprint scans {}/s",
+                lane.trace_parts,
+                video.interior_shadow_entity_rate,
+                lane.trace_gathers,
+                lane.trace_reach,
+                lane.trace_scans,
+            );
+            lane.trace_gathers = 0;
+            lane.trace_scans = 0;
+            // MONKEY (torch caster selection): per SLOT, the three numbers the selection is made
+            // of — which fixture, what it scores at the player, and how far its cross-fade has
+            // ramped. A shadow that pops is a `w` that jumped; a shadow that should be there and
+            // is not is a fixture missing from this list (then read `cands`, above).
+            // MONKEY (torch caster reach): scientific scores expose the small distant tail;
+            // distance is still from the player, and eligibility now extends to 4R + 3 yd.
+            for (i, e, p, sc, w, ext) in &promoted {
+                // MONKEY (torch owner exclusion): `owner` + `own body` are the fix's own readout —
+                // "who this fixture belongs to" and "how many retained items / entity parts its
+                // LAST rebuild dropped as that owner's body". A fixture standing in its own black
+                // square with `own body 0/0` is a missing owner tag; one with a plausible count and
+                // a shadow still under it is a caster arriving by some third route.
+                let slot = lane.slots.iter().find(|s| s.cache_slot == *i);
+                let (gx_excl, part_excl) = slot.map_or((0, 0), |s| s.trace_excluded);
+                // MONKEY (moving fixture): `moving` is this feature's readout — `live` is a slot
+                // being re-rendered from scratch every frame, `dropped` one that is moving but past
+                // TORCH_MOVING_MAX and fast-fading out, `settled` the ordinary cached path. An imp
+                // whose shadow lags is a slot reading `settled` while it walks (then look at
+                // `still_since` / the owner tag); a room whose static shadows freeze is two slots
+                // stuck on `live`.
+                info!(
+                    "  slot {i}: lane {} {e} at [{:.1},{:.1},{:.1}] d(player) {:.1} score {:.4e} w {:.2} owner {:?} moving {} own body {gx_excl} gx + {part_excl} parts (camera <= shadowDistance AND player <= 4R+3) static {} dynamic {} requested_live_rank {:?}",
+                    if *ext { "EXT" } else { "INT" },
+                    p.x,
+                    p.y,
+                    p.z,
+                    p.distance(anchor),
+                    sc,
+                    w,
+                    slot.and_then(|s| s.owner),
+                    match slot {
+                        Some(s) if s.moving_live => "live",
+                        Some(s) if s.fast_fade => "dropped",
+                        _ => "settled",
+                    },
+                    if static_rebuilt & (1 << i) != 0 { "rebuilt (GPU pending)" } else { "cached/requested" },
+                    if dynamic & (1 << i) != 0 { "yes" } else { "no" },
+                    (dynamic & (1 << i) != 0).then(|| TorchShadowViews::live_rank(dynamic, *i)),
+                );
+            }
+        }
+    }
+}
+
+// MONKEY (static torch cache): a rig can deform even while its root stands still. Cache only
+// rigid non-creature parts; animated furniture follows the same nearest-N policy as characters.
+fn static_part(part: &ModelPart, rigged: bool) -> bool {
+    part.kind != ModelKind::Creature && !rigged && part.blend == ModelBlend::Opaque
+}
+
+/// MONKEY (torch lane perf): `fixtures` is `(slot, position, RADIUS, owner)` — each fixture carries
+/// the radius it admits casters inside, instead of the whole gather sharing [`TORCH_RANGE`]. The
+/// static (cached) caller passes `TORCH_RANGE`, so its admission WINDOW is the one it always was;
+/// only the per-frame MOVING gather narrows, to `entity_gather_radius(reach)`.
+///
+/// MONKEY (torch owner exclusion): …and the owner, which drops the fixture's own body
+/// ([`part_is_own_body`]). Returns `(admitted, excluded-as-own-body)` — the second is trace only.
+fn collect_torch_entities(
+    ents: &EntityCasters, want_static: bool, fixtures: &[GatherFixture],
+    positions: &mut Vec<[f32; 3]>, indices: &mut Vec<u32>,
+) -> (u32, u32) {
+    let mut admitted = 0;
+    let mut excluded = 0;
+    for (entity, pick, part, global, rig_part, occluder, _, object, aabb) in &ents.parts {
+        if !occluder.0 || static_part(part, rig_part.is_some()) != want_static { continue; }
+        let solid = part.blend == ModelBlend::Opaque
+            || (part.kind == ModelKind::Creature && part.blend == ModelBlend::AlphaTest);
+        if !solid { continue; }
+        let rig = rig_part.and_then(|r| ents.rigs.get(r.0).ok());
+        let origin = global.map(GlobalTransform::translation)
+            .or_else(|| rig.and_then(|r| ents.palettes.slot_origin(r.slot)));
+        let Some(origin) = origin else { continue };
+        if !within_any_reach(fixtures, origin) { continue; }
+        // After the cheap window, before the expensive CPU skin: this is the lamp's own housing,
+        // the brazier's own bowl, the lantern post the light hangs off.
+        if part_is_own_body(ents, fixtures, entity, part.kind, object, global, aabb) {
+            excluded += 1;
+            continue;
+        }
+        let base = positions.len() as u32;
+        if let Some(rig) = rig {
+            let Some(palette) = ents.palettes.world_palette(rig.slot, rig.bones() as usize) else { continue };
+            for (v, p) in pick.0.positions.iter().enumerate() {
+                let p = wow_to_bevy(*p);
+                let (Some(joints), Some(weights)) = (pick.0.joints.get(v), pick.0.weights.get(v)) else {
+                    positions.push(palette.first().map(|m| m.transform_point3(p)).unwrap_or(origin).to_array());
+                    continue;
+                };
+                let mut skinned = Vec3::ZERO;
+                for lane in 0..4 {
+                    if weights[lane] > 0.0 {
+                        if let Some(m) = palette.get(joints[lane] as usize) {
+                            skinned += m.transform_point3(p) * weights[lane];
+                        }
+                    }
+                }
+                positions.push(skinned.to_array());
+            }
+        } else if rig_part.is_none() {
+            if let Some(global) = global {
+                positions.extend(pick.0.positions.iter().map(|p| global.transform_point(wow_to_bevy(*p)).to_array()));
+            }
+        }
+        let added = positions.len() as u32 - base;
+        if added == 0 { continue; }
+        for tri in pick.0.indices.chunks_exact(3) {
+            if tri.iter().all(|i| *i < added) { indices.extend(tri.iter().map(|i| base + *i)); }
+        }
+        admitted += 1;
+    }
+    (admitted, excluded)
+}
+
+/// MONKEY (torch lane perf): the entity half of [`PartCensus`] — one branch-free mix per RIGID
+/// OPAQUE model part (the exact set the fingerprint's own entity walk hashes), folded
+/// order-independently so archetype reordering is invisible.
+///
+/// Deliberately much cheaper than the thing it guards: no `DefaultHasher` per part and no
+/// `to_matrix()`, just the entity id, the geometry `Arc`'s identity, the affine's translation and
+/// ONE basis column. Translation catches a moved prop, the basis column catches a rotated one (a
+/// door on its hinge barely moves its origin), the `Arc` catches a geometry swap, and the id sum
+/// catches an arrival or a despawn. What it cannot see — a part rotating exactly about the axis of
+/// the column sampled — has no bearing on a shadow's silhouette to the precision this lane renders.
+fn static_part_census(ents: &EntityCasters) -> u64 {
+    let mut census = 0u64;
+    for (entity, pick, part, global, rig, occluder, ..) in &ents.parts {
+        if !occluder.0 || !static_part(part, rig.is_some()) { continue; }
+        let Some(global) = global else { continue };
+        let a = global.affine();
+        let mut mix = entity.to_bits() ^ (std::sync::Arc::as_ptr(&pick.0) as usize as u64);
+        for v in [
+            a.translation.x, a.translation.y, a.translation.z,
+            a.matrix3.x_axis.x, a.matrix3.x_axis.y, a.matrix3.x_axis.z,
+        ] {
+            mix = mix.rotate_left(11) ^ u64::from(v.to_bits());
+        }
+        census = census.wrapping_add(mix);
+    }
+    census
+}
+
+/// Tear down the caster mesh and clear the published views (the lane went off, or we left the world).
+fn teardown(lane: &mut TorchLane, meshes: &mut Assets<Mesh>, views: &mut TorchShadowViews) {
+    for slot in &mut lane.slots {
+        if let Some(handle) = slot.mesh.take() { meshes.remove(handle.id()); }
+    }
+    if let Some(handle) = lane.entity_mesh.take() { meshes.remove(handle.id()); }
+    // MONKEY (torch caster selection): the slot table goes with them — an incumbent kept across a
+    // teardown would come back at full weight in a room it is no longer in.
+    lane.slots.clear();
+    // MONKEY (torch lane perf): the gather bookkeeping goes with them. A lane that comes back up in
+    // a different room must regather on its first frame, not wait out a cadence tick against a
+    // timestamp from before the teardown.
+    lane.entity_at = 0.0;
+    lane.entity_mask = 0;
+    *views = TorchShadowViews::default();
+}
+
+// MONKEY (torch caster reach): regression boundaries and the unfloored distant ranking tail.
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // MONKEY (review fixes): useful interior casters win regardless of an exterior fixture's
+    // brightness; the fire dial scales only invented sources, including its live kill switch.
+    #[test]
+    fn candidates_follow_the_packed_lane_and_fire_gain() {
+        let interior = LightLane::carried(true);
+        let exterior = LightLane::carried(false);
+        let authored = candidate_score(1.0, 10.0, 10.0, Some(&interior), true, false, 0.0);
+        assert!(authored > 0.0);
+        assert_eq!(candidate_score(100.0, 1.0, 10.0, Some(&exterior), true, false, 1.0), 0.0);
+        for gain in [0.0, -1.0] {
+            assert_eq!(candidate_score(100.0, 1.0, 10.0, Some(&interior), true, true, gain), 0.0);
+        }
+        assert_eq!(candidate_score(1.0, 10.0, 10.0, Some(&interior), true, true, 0.5), authored * 0.5);
+        // No MOLR is needed once a containment-only fixture resolves interior; before resolution
+        // the old LightRooms fallback is shared with build_light_data, in both directions.
+        assert_eq!(candidate_score(1.0, 10.0, 10.0, Some(&interior), false, false, 0.0), authored);
+        assert_eq!(candidate_score(1.0, 10.0, 10.0, None, true, false, 0.0), authored);
+        assert_eq!(candidate_score(1.0, 10.0, 10.0, None, false, false, 0.0), 0.0);
+    }
+
+    #[test]
+    fn eligibility_covers_four_reaches_with_slack() {
+        for r in [7.0, 15.0, 48.0] {
+            assert!(fixture_eligible(3.5 * r, 80.0, r, 80.0));
+            assert!(fixture_eligible(4.0 * r + 3.0, 80.0, r, 80.0));
+            assert!(!fixture_eligible(4.2 * r + 3.0, 80.0, r, 80.0));
+        }
+        assert!(!fixture_eligible(1.0, 80.01, 48.0, 80.0));
+        assert!(fixture_eligible(1.0, 250.0, 48.0, 300.0));
+        assert!(!fixture_eligible(32.0, 1.0, 7.0, 80.0));
+        assert!(!fixture_eligible(1.0, f32::NAN, 48.0, 80.0));
+    }
+
+    // MONKEY (live bank rank): sparse slots, tie stability and both ends of the live budget.
+    #[test]
+    fn dynamic_subset_is_nearest_and_deterministic() {
+        let fixtures = [(15, Vec3::X), (8, -Vec3::X), (2, Vec3::X * 20.0), (4, Vec3::ZERO)];
+        assert_eq!(dynamic_set(&fixtures, Vec3::ZERO, 2), (1 << 4) | (1 << 8));
+        assert_eq!(dynamic_set(&fixtures, Vec3::X * 20.0, 1), 1 << 2);
+        assert_eq!(dynamic_set(&fixtures, Vec3::ZERO, 0), 1 << 4);
+        assert_eq!(dynamic_set(&fixtures, Vec3::ZERO, 16).count_ones(), 4);
+        let all: Vec<_> = (0..MAX_TORCH_CASTERS).map(|i| (i, Vec3::X * i as f32)).collect();
+        assert_eq!(dynamic_set(&all, Vec3::ZERO, 16), 0xff);
+        assert_eq!(dynamic_set(&[], Vec3::ZERO, 1), 0);
+    }
+
+    // MONKEY (static torch cache): a never-built slot publishes nothing; a merely STALE map keeps
+    // being published (its shadow must not blink off while the rebuild cursor reaches it); a map
+    // whose fixture has MOVED is withdrawn, because the projections no longer address it.
+    #[test]
+    fn a_cached_map_survives_staleness_but_not_fixture_drift() {
+        assert!(!map_publishable(None, Vec3::ZERO));
+        assert!(map_publishable(Some(Vec3::ZERO), Vec3::ZERO));
+        assert!(map_publishable(Some(Vec3::ZERO), Vec3::X * 0.09));
+        assert!(!map_publishable(Some(Vec3::ZERO), Vec3::X * 0.2));
+        assert!(!map_publishable(Some(Vec3::ZERO), Vec3::splat(10.0)));
+    }
+
+    // MONKEY (outdoor torch shadows): the exterior ranking key is the EXTERIOR receivers' own
+    // profile, not the interior soft core — monotone in distance, linear in intensity, floored off
+    // the falloff's pole at 0, and reaching exactly zero at the eligibility edge so a candidate
+    // never steps out of the list at a finite score.
+    #[test]
+    fn exterior_scores_follow_the_outdoor_falloff() {
+        let near = exterior_fixture_score(1.0, 5.0);
+        let mid = exterior_fixture_score(1.0, 15.0);
+        let far = exterior_fixture_score(1.0, 40.0);
+        assert!(near > mid && mid > far && far > 0.0);
+        assert_eq!(exterior_fixture_score(1.0, TORCH_EXT_ELIGIBLE_YD), 0.0);
+        assert_eq!(exterior_fixture_score(0.0, 5.0), 0.0);
+        assert!(exterior_fixture_score(2.0, 15.0) > mid);
+        // The falloff's pole at d = 0 is floored, so a fixture the player is standing on cannot
+        // score infinity, take a slot for one frame and hand it straight back.
+        let at_zero = exterior_fixture_score(1.0, 0.0);
+        assert!(at_zero.is_finite() && at_zero <= 1.0 / 0.73 + 1e-3, "{at_zero}");
+        // …and inside the window it IS the receivers' falloff: 1/(0.7d + 0.03d^2) at 1 yd.
+        assert!((exterior_fixture_score(1.0, 1.0) - 1.0 / 0.73).abs() < 1e-2);
+    }
+
+    // MONKEY (outdoor torch shadows): the camera tests are shared with the interior lane (same
+    // budget, same `shadowDistance` dial); the player window is flat, because an exterior entry
+    // packs no reach for a `4R` window to be four of.
+    #[test]
+    fn exterior_eligibility_is_the_cube_range_at_the_player() {
+        assert!(exterior_eligible(0.0, 0.0, 80.0));
+        assert!(exterior_eligible(TORCH_EXT_ELIGIBLE_YD, 10.0, 80.0));
+        assert!(!exterior_eligible(TORCH_EXT_ELIGIBLE_YD + 0.1, 10.0, 80.0));
+        assert!(!exterior_eligible(1.0, 80.01, 80.0));
+        assert!(exterior_eligible(1.0, 250.0, 300.0));
+        assert!(!exterior_eligible(1.0, f32::NAN, 80.0));
+    }
+
+    // MONKEY (outdoor torch shadows): the lane gate is the cvar AND night, and "night" is the
+    // receivers' own threshold — `sun_shadow_strength` saturates at exactly 1.0 in daylight, so the
+    // CPU lane and the shaders' `night_w` can never disagree about which it is.
+    #[test]
+    fn the_exterior_lane_is_night_only_and_cvar_gated() {
+        let mut video = VideoConfig::default();
+        assert!(video.exterior_shadows, "shipped on");
+        assert!(exterior_shadows_on(&video, 0.0), "midnight");
+        assert!(exterior_shadows_on(&video, 0.99), "dusk still counts");
+        assert!(!exterior_shadows_on(&video, 1.0), "full daylight never");
+        video.exterior_shadows = false;
+        assert!(!exterior_shadows_on(&video, 0.0));
+        // The receivers' threshold, verbatim: 1.0 the moment the sun clears ~12 degrees.
+        assert_eq!(sun_shadow_strength(0.208), 1.0);
+        assert_eq!(sun_shadow_strength(0.9), 1.0);
+        assert_eq!(sun_shadow_strength(-0.3), 0.0);
+        assert!(sun_shadow_strength(0.1) > 0.0 && sun_shadow_strength(0.1) < 1.0);
+    }
+
+    // MONKEY (outdoor torch shadows): half the budget, rounded up — and the cap only ever removes
+    // EXTERIOR candidates, keeping the best ones (the list is score-sorted).
+    #[test]
+    fn the_exterior_budget_is_half_and_caps_only_its_own_lane() {
+        assert_eq!(exterior_budget(12), 6);
+        assert_eq!(exterior_budget(16), 8);
+        assert_eq!(exterior_budget(1), 1, "the smallest budget still gets one outdoor shadow");
+        let mut cands: Vec<Candidate> = (0..8)
+            .map(|i| {
+                (Entity::from_raw_u32(i).unwrap(), Vec3::ZERO, 8.0 - i as f32, i % 2 == 0, 10.0,
+                 None)
+            })
+            .collect();
+        cap_exterior_candidates(&mut cands, 2);
+        // Identified by score, which is also their rank: 8,7,6,5,4,3,2,1 with the even ranks
+        // exterior. Capped at two, ranks 8 and 6 (the best two fires) survive; 4 and 2 do not.
+        let kept: Vec<(u32, bool)> =
+            cands.iter().map(|(_, _, sc, x, ..)| (*sc as u32, *x)).collect();
+        assert_eq!(
+            kept,
+            vec![(8, true), (7, false), (6, true), (5, false), (3, false), (1, false)],
+            "the two best exterior fires survive; every interior candidate does"
+        );
+        // A cap of zero is a lane switched off, and it takes nothing else with it.
+        let mut all_ext: Vec<Candidate> =
+            vec![(Entity::from_raw_u32(0).unwrap(), Vec3::ZERO, 1.0, true, 10.0, None)];
+        cap_exterior_candidates(&mut all_ext, 0);
+        assert!(all_ext.is_empty());
+    }
+
+    // MONKEY (torch lane perf): the moving-caster gather is sized off each fixture's OWN reach.
+    // The margin covers the part's extent (the test is on its ORIGIN), the clamp keeps the radius
+    // inside the cube projection that has to record it, and a degenerate reach can only ever widen
+    // the window — losing a caster must never be the failure direction here.
+    #[test]
+    fn the_entity_gather_radius_is_the_fixtures_own_reach() {
+        assert_eq!(entity_gather_radius(12.0), 12.0 + TORCH_ENTITY_REACH_MARGIN);
+        assert!(entity_gather_radius(12.0) < TORCH_RANGE, "a candle sweeps far less than 48 yd");
+        assert_eq!(entity_gather_radius(TORCH_RANGE), TORCH_RANGE, "clamped to the cube range");
+        assert_eq!(entity_gather_radius(1e9), TORCH_RANGE);
+        assert_eq!(entity_gather_radius(0.0), TORCH_ENTITY_REACH_MARGIN);
+        assert_eq!(entity_gather_radius(-5.0), TORCH_ENTITY_REACH_MARGIN);
+        assert_eq!(entity_gather_radius(f32::NAN), TORCH_RANGE, "never a silent zero radius");
+    }
+
+    // …and the gather admits the UNION of those radii, not one shared radius: a tight candle and a
+    // wide hearth in the same dynamic set each keep their own window, and a part inside either is
+    // in. The reach that matters is the fixture's, so a body 20 yd from the candle and 20 yd from
+    // the hearth is a caster for the hearth alone.
+    #[test]
+    fn the_gather_admits_the_union_of_the_fixture_reaches() {
+        let candle = entity_gather_radius(8.0);
+        let hearth = entity_gather_radius(30.0);
+        let set = [(0usize, Vec3::ZERO, candle, None), (1usize, Vec3::X * 60.0, hearth, None)];
+        assert!(within_any_reach(&set, Vec3::X * 5.0), "inside the candle");
+        assert!(within_any_reach(&set, Vec3::X * 40.0), "inside the hearth, not the candle");
+        assert!(!within_any_reach(&set, Vec3::X * 20.0), "between the two, lit by neither");
+        assert!(!within_any_reach(&[], Vec3::ZERO), "an empty dynamic set admits nothing");
+        // The margin is what keeps a body whose ORIGIN sits just outside the pool casting.
+        assert!(within_any_reach(&set, Vec3::X * (8.0 + 1.0)));
+    }
+
+    // MONKEY (torch lane perf): the regather cadence. `0` is the every-frame escape hatch, a
+    // changed dynamic set always overrides the clock (the mesh is only valid for the fixtures it
+    // was gathered around), and the tolerance stops a 30 Hz cadence from beating against a 60 fps
+    // frame into an alternating 1/3-frame stutter.
+    // MONKEY (moving fixture): a slot for the motion tests — everything but the four fields the
+    // verdict reads is inert.
+    fn moving_slot(owner: Option<LightOwner>, built_at: Vec3, pos: Vec3, still_since: f64) -> TorchSlot {
+        TorchSlot {
+            cache_slot: 0,
+            mesh: None,
+            geometry_key: None,
+            built_at: Some(built_at),
+            fixture: Entity::PLACEHOLDER,
+            pos,
+            score: 1.0,
+            reach: 10.0,
+            checked: None,
+            exterior: false,
+            owner,
+            trace_excluded: (0, 0),
+            last_pos: pos,
+            still_since,
+            moving_live: false,
+            fast_fade: false,
+            w: 1.0,
+            evicting: false,
+        }
+    }
+
+    // MONKEY (moving fixture): WHO may be re-rendered every frame, and for HOW LONG after it stops.
+    #[test]
+    fn a_fixture_is_moving_only_while_it_is_actually_moving() {
+        let pet = Some(LightOwner::Instance(Entity::PLACEHOLDER));
+        let wall = Some(LightOwner::Placement { kind: ModelKind::Wmo, id: 7, label: 0 });
+        let now = 100.0;
+        // A pet's flame that moved this frame: live.
+        assert!(moving_slot(pet, Vec3::ZERO, Vec3::ZERO, now).moving(now));
+        // …still live a moment later (a walk cycle pauses; the map must not thrash back and forth).
+        assert!(moving_slot(pet, Vec3::ZERO, Vec3::ZERO, now - 0.5).moving(now));
+        // …and settled once it has held still past the threshold — back on the cached path.
+        assert!(!moving_slot(pet, Vec3::ZERO, Vec3::ZERO, now - 1.0).moving(now));
+        // A placed brazier that has never moved is never live, however recently it was promoted.
+        assert!(!moving_slot(wall, Vec3::ZERO, Vec3::ZERO, now).moving(now));
+        // …unless it has physically drifted off its own baked map, which IS proof of motion:
+        // exactly TORCH_STALE_DRIFT_SQ (0.1 yd) worth, the same threshold `map_publishable` uses.
+        assert!(!moving_slot(wall, Vec3::ZERO, Vec3::X * 0.09, now).moving(now));
+        assert!(moving_slot(wall, Vec3::ZERO, Vec3::X * 0.2, now).moving(now));
+        // A slot with no map yet is NEW, not drifted — it belongs to the promotion path.
+        let mut fresh = moving_slot(wall, Vec3::ZERO, Vec3::splat(50.0), now);
+        fresh.built_at = None;
+        assert!(!fresh.drifted());
+        assert!(!fresh.moving(now));
+    }
+
+    // MONKEY (moving fixture): the budget is by contribution, capped, and deterministic.
+    #[test]
+    fn the_moving_budget_keeps_the_best_two_and_drops_the_rest() {
+        assert_eq!(moving_budget(vec![]), (vec![], vec![]));
+        assert_eq!(moving_budget(vec![(3, 0.5)]), (vec![3], vec![]));
+        let (live, dropped) = moving_budget(vec![(0, 0.1), (1, 9.0), (2, 4.0), (3, 0.2)]);
+        assert_eq!(live, vec![1, 2]);
+        assert_eq!(dropped, vec![3, 0]);
+        // Equal scores resolve by slot order, both ways round, so the set cannot alternate.
+        let tied = vec![(5, 1.0), (2, 1.0), (9, 1.0)];
+        assert_eq!(moving_budget(tied.clone()).0, vec![2, 5]);
+        assert_eq!(moving_budget(tied.into_iter().rev().collect()).0, vec![2, 5]);
+        assert_eq!(TORCH_MOVING_MAX, 2, "the cap the render plan budgets for");
+    }
+
+    #[test]
+    fn the_entity_gather_cadence_is_a_rate_not_a_gate() {
+        assert!(entity_gather_due(0, 0.0, 1, 1), "rate 0 = every frame");
+        assert!(!entity_gather_due(30, 0.0, 1, 1), "same set, no time passed");
+        assert!(!entity_gather_due(30, 0.02, 1, 1), "still inside 1/30 s");
+        assert!(entity_gather_due(30, 1.0 / 30.0, 1, 1), "exactly on the tick");
+        assert!(entity_gather_due(30, 1.0 / 60.0 * 2.0, 1, 1), "two 60 fps frames make the tick");
+        assert!(entity_gather_due(30, 0.0, 0b11, 0b01), "a changed dynamic set overrides the clock");
+        assert!(entity_gather_due(15, 0.07, 1, 1));
+        assert!(!entity_gather_due(15, 0.05, 1, 1));
+        // A rate at or above the frame rate is "every frame" without being a special case.
+        assert!(entity_gather_due(240, 1.0 / 46.0, 1, 1));
+    }
+
+    #[test]
+    fn distant_scores_stay_positive_and_ordered() {
+        let r = 10.0;
+        let near = fixture_score(1.0, r, r);
+        let far = fixture_score(1.0, 3.0 * r, r);
+        let farther = fixture_score(1.0, 3.5 * r, r);
+        let slack = fixture_score(1.0, 4.0 * r + 2.0, r);
+        assert!(near > far && far > farther && farther > slack && slack > 0.0);
+        assert!(far < near * 0.2);
+        assert_eq!(fixture_score(0.0, 3.0 * r, r), 0.0);
+        assert_eq!(fixture_score(1.0, 4.0 * r + 3.0, r), 0.0);
+        assert!(fixture_score(2.0, 3.0 * r, r) > far);
+    }
+}
diff --git a/crates/benilla-app/src/ui_script/options_tests.rs b/crates/benilla-app/src/ui_script/options_tests.rs
index afa2b1c9..72b67521 100644
--- a/crates/benilla-app/src/ui_script/options_tests.rs
+++ b/crates/benilla-app/src/ui_script/options_tests.rs
@@ -2560,6 +2560,9 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
                 "AudioRowBackgroundSound",
             ),
             ("BENILLA_TOOLTIP_BRIGHTNESS", "GraphicsRowBrightness"),
+            ("BENILLA_TOOLTIP_CHARACTER_SHADOWS", "GraphicsRowCharacterShadows"),
+            ("BENILLA_TOOLTIP_WORLD_SHADOWS", "GraphicsRowWorldShadows"),
+            ("BENILLA_TOOLTIP_SHADOW_DISTANCE", "GraphicsRowShadowDistance"),
         ];
         if let Some((_, want_row)) = BENILLA_OWNED.iter().find(|(k, _)| *k == key) {
             assert_eq!(row, *want_row, "{row}: not this row's string");
@@ -2618,7 +2621,9 @@ fn every_row_tooltip_key_resolves_in_the_real_global_strings() {
     // …and Brightness (2182), the FOURTH row whose description is benilla's own rather than 1.12
     // GlobalStrings — OPTION_TOOLTIP_GAMMA spends its second sentence on the stock window's
     // 21-step grey ramp, which this page does not have (see the guard above). 77 -> 78.
-    assert_eq!(checked, 78, "every tipped row carries a live key");
+    // MONKEY (world shadows): +3 for Real Character Shadows, World Shadows and the Shadow
+    // Distance slider (all benilla-owned keys, carved out in BENILLA_OWNED above). 78 -> 81.
+    assert_eq!(checked, 81, "every tipped row carries a live key");
     assert_eq!(
         untipped,
         vec![
@@ -2738,7 +2743,9 @@ fn every_flavor_of_row_raises_its_plate_from_the_page_it_lives_on() {
     // own key, which is what makes the count move by exactly the number of rows added.
     // …and Weather Intensity (2181) and Brightness (2182), the Graphics page's fourth and fifth
     // sliders.
-    assert_eq!(raised, 78, "every row but Auto Loot raises a description");
+    // MONKEY (world shadows): +3 for Real Character Shadows, World Shadows and the Shadow
+    // Distance slider (all benilla-owned keys, carved out in BENILLA_OWNED above). 78 -> 81.
+    assert_eq!(raised, 81, "every row but Auto Loot raises a description");
 }
 
 /// The **Combat page** (decision 1134) — the first rows in this window whose store is a
diff --git a/crates/benilla-app/src/video.rs b/crates/benilla-app/src/video.rs
index 5b741977..d829c03d 100644
--- a/crates/benilla-app/src/video.rs
+++ b/crates/benilla-app/src/video.rs
@@ -213,9 +213,186 @@ pub(crate) fn boot_windowed_size() -> UVec2 {
 /// since 0294): the window literal resolves env-then-file for itself, `load_config` applies the
 /// file to this resource at `Startup`, and because both read the same key the reconcile is a no-op
 /// rather than a mode change one frame into the run.
-#[derive(Resource, Clone, Copy, PartialEq, Eq, Debug)]
+// NB: no `Eq` — `shadow_distance` is an f32 (only `PartialEq` is needed, for `!=` change detection).
+#[derive(Resource, Clone, Copy, PartialEq, Debug)]
 pub(crate) struct VideoConfig {
     pub(crate) vsync: bool,
+    /// Whether the STATIC WORLD (trees, buildings, foliage) casts realtime shadows and baked MCSH
+    /// terrain shadows are suppressed. Independent of [`Self::character_shadows`] — either drives
+    /// the shared shadow rig (`character_shadow` / `world_shadow`).
+    pub(crate) world_shadows: bool,
+    /// Whether CHARACTERS (players, NPCs, creatures, mounts) cast realtime silhouettes instead of
+    /// the legacy oval blob. Independent of [`Self::world_shadows`].
+    pub(crate) character_shadows: bool,
+    /// Realtime-shadow render distance in yards (the `shadowDistance` slider) — the shadow-map
+    /// cascade range + caster reach. Clamped to `shadow_core::SHADOW_DISTANCE_RANGE`.
+    pub(crate) shadow_distance: f32,
+    /// MONKEY (sun shadow perf): the directional shadow map's edge in texels (`shadowMapSize`;
+    /// 1024/2048/4096, default 2048). The rig shipped a 4096 literal, and at 1080p the two sun
+    /// lanes measured ~5 ms/frame together — a shadow map is quadratic in this number, so halving
+    /// the edge quarters the pass's fill AND the depth texture (4096² D32 = 64 MB, 2048² = 16 MB).
+    /// 2048 over one 80 yd cascade is ~26 texels/yd, still finer than the receivers' Gaussian
+    /// kernel resolves. Applied to Bevy's `DirectionalLightShadowMap` resource, which
+    /// `extract_lights` re-publishes on change and `prepare_lights` re-keys the texture cache with
+    /// — so the map is genuinely re-created, live, with no restart.
+    pub(crate) shadow_map_size: u32,
+    /// MONKEY (sun shadow perf): the receivers' PCF kernel (`shadowFilter`; 0 = Hardware2x2, one
+    /// hardware comparison sample, 1 = Gaussian, nine). Default **1** — the current look — because
+    /// this one is a taste call the user A/Bs, not a free win: `0` is 9× fewer shadow-map fetches
+    /// per lit fragment (the RECEIVER half of the cost, where `shadowMapSize` is the caster half)
+    /// at the price of visibly stair-stepped edges. Applied BOTH to the world camera's
+    /// `ShadowFilteringMethod` (which keys every Bevy-material receiver — terrain, `wow_model`)
+    /// AND to the retained `static_gx` pipeline's shader def, which is specialized by hand and
+    /// would otherwise keep whichever branch was compiled in.
+    pub(crate) shadow_filter: u32,
+    /// MONKEY (sun shadow perf): Hz cap on the CHARACTER lane's proxy re-skin
+    /// (`characterShadowRate`, 0..120, default 30; `0` = every frame, the pre-cvar behaviour). The
+    /// lane CPU-skins every admitted unit and mutates a `Mesh` asset, which costs a full
+    /// vertex+index re-upload — the character lane's ~3 ms. The shadow MAP is still rendered every
+    /// frame from the last proxy, so a capped rate does not flicker; it only lets a running NPC's
+    /// silhouette lag by up to 1/rate s.
+    pub(crate) character_shadow_rate: u32,
+    /// MONKEY (sun shadow perf): the same cap for the WORLD lane's per-frame ENTITY caster
+    /// (`worldShadowRate`, 0..120, default 30) — gameobjects, distance-faded doodads, WMO props.
+    /// A SEPARATE row from [`Self::character_shadow_rate`] on purpose: its population is nearly
+    /// static (a swinging lamp, a fading doodad) where the character lane's is animated every
+    /// frame, so it tolerates a much lower rate — and one dial named for characters silently
+    /// governing the world lane is the kind of thing nobody finds again. The world lane's STATIC
+    /// casters are untouched: they already rebuild only on 16 yd camera drift.
+    pub(crate) world_shadow_rate: u32,
+    /// MONKEY (sun shadow perf): multiplier on the CASTER-COLLECTION reach (`shadowCasterReach`,
+    /// 0.25..2, default 1 = unchanged). Collection reaches past the resolve range on purpose (a
+    /// tree standing outside the cascade still throws a shadow into it), which at `shadowDistance`
+    /// 80 admits 112 yd of entities and up to 204 yd of statics, with `NoFrustumCulling` on the
+    /// proxies. Trimming it is the direct dial on caster POPULATION — the input to both lanes'
+    /// per-rebuild cost — at the risk of a tall caster's shadow popping in as you approach.
+    pub(crate) shadow_caster_reach: f32,
+    /// MONKEY (dynamic interiors): WMO interiors + their props light from the room's live fixtures
+    /// (`interiorLight`) instead of the baked path. The three knobs are `interiorAmbient` (base
+    /// ambient, 0..1), `interiorFill` (per-fixture bounce gain, 0..2) and `interiorExposure`
+    /// (light-budget multiplier, 0.25..8) — bridged to benilla-world by `dynamic_interior`.
+    pub(crate) interior_light: bool,
+    pub(crate) interior_ambient: f32,
+    pub(crate) interior_fill: f32,
+    pub(crate) interior_exposure: f32,
+    /// MONKEY (soft falloff): live scale on every interior fixture's AUTHORED attenuation window
+    /// (`interiorAttenScale`, 0..8) — the fixture's EFFECTIVE RADIUS is `authored end × this`. A
+    /// WMO MOLT record's `+0x2c` (an M2 source buckets by intensity, its authored pair being a
+    /// template default rather than a reach) is a "full brightness ends here" number, not a
+    /// "nothing past here" one, so `1` gave a hard-edged disc at exactly the authored end. The
+    /// default is **2.5**: a 5 yd candle now tails smoothly out to 12.5, reading ~⅓ of its 1 yd
+    /// brightness at the authored 5 and ~8 % at 10. `0` still means "no window" (the 48 yd lane).
+    /// Bridged to benilla-world's `DynamicInteriors::atten_scale`, which the light packer folds
+    /// into each interior entry's packed radius, so the dial moves the frame it changes.
+    pub(crate) interior_atten_scale: f32,
+    /// MONKEY (torch shadows, Stage B): whether interior fixtures cast real shadows (the nearest few
+    /// promoted to cube-map casters — `torch_shadow`). Only meaningful with `interior_light` on.
+    pub(crate) interior_shadows: bool,
+    /// MONKEY (outdoor torch shadows): whether EXTERIOR fire lights (campfires, braziers,
+    /// lampposts, bonfires — the point table's exterior half, colour row `.w == 0`) cast real
+    /// cube-map shadows onto WMO outdoor surfaces, doodads and models AT NIGHT (`exteriorShadows`,
+    /// default on). Deliberately NOT gated on `interior_light`: the exterior receivers were never
+    /// part of the dynamic-interior feature and draw identically with it off. By day the lane is
+    /// inert on both sides — no candidates, no maps, and the receivers' own `night_w` is exactly 0
+    /// — so this dial has no daylight effect to have.
+    ///
+    /// It shares `interior_shadow_casters`' sixteen resident cube slots, capped at half of them
+    /// (`torch_shadow::exterior_budget`) so a village square cannot evict an inn's candles.
+    pub(crate) exterior_shadows: bool,
+    /// MONKEY (static torch cache): resident fixture budget (1..16, default 12). Static
+    /// geometry renders only on promotion/residency changes; lowering this fades extra slots out.
+    pub(crate) interior_shadow_casters: u32,
+    /// MONKEY (static torch cache): nearest promoted fixtures with per-frame entity overlays
+    /// (0..16, default 4). Zero keeps all static shadows and disables only the moving casters.
+    pub(crate) interior_shadow_dynamic: u32,
+    /// MONKEY (torch lane perf): how often (Hz) the moving-caster mesh is REGATHERED
+    /// (`interiorShadowEntityRate`, 0..240, default 30; `0` = every frame, the pre-feature
+    /// behaviour). The gather CPU-skins every admitted unit inside the dynamic fixtures' reach and
+    /// then MUTATES the aggregate `Mesh` asset, which costs a full vertex+index re-extraction and
+    /// GPU re-upload plus an `AssetChanged<Mesh3d>` fan-out through material specialisation - a
+    /// fixed per-frame charge that neither `interiorShadowCasters` nor `interiorShadowDynamic`
+    /// could reduce (both were measured to change nothing). The six overlay passes still run EVERY
+    /// frame from the LAST mesh, so lowering this cannot blink a shadow off; it only ages the pose
+    /// the mesh was gathered at. At 30 Hz on a 46 fps frame that is "regather about two frames in
+    /// three", and a walking NPC's shadow lags its body by at most one frame's stride.
+    pub(crate) interior_shadow_entity_rate: u32,
+    /// MONKEY (torch caster selection): the PCF tap-radius scale for the torch maps
+    /// (`interiorShadowSoft`, 0.5..3, default **1.5**). A candle cluster casts many hard-edged
+    /// overlapping shadows; widening the 4-tap kernel is the cheap softening. Rides the torch
+    /// table's `count.y` (as `x100`, LOW half) rather than a `DynamicInteriors` field, because it
+    /// belongs to the shadow table's own bytes.
+    ///
+    /// MONKEY (pcss): it is now the CONTACT radius, not the radius everywhere — the projector's
+    /// blocker search grows the kernel with the receiver's distance from its caster and clamps at
+    /// 4x this. So this dial sets how sharp the sharpest edge in the scene is, and 1 (the old
+    /// default) now reads sharper at a contact than it used to read anywhere; 1.5 restores the
+    /// shipped softness at a contact and lets the penumbra open up from there.
+    pub(crate) interior_shadow_soft: f32,
+    /// MONKEY (shadow floor): how much of the DIRECT term a torch shadow removes
+    /// (`torchShadowStrength`, 0..1, default **0.7**). A torch map is the only occlusion the
+    /// direct arm has, so a blocked fragment used to lose all of it — the pitch-black razor-edged
+    /// "scars" the Darkmoon tents printed on the grass and the Darkshire chairs printed on the inn
+    /// floor. Nothing in this renderer bounces light, so the 30 % left standing at the default IS
+    /// the bounce. Rides the torch table's `count.y` HIGH half beside `interior_shadow_soft`, and
+    /// the receivers fold it into the slot's cross-fade weight (one multiply, no extra tap), so it
+    /// touches the direct arm only — fill and ambient never saw this factor. `1` restores the
+    /// shipped look exactly; `0` turns torch shadows off without disturbing the lane behind them.
+    pub(crate) torch_shadow_strength: f32,
+    /// MONKEY (room gate): whether an interior fixture may only light the ROOMS IT CLAIMS
+    /// (`interiorRoomGate`, default on). Off = the pre-gate behaviour, where every interior fixture
+    /// in range lights every interior surface in range and the only occlusion is the handful of
+    /// promoted cube-shadow casters — the live A/B for "did the gate darken this room, or was it
+    /// always unlit?". Bridged to benilla-world's `DynamicInteriors::room_gate`, which the light
+    /// packer applies at PACK time (an ungated pack is one `count = 0` head per light), so it moves
+    /// the frame it changes and costs the shader nothing.
+    pub(crate) interior_room_gate: bool,
+    /// MONKEY (interior debug): the interior-lane diagnostic overlay (`interiorDebug`, 0..4). See
+    /// [`benilla_world::lighting::DynamicInteriors::debug`].
+    pub(crate) interior_debug: u32,
+    /// MONKEY (darkness gains): the exterior night dim (`nightGain`, 0.2..1.5, default **0.8** =
+    /// nights 20 % darker). Bridged to `DynamicInteriors::night_gain`, which the light packer folds
+    /// into the packed ambient/diffuse/specular rows on a `mix(1, gain, night_w)` ramp — so it is
+    /// exactly inert while the sun is up and live the frame it changes after dark.
+    pub(crate) night_gain: f32,
+    /// MONKEY (lighting debug panel): the interior dim (`interiorGain`, 0.2..1.5, default **0.5** =
+    /// room inputs 50 % weaker). Bridged to `DynamicInteriors::interior_gain`, which scales the room
+    /// lane's INPUTS (base ambient, per-fixture fill, every interior fixture's colour) and not
+    /// `interiorExposure` — that stays the user's own dial, and this composes with it.
+    pub(crate) interior_gain: f32,
+    /// MONKEY (enclosed day floor): the DAYLIGHT floor a room inside a building gets by day
+    /// (`interiorDaylight`, 0..1, default **0.12**). Bridged to
+    /// [`benilla_world::lighting::DynamicInteriors::daylight`], packed into the free fraction of
+    /// the interior lane's on/off word, and added to the room law's ambient budget for batches the
+    /// record table flags as enclosed. `0` restores the pre-feature look exactly; the night look is
+    /// unaffected at any value (the term is scaled by the sun's own day envelope).
+    pub(crate) interior_daylight: f32,
+    /// MONKEY (bake floor): the share of a WMO interior batch's OWN MOCV bake every interior-lane
+    /// fragment keeps whether or not a fixture reaches it (`interiorBakeFloor`, 0..1, default
+    /// **0.12**). Bridged to [`benilla_world::lighting::DynamicInteriors::bake_floor`], packed
+    /// (times `interiorGain`) into the free fraction of the world-shadow lane, and added to the
+    /// room law's budget inside its rolloff. It is what stops a room the fixture table cannot
+    /// reach — the Lion's Pride Inn's east vestibule — rendering black; `0` restores the
+    /// pre-feature look exactly.
+    pub(crate) interior_bake_floor: f32,
+    /// MONKEY (fire GO lights): gain on every light SYNTHESISED from a fire prop's flame emitter
+    /// (`fireLightGain`, 0..4; `0` = the invented-light lane off). Bridged to benilla-world's
+    /// [`benilla_world::lighting::FireLightGain`] by `dynamic_interior`, and applied at PACK time
+    /// so it is live.
+    pub(crate) fire_light_gain: f32,
+    /// MONKEY (spellLightGain): gain on every light a SPELL EFFECT invented — a kit's aura glow, a
+    /// missile's core, an impact flash, a firework shell's burst (`spellLightGain`, 0..4; `0` = the
+    /// spell-light lane off). Bridged to benilla-world's
+    /// [`benilla_world::lighting::SpellLightGain`] by `dynamic_interior` and applied at PACK time,
+    /// so it is live. Deliberately NOT folded into `fireLightGain`: a spell light is tagged
+    /// synthetic too, and one dial over both would mean turning the world's hearths down darkened
+    /// every fireball in the game.
+    pub(crate) spell_light_gain: f32,
+    /// MONKEY (flame flicker): how strongly every FLAME's brightness wobbles (`fireFlicker`, 0..2;
+    /// `1` = the authored per-kind amplitudes, `0` = the pre-feature steady constants, `2` =
+    /// doubled). Bridged to `DynamicInteriors::flicker` and applied at PACK time, so it is live —
+    /// and separate from `fireLightGain`, which scales only the SYNTHESISED lane while a flicker
+    /// belongs to authored wall torches too.
+    pub(crate) fire_flicker: f32,
     pub(crate) display: DisplayMode,
     /// The windowed size, `gxResolution`. Kept while fullscreen so leaving it can restore it.
     pub(crate) windowed: UVec2,
@@ -225,6 +402,52 @@ impl Default for VideoConfig {
     fn default() -> Self {
         Self {
             vsync: !novsync_env(),
+            world_shadows: true,
+            character_shadows: true,
+            shadow_distance: crate::shadow_core::DEFAULT_SHADOW_DISTANCE,
+            // MONKEY (sun shadow perf): 2048, not the rig's old 4096 literal — see the field docs.
+            shadow_map_size: crate::shadow_core::DEFAULT_SHADOW_MAP_SIZE,
+            shadow_filter: crate::shadow_core::DEFAULT_SHADOW_FILTER,
+            character_shadow_rate: crate::shadow_core::DEFAULT_SHADOW_RATE,
+            world_shadow_rate: crate::shadow_core::DEFAULT_SHADOW_RATE,
+            shadow_caster_reach: 1.0,
+            // The cvar defaults are the source of truth at load; these only stand in until then.
+            interior_light: true,
+            interior_ambient: 0.015,
+            interior_fill: 0.08,
+            interior_exposure: 2.5,
+            // MONKEY (soft falloff): 2.5, not 1 — see the field doc.
+            interior_atten_scale: 1.6,
+            interior_shadows: true,
+            // MONKEY (outdoor torch shadows): on — a night campfire with no shadow is the thing
+            // this lane exists to fix, and it costs nothing whenever the sun is up.
+            exterior_shadows: true,
+            // MONKEY (static torch cache): 12 resident maps, four moving-caster overlays.
+            interior_shadow_casters: 12,
+            interior_shadow_dynamic: 4,
+            // MONKEY (torch lane perf): 30 Hz - see the field doc.
+            interior_shadow_entity_rate: 30,
+            // MONKEY (pcss): 1.5 — see the field doc; `soft` is now the CONTACT radius.
+            interior_shadow_soft: 1.5,
+            // MONKEY (shadow floor): 0.7 — a shadow takes 70 % of the direct term, not all of it.
+            torch_shadow_strength: 0.7,
+            // MONKEY (room gate): on — without it a building's fixtures light through its own
+            // floors and walls.
+            interior_room_gate: true,
+            interior_debug: 0,
+            // MONKEY (lighting debug panel): nights 20 % darker, interior inputs 50 % weaker.
+            night_gain: 0.45,
+            interior_gain: 0.5,
+            // MONKEY (enclosed day floor): calibrated so the Goldshire inn's entry floor reads
+            // ~50 % of the sunlit threshold beside it — see `lighting::DAYLIGHT_LANE_SCALE`.
+            interior_daylight: 0.0,
+            // MONKEY (bake floor): an eighth of the authored bake — measured to lift the inn's
+            // black door band from 0.019 to 0.108 x tex while moving candle-lit surfaces by
+            // under 10 % (see `lighting::DynamicInteriors::bake_floor`).
+            interior_bake_floor: 0.12,
+            fire_light_gain: 1.0,
+            spell_light_gain: 1.0,
+            fire_flicker: 1.0,
             display: if windowed_env() {
                 DisplayMode::Windowed
             } else {
@@ -284,6 +507,115 @@ pub(crate) fn on_cvar(
         // Display mode (1627) — the reference's own polarity: `1` is WINDOWED (the row is
         // "Windowed Mode"). `apply_window_mode` pushes it to the window when this moves.
         "gxwindow" => cfg.display = display_from_flag(v),
+        // ── MONKEY (lighting): the dynamic light + shadow system's 29 rows ────────────────────
+        // They live in THIS observer, and not in one of their own beside `shadow_core` /
+        // `dynamic_interior`, because of the law the arm above states: *each arm writes only its
+        // own resource*. Every one of these knobs IS a field of [`VideoConfig`] — the lanes read
+        // that resource per frame (`shadow_core::update_shadows`, `dynamic_interior::bridge`,
+        // `torch_shadow`), none of them owns a resource of its own — so a second observer beside
+        // them would be a second writer of this one resource for no gain, splitting one match
+        // over two files while dirtying exactly the same thing.
+        //
+        // What it DOES cost is the precision of `Res<VideoConfig>::is_changed()`: on upstream's
+        // struct that signal means "a Video Options row moved", and here it means "a video OR a
+        // lighting row moved". The one consumer that cares is `apply_present_mode`, which keeps
+        // 2303's retired value compare for exactly this reason — see its doc.
+        //
+        // Clamps are each row's own, stated beside it, exactly as for the reference rows above;
+        // the `ours(...)` entries in `cvars::REGISTERED` carry the matching defaults, and
+        // `cvars::tests::registered_defaults_mirror_the_code_truths` welds all 29 pairs.
+        "worldshadows" => cfg.world_shadows = ev.flag(),
+        "charactershadows" => cfg.character_shadows = ev.flag(),
+        "shadowdistance" => {
+            cfg.shadow_distance = v.clamp(
+                *crate::shadow_core::SHADOW_DISTANCE_RANGE.start(),
+                *crate::shadow_core::SHADOW_DISTANCE_RANGE.end(),
+            )
+        }
+        // MONKEY (sun shadow perf): the five cost dials, clamped at the edge like every numeric row
+        // here. `shadowMapSize` SNAPS onto the power-of-two ladder rather than clamping into a
+        // range — an off-ladder value is not a weaker setting, it is one Bevy silently rounds UP
+        // into a bigger and slower map than the one that was typed.
+        "shadowmapsize" => {
+            cfg.shadow_map_size = crate::shadow_core::clamp_shadow_map_size(v.max(0.0) as u32)
+        }
+        "shadowfilter" => {
+            cfg.shadow_filter = (v.max(0.0) as u32).min(crate::shadow_core::MAX_SHADOW_FILTER)
+        }
+        // `0` is MEANINGFUL on both rate rows (the pre-cvar every-frame rebuild), so they floor at
+        // 0 rather than at 1 — the shadow off-switches are `characterShadows` / `worldShadows`.
+        "charactershadowrate" => {
+            cfg.character_shadow_rate =
+                (v.max(0.0) as u32).min(crate::shadow_core::MAX_SHADOW_RATE)
+        }
+        "worldshadowrate" => {
+            cfg.world_shadow_rate = (v.max(0.0) as u32).min(crate::shadow_core::MAX_SHADOW_RATE)
+        }
+        "shadowcasterreach" => {
+            cfg.shadow_caster_reach = v.clamp(
+                *crate::shadow_core::CASTER_REACH_RANGE.start(),
+                *crate::shadow_core::CASTER_REACH_RANGE.end(),
+            )
+        }
+        // MONKEY (dynamic interiors): the interior lane's on/off + knobs, clamped at the edge like
+        // every other numeric row. `dynamic_interior::bridge` publishes them to benilla-world.
+        "interiorlight" => cfg.interior_light = ev.flag(),
+        "interiorambient" => cfg.interior_ambient = v.clamp(0.0, 1.0),
+        "interiorfill" => cfg.interior_fill = v.clamp(0.0, 2.0),
+        "interiorexposure" => cfg.interior_exposure = v.clamp(0.25, 8.0),
+        // MONKEY (interior attenuation): the authored-window scale. `0` is a MEANINGFUL value here
+        // (the window off), so the range floors at 0 rather than at a small positive.
+        "interiorattenscale" => cfg.interior_atten_scale = v.clamp(0.0, 8.0),
+        "interiorroomgate" => cfg.interior_room_gate = ev.flag(),
+        "interiorshadows" => cfg.interior_shadows = ev.flag(),
+        // MONKEY (outdoor torch shadows): a flag like every other checkbox here. Live — the lane
+        // reads `VideoConfig` every frame, so `0` fades the outdoor shadows out (the slots evict
+        // through the same cross-fade a walked-away fixture does) and `1` fades them back in.
+        "exteriorshadows" => cfg.exterior_shadows = ev.flag(),
+        // MONKEY (torch caster selection): the working-set size and the PCF radius, clamped at the
+        // edge like every other numeric row. `casters` floors at 1, not 0 — `interiorShadows 0` is
+        // already the off switch, and a 0 here would be a second, confusing one.
+        "interiorshadowcasters" => cfg.interior_shadow_casters = (v.max(1.0) as u32).clamp(1, 16),
+        // MONKEY (static torch cache): the live bank rank, 1..`MAX_TORCH_DYNAMIC`.
+        "interiorshadowdynamic" => {
+            cfg.interior_shadow_dynamic =
+                (v.max(1.0) as u32).clamp(1, crate::torch_shadow::MAX_TORCH_DYNAMIC as u32)
+        }
+        // MONKEY (torch lane perf): the moving-caster regather cadence in Hz. `0` is MEANINGFUL
+        // here (every frame -- the behaviour before the gate), so unlike `casters` this floors at
+        // 0 rather than at 1. Ceiling 240 so a typo cannot ask for a per-frame rebuild AND a
+        // divide by a huge number; anything at or above the frame rate is already "every frame".
+        "interiorshadowentityrate" => {
+            cfg.interior_shadow_entity_rate = (v.max(0.0) as u32).min(240)
+        }
+        "interiorshadowsoft" => cfg.interior_shadow_soft = v.clamp(0.5, 3.0),
+        // MONKEY (shadow floor): 0 IS meaningful (shadows off), so this floors at 0, not at a
+        // minimum-useful value; 1 is the pre-feature pitch black.
+        "torchshadowstrength" => cfg.torch_shadow_strength = v.clamp(0.0, 1.0),
+        "interiordebug" => cfg.interior_debug = (v.max(0.0) as u32).min(4),
+        // MONKEY (darkness gains): the two dim dials, clamped at the edge like every numeric row
+        // here. The floor is 0.2 rather than 0: a true 0 would be indistinguishable from a broken
+        // light pack (black world / black room), and the off switch people actually want is `1`.
+        "nightgain" => cfg.night_gain = v.clamp(0.2, 1.5),
+        "interiorgain" => cfg.interior_gain = v.clamp(0.2, 1.5),
+        // MONKEY (enclosed day floor): 0 IS meaningful here (it restores the pre-feature look
+        // exactly), unlike the two dim dials above whose 0 would be a broken-looking world.
+        "interiordaylight" => cfg.interior_daylight = v.clamp(0.0, 1.0),
+        // MONKEY (bake floor): 0 IS meaningful here too (it restores the pre-feature look exactly).
+        // The upper clamp matters more than usual: the packer multiplies this by `interiorGain`
+        // (up to 1.5) and rides the product in a lane fraction that must stay under 0.5 after
+        // scaling, so a value that escaped this clamp would reach the world-shadow flag it shares
+        // a lane with. `pack_bake_lane` clamps the product too — belt and braces, one at each end.
+        "interiorbakefloor" => cfg.interior_bake_floor = v.clamp(0.0, 1.0),
+        // MONKEY (fire GO lights): the synthesised-fire gain, clamped at the edge like the rest.
+        "firelightgain" => cfg.fire_light_gain = v.clamp(0.0, 4.0),
+        // MONKEY (spellLightGain): the spell lane's gain, same range and same edge clamp — and `0`
+        // is meaningful here (the lane off) exactly as it is for the fire gain above.
+        "spelllightgain" => cfg.spell_light_gain = v.clamp(0.0, 4.0),
+        // MONKEY (flame flicker): 0..2 — the amplitudes are authored at 1, and 2 is the deliberate
+        // over-drive for judging the shape. Clamped at the edge like every knob here.
+        "fireflicker" => cfg.fire_flicker = v.clamp(0.0, 2.0),
+        // ── end MONKEY (lighting) ─────────────────────────────────────────────────────────────
         "farclip" => view.farclip = v.clamp(*FARCLIP_RANGE.start(), *FARCLIP_RANGE.end()),
         // The reference REFUSES an out-of-range write here rather than clamping (`0x688d90`
         // echoes "NearClip must be in range 0.01 - 0.33" and returns 0). We clamp, which is the
@@ -723,15 +1055,25 @@ fn display_session() -> String {
 /// First sight deliberately does **not** just arm: an inserted resource reads as changed on its
 /// first frame, and `load_config` applies the saved value at `Startup`, after the window already
 /// exists at its boot mode — so the first run is the one that reconciles them.
+///
+/// **MONKEY (lighting): the value compare 2303 retired is kept here, on top of `is_changed()`.**
+/// Upstream could drop it because on ITS `VideoConfig` every row is a Video Options row, so
+/// "the resource moved" and "a display row moved" are the same fact. This branch hangs 29
+/// lighting knobs off the same resource (`interiorGain`, `torchShadowStrength`, …), each written
+/// by its own arm of [`on_cvar`] — so `is_changed()` alone would let a `SetCVar("interiorGain")`
+/// re-assert the present mode, and the inner `!=` guard below would then happily undo exactly the
+/// probe override this gate exists to protect (a probe writes `AutoNoVsync` on the window while
+/// `cfg.vsync` still says on). `is_changed()` stays as the cheap pre-filter.
 fn apply_present_mode(
     cfg: Res<VideoConfig>,
     restarts: Res<GxRestarts>,
     mut windows: Query<&mut Window, With<PrimaryWindow>>,
+    mut last: Local<Option<bool>>,
     mut last_restart: Local<u32>,
 ) {
     // A `RestartGx()` re-asserts even when nothing moved — that is what the caller asked for.
     let forced = std::mem::replace(&mut *last_restart, restarts.0) != restarts.0;
-    if !cfg.is_changed() && !forced {
+    if (!cfg.is_changed() || last.replace(cfg.vsync) == Some(cfg.vsync)) && !forced {
         return;
     }
     let want = present_mode(cfg.vsync);
@@ -861,8 +1203,13 @@ mod tests {
         let mut app = App::new();
         app.insert_resource(VideoConfig {
             vsync: true,
+            world_shadows: false,
+            character_shadows: false,
+            shadow_distance: 80.0,
             display: DisplayMode::Fullscreen,
             windowed: UVec2::new(1024, 768),
+            // MONKEY (review fixes): this window test inherits unrelated lighting defaults.
+            ..Default::default()
         })
         // The plugin's resource, seated by hand because this test runs the one system rather than
         // the plugin — `apply_window_mode` reads it to know a `RestartGx()` asked for a re-assert.
diff --git a/crates/benilla-app/src/world_shadow.rs b/crates/benilla-app/src/world_shadow.rs
new file mode 100644
index 00000000..c3bd7662
--- /dev/null
+++ b/crates/benilla-app/src/world_shadow.rs
@@ -0,0 +1,344 @@
+//! The WORLD shadow lane — a thin plug-in on top of [`super::shadow_core`], equal to and independent
+//! of [`super::character_shadow`].
+//!
+//! It owns the shadows cast by the WORLD: the retained `static_gx` geometry (trees + buildings, cast
+//! solid), the alpha-tested foliage (leaf canopies, one caster per leaf texture), and the per-frame
+//! ENTITY-resident environment (gameobjects, distance-faded doodads, WMO props). When `worldShadows`
+//! is on it declares demand to the shared rig and, while the rig is live, builds those casters using
+//! the rig's shared material + per-frame facts ([`ShadowFrame`]). It also drives the terrain
+//! MCSH-suppression flag ([`WorldShadowActive`]) — baked terrain shadows switch off only for THIS
+//! lane. Remove this module + its plugin registration + the `worldShadows` cvar and the character
+//! lane is untouched.
+//!
+//! Cadence: the static world doesn't move, so its solid + cutout casters rebuild only on camera
+//! drift ([`STATIC_REBUILD_STEP`]); the environment-entity caster (doodads fade in/out, gameobjects
+//! spawn) is collected fresh every frame like the character lane.
+
+use bevy::asset::AssetId;
+use bevy::camera::visibility::{NoFrustumCulling, RenderLayers};
+use bevy::image::Image;
+use bevy::light::NotShadowReceiver;
+use bevy::mesh::Indices;
+use bevy::pbr::{Material, MaterialPipeline, MaterialPlugin, MeshMaterial3d};
+use bevy::platform::collections::HashSet;
+use bevy::prelude::*;
+use bevy::reflect::TypePath;
+use bevy::render::render_resource::{
+    AsBindGroup, RenderPipelineDescriptor, SpecializedMeshPipelineError,
+};
+use bevy::shader::ShaderRef;
+
+use benilla_assets::materials::WowModelMaterial;
+use benilla_world::billboard::BillboardCard;
+use benilla_world::interact::PickMesh;
+use benilla_world::lighting::WorldShadowActive;
+use benilla_world::model_render::{ModelPart, ShadowOccluder};
+use benilla_world::rig_palette::{RigPalettes, RigPart, RigSkin};
+use benilla_world::static_gx::StaticGx;
+
+use crate::shadow_core::{
+    collect_entity_geometry, empty_cutout_mesh, empty_shadow_mesh, restore_mesh_buffers,
+    shadow_trace, spawn_solid_caster, take_mesh_buffers, RebuildRate, ShadowCaster, ShadowDemand,
+    ShadowFrame, ShadowSet, PLAYER_SHADOW_LAYER, STATIC_REBUILD_STEP,
+};
+use crate::video::VideoConfig;
+
+pub(crate) struct WorldShadowPlugin;
+
+impl Plugin for WorldShadowPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(MaterialPlugin::<CutoutShadowCasterMaterial>::default())
+            .init_resource::<WorldLane>()
+            .add_systems(Last, update_world_shadows.in_set(ShadowSet::Lanes));
+    }
+}
+
+/// The alpha-tested twin of [`ShadowCasterMaterial`]: same invisible-in-forward proxy, but its
+/// prepass fragment samples a leaf sheet and discards transparent texels so cutout FOLIAGE casts a
+/// leaf-shaped silhouette instead of the solid box a positions-only proxy throws. One instance per
+/// distinct leaf texture. `AlphaMode::Mask` sets Bevy's `MAY_DISCARD` key and the EXPLICIT
+/// `prepass_fragment_shader` makes the otherwise depth-only directional-shadow pass run a fragment —
+/// the exact pair Bevy's prepass specializer requires to alpha-test in the shadow map.
+#[derive(Asset, AsBindGroup, TypePath, Debug, Clone)]
+struct CutoutShadowCasterMaterial {
+    /// The leaf sheet, bound at material binding 0/1. Reusing the SAME image handle the forward pass
+    /// draws makes the sampler inherit that image's clamp/repeat address mode, so the shadow
+    /// silhouette matches the visible foliage (a cutout card's out-of-range UVs must clamp).
+    #[texture(0)]
+    #[sampler(1)]
+    leaf: Handle<Image>,
+}
+
+impl Material for CutoutShadowCasterMaterial {
+    fn fragment_shader() -> ShaderRef {
+        // Forward pass: still fully invisible — the shared proxy fragment discards every fragment.
+        "embedded://benilla_app/shaders/shadow_caster.wgsl".into()
+    }
+
+    fn prepass_fragment_shader() -> ShaderRef {
+        // EXPLICIT → the shadow pass runs this fragment for the MAY_DISCARD material and alpha-tests.
+        "embedded://benilla_app/shaders/shadow_caster_cutout_prepass.wgsl".into()
+    }
+
+    fn alpha_mode(&self) -> AlphaMode {
+        AlphaMode::Mask(benilla_assets::materials::VANILLA_ALPHA_KEY_REF)
+    }
+
+    fn specialize(
+        _pipeline: &MaterialPipeline,
+        descriptor: &mut RenderPipelineDescriptor,
+        _layout: &bevy::mesh::MeshVertexBufferLayoutRef,
+        _key: bevy::pbr::MaterialPipelineKey<Self>,
+    ) -> Result<(), SpecializedMeshPipelineError> {
+        // Two-sided like the solid caster; applies to the shadow (prepass) pipeline too.
+        descriptor.primitive.cull_mode = None;
+        Ok(())
+    }
+}
+
+/// One live alpha-tested foliage caster: its layer-31 entity, its per-texture mesh, and the material
+/// carrying that one leaf sheet. Keyed by the leaf texture's `AssetId` so it persists across rebuilds.
+struct CutoutCaster {
+    entity: Entity,
+    mesh: Handle<Mesh>,
+    material: Handle<CutoutShadowCasterMaterial>,
+}
+
+/// The world lane's retained casters.
+#[derive(Resource, Default)]
+struct WorldLane {
+    /// The cached static caster — the retained `static_gx` world (trees + buildings), rebuilt on drift.
+    static_caster: Option<Entity>,
+    static_mesh: Option<Handle<Mesh>>,
+    static_rebuilt_at: Option<Vec3>,
+    /// The alpha-tested foliage casters — one per distinct leaf texture.
+    cutout: bevy::platform::collections::HashMap<AssetId<Image>, CutoutCaster>,
+    /// The per-frame ENTITY-resident environment caster (gameobjects, faded doodads, WMO props).
+    env_caster: Option<Entity>,
+    env_mesh: Option<Handle<Mesh>>,
+    env_traced: (u32, u32, u32),
+    /// MONKEY (sun shadow perf): the `worldShadowRate` cadence gate on the ENVIRONMENT caster only.
+    /// The static solid + cutout casters keep their own, much coarser cadence (16 yd camera drift).
+    env_rate: RebuildRate,
+}
+
+#[allow(clippy::too_many_arguments)]
+fn update_world_shadows(
+    video: Res<VideoConfig>,
+    time: Res<Time>,
+    mut demand: ResMut<ShadowDemand>,
+    frame: Res<ShadowFrame>,
+    mut lane: ResMut<WorldLane>,
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut cutout_materials: ResMut<Assets<CutoutShadowCasterMaterial>>,
+    // The retained static world — `Option` because it exists only when the retained pass is armed.
+    gx: Option<Res<StaticGx>>,
+    // The terrain MCSH-suppression flag (this lane owns it).
+    mut world_active: ResMut<WorldShadowActive>,
+    parts: Query<
+        (
+            &PickMesh,
+            &ModelPart,
+            Option<&GlobalTransform>,
+            Option<&RigPart>,
+            &ShadowOccluder,
+            Option<&MeshMaterial3d<WowModelMaterial>>,
+        ),
+        Without<BillboardCard>,
+    >,
+    rigs: Query<&RigSkin>,
+    palettes: Res<RigPalettes>,
+) {
+    // Declare demand so the shared rig stays up while this lane is on (rig reads it next frame).
+    demand.0 = demand.0 || video.world_shadows;
+    // The lane is casting when the rig is live AND its cvar is on. The MCSH terrain-shadow
+    // suppression keys on exactly this (a character-only shadow sun must leave baked MCSH alone).
+    let world_on = frame.active && video.world_shadows;
+    if world_active.0 != world_on {
+        world_active.0 = world_on;
+    }
+
+    if !world_on {
+        teardown(&mut lane, &mut commands, &mut meshes, &mut cutout_materials);
+        return;
+    }
+    let Some(material) = frame.material.clone() else {
+        return;
+    };
+
+    // (1) The per-frame ENTITY-resident environment caster (opaque doodads/gameobjects/WMO props).
+    if lane.env_caster.is_none() {
+        let mesh = meshes.add(empty_shadow_mesh());
+        let entity = spawn_solid_caster(&mut commands, mesh.clone(), material.clone());
+        lane.env_caster = Some(entity);
+        lane.env_mesh = Some(mesh);
+        // A brand-new caster is an EMPTY mesh; make sure this frame fills it.
+        lane.env_rate.reset();
+    }
+    // MONKEY (sun shadow perf): the `worldShadowRate` gate — the world lane's twin of the character
+    // lane's. Only THIS caster is paced: the static solid + cutout casters below already rebuild on
+    // 16 yd of camera drift and cost nothing on a standing frame. Skipping leaves the previous
+    // environment proxy in place (the map is still rendered from it every frame), so the only
+    // visible effect is a swinging lamp's or a fading doodad's shadow lagging by up to 1/rate s.
+    //
+    // Its own cvar rather than sharing `characterShadowRate`: this population barely moves, so it
+    // tolerates a far lower rate than an animated crowd does, and a dial named for characters that
+    // silently also governs the world is a trap for whoever reads this next.
+    let env_due = lane.env_rate.due(time.elapsed_secs(), video.world_shadow_rate);
+    if let Some(handle) = lane.env_mesh.clone().filter(|_| env_due) {
+        if let Some(mesh) = meshes.get_mut(&handle) {
+            let (mut positions, mut indices) = take_mesh_buffers(mesh);
+            let (admitted, rejected) = collect_entity_geometry(
+                &parts,
+                &rigs,
+                &palettes,
+                false, // want_creatures (the character lane's job)
+                true,  // want_environment
+                frame.light_position,
+                frame.entity_reach,
+                frame.tall_reach,
+                &mut positions,
+                &mut indices,
+            );
+            let tris = (indices.len() / 3) as u32;
+            restore_mesh_buffers(mesh, positions, indices);
+            if shadow_trace() {
+                let now = (tris, admitted, rejected);
+                if lane.env_traced != now {
+                    info!(
+                        "shadow-trace: world-entity {} tris | env admitted {} / rejected {} (was {:?})",
+                        tris, admitted, rejected, lane.env_traced
+                    );
+                    lane.env_traced = now;
+                }
+            }
+        }
+    }
+
+    // (2) The cached static world (trees + buildings) + alpha-tested foliage — rebuilt on drift.
+    let Some(gx) = gx.as_ref() else {
+        return;
+    };
+    // Ensure the static SOLID caster.
+    if lane.static_caster.is_none() {
+        let mesh = meshes.add(empty_shadow_mesh());
+        let entity = spawn_solid_caster(&mut commands, mesh.clone(), material);
+        lane.static_caster = Some(entity);
+        lane.static_mesh = Some(mesh);
+        lane.static_rebuilt_at = None;
+    }
+    let due = lane
+        .static_rebuilt_at
+        .map_or(true, |at| at.distance(frame.light_position) > STATIC_REBUILD_STEP);
+    if !due {
+        return;
+    }
+
+    // Solid pass — the retained world's opaque geometry (minus the cutout foliage it skips).
+    if let Some(handle) = lane.static_mesh.clone() {
+        if let Some(mesh) = meshes.get_mut(&handle) {
+            let (mut positions, mut indices) = take_mesh_buffers(mesh);
+            gx.append_shadow_triangles(
+                frame.light_position,
+                frame.tall_reach,
+                &mut positions,
+                &mut indices,
+            );
+            let tris = (indices.len() / 3) as u32;
+            restore_mesh_buffers(mesh, positions, indices);
+            lane.static_rebuilt_at = Some(frame.light_position);
+            if shadow_trace() {
+                info!(
+                    "shadow-trace: static rebuild — {} tris within {:.0}yd",
+                    tris, frame.tall_reach
+                );
+            }
+        }
+    }
+
+    // Alpha-tested foliage pass — the cutout leaf cards, grouped one caster per leaf texture.
+    let buckets = gx.collect_cutout_shadow_triangles(frame.light_position, frame.tall_reach);
+    let mut seen: HashSet<AssetId<Image>> = HashSet::new();
+    let mut cutout_tris = 0u32;
+    for bucket in buckets {
+        seen.insert(bucket.texture_id);
+        cutout_tris += (bucket.indices.len() / 3) as u32;
+        if !lane.cutout.contains_key(&bucket.texture_id) {
+            let mesh = meshes.add(empty_cutout_mesh());
+            let material = cutout_materials.add(CutoutShadowCasterMaterial {
+                leaf: bucket.texture.clone(),
+            });
+            let entity = commands
+                .spawn((
+                    Mesh3d(mesh.clone()),
+                    MeshMaterial3d(material.clone()),
+                    Transform::IDENTITY,
+                    Visibility::Visible,
+                    RenderLayers::layer(PLAYER_SHADOW_LAYER),
+                    NoFrustumCulling,
+                    NotShadowReceiver,
+                    ShadowCaster,
+                ))
+                .id();
+            lane.cutout
+                .insert(bucket.texture_id, CutoutCaster { entity, mesh, material });
+        }
+        let mesh_handle = lane.cutout[&bucket.texture_id].mesh.clone();
+        if let Some(mesh) = meshes.get_mut(&mesh_handle) {
+            mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, bucket.positions);
+            mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, bucket.uvs);
+            mesh.insert_indices(Indices::U32(bucket.indices));
+        }
+    }
+    // Despawn casters whose leaf texture left the reach, so the set stays bounded across zones.
+    let stale: Vec<AssetId<Image>> = lane
+        .cutout
+        .keys()
+        .filter(|id| !seen.contains(*id))
+        .copied()
+        .collect();
+    for id in stale {
+        if let Some(caster) = lane.cutout.remove(&id) {
+            commands.entity(caster.entity).despawn();
+            meshes.remove(caster.mesh.id());
+            cutout_materials.remove(caster.material.id());
+        }
+    }
+    if shadow_trace() {
+        info!(
+            "shadow-trace: cutout rebuild — {} tris across {} leaf textures",
+            cutout_tris,
+            lane.cutout.len()
+        );
+    }
+}
+
+/// Tear down every world-lane caster (static solid, all foliage casters, the environment caster).
+fn teardown(
+    lane: &mut WorldLane,
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    cutout_materials: &mut Assets<CutoutShadowCasterMaterial>,
+) {
+    if let Some(entity) = lane.static_caster.take() {
+        commands.entity(entity).despawn();
+    }
+    if let Some(handle) = lane.static_mesh.take() {
+        meshes.remove(handle.id());
+    }
+    lane.static_rebuilt_at = None;
+    for (_texture, caster) in lane.cutout.drain() {
+        commands.entity(caster.entity).despawn();
+        meshes.remove(caster.mesh.id());
+        cutout_materials.remove(caster.material.id());
+    }
+    if let Some(entity) = lane.env_caster.take() {
+        commands.entity(entity).despawn();
+    }
+    if let Some(handle) = lane.env_mesh.take() {
+        meshes.remove(handle.id());
+    }
+    // The mesh the gate was pacing is gone — re-arm so a re-enable builds on its first frame.
+    lane.env_rate.reset();
+}
diff --git a/crates/benilla-assets/src/lib.rs b/crates/benilla-assets/src/lib.rs
index fd8411af..16c7d356 100644
--- a/crates/benilla-assets/src/lib.rs
+++ b/crates/benilla-assets/src/lib.rs
@@ -57,6 +57,9 @@ mod m2;
 pub use m2::{
     EmitterBillboard, M2Model, M2ModelLoader, M2SequenceInfo, ModelEmitter, ModelLight,
     ModelRibbon, PortraitCamera,
+    // MONKEY (spell light): what a spell/firework-derived light carries beyond the light itself
+    // (its school and its onset) — see [`ModelLight::spell`].
+    SpellLightInfo,
 };
 mod wmo;
 pub use benilla_formats::{WmoPortalInfo, WmoPortalRef};
diff --git a/crates/benilla-assets/src/m2.rs b/crates/benilla-assets/src/m2.rs
index 3ccfc0e7..49339370 100644
--- a/crates/benilla-assets/src/m2.rs
+++ b/crates/benilla-assets/src/m2.rs
@@ -367,6 +367,59 @@ pub struct ModelRibbon {
 pub struct ModelLight {
     pub def: M2Light,
     pub bone_pivot: [f32; 3],
+    /// MONKEY (fire GO lights): `true` when this light was **synthesised** from the model's flame
+    /// particle emitter rather than read off an authored light block
+    /// ([`benilla_formats::fire_light`]). Only ~17 of the ~430 fire-ish props in the chain author
+    /// one, so without this every wall torch, magic brazier, forge and candle in the game lights
+    /// nothing.
+    ///
+    /// The flag exists so a lane can REFUSE it, and one does: the WMO MODD prop lane. A building's
+    /// own MOLT fixtures already sit at its wall torches' flames (the artists place a companion
+    /// MOLT per fixture doodad — NSabbey ships one per candelabra), so a synthetic light on the
+    /// prop would double-light exactly the interiors that are already correct. Every other lane —
+    /// ADT map doodads, GameObjects/creatures, transport props — takes it like an authored one.
+    pub synthetic: bool,
+    /// MONKEY (flame flicker): `true` when the synthesis took the **FLAME** route — an additive
+    /// fire particle emitter ([`benilla_formats::synthesize_fire_light`]) — as opposed to the LAMP
+    /// route ([`benilla_formats::synthesize_lamp_light`]: a lamppost's unlit glass geoset). Always
+    /// `false` on an authored block.
+    ///
+    /// `synthetic` alone cannot answer this, and the difference is exactly what decides whether the
+    /// light FLICKERS: an open flame does, and a flame of any colour does (the ogre's purple wall
+    /// torch and `HumanBrazierMagic`'s green fire are fires with odd chemistry); a lamp behind
+    /// glass does not, and a street lamp that breathed would read as a fault in the city rather
+    /// than as fire. Keying on the ROUTE rather than on the hue is what gets both right — see
+    /// `benilla_world::lighting::flame_kind_for`.
+    pub flame: bool,
+    /// MONKEY (spell light): `true` when this light came from the **SPELL** route
+    /// ([`benilla_formats::synthesize_spell_light`]) — a spell effect's or a firework's emitter.
+    /// Always `false` on an authored block and on the two world routes.
+    ///
+    /// It exists so the PLACED lanes can keep refusing spell content exactly as they did before
+    /// this feature (`benilla_world::terrain_stream::spawn`'s `spawn_lights_for`): the world light
+    /// table is built for fixtures that stand still for minutes, and an effect model that happens
+    /// to be placed as scenery must not enter it. Only the ENTITY lanes — a spell-visual instance,
+    /// a missile, a firework GameObject — take it, and there it is budgeted, enveloped and reaped
+    /// with its effect (`entities::carried_light`'s spell-light helper).
+    ///
+    /// It also carries the light's **onset**: `benilla_formats::fire_light::emit_onset`, the delay
+    /// before the emitter this light stands for actually fires. A firework's shell detonates half
+    /// a second into its model's clip, and a light lit at spawn would flash the rocket's flight
+    /// instead of its burst.
+    pub spell: Option<SpellLightInfo>,
+}
+
+/// MONKEY (spell light): what a spell/firework-derived [`ModelLight`] carries beyond the light
+/// itself — see [`ModelLight::spell`].
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SpellLightInfo {
+    /// The school judged at synthesis ([`benilla_formats::SpellLightKind`]) — for the trace and
+    /// for any future per-school gain. Never `None` (that case yields no light at all).
+    pub kind: benilla_formats::SpellLightKind,
+    /// Seconds from the instance's birth before the light comes up (the emitter's rate-track
+    /// onset). `0.0` for everything with a constant emission rate, which is every missile and
+    /// every kit glow.
+    pub onset: f32,
 }
 
 /// Bevy [`AssetLoader`] decoding `*.m2` → [`M2Model`].
@@ -549,7 +602,7 @@ impl AssetLoader for M2ModelLoader {
 
         // M2 lights: the same host-bone pivot bake, so a light on an animating model (the torch in
         // an NPC's hand) can ride its bone's joint instead of freezing at the rest-pose spot.
-        let lights = light_defs
+        let mut lights: Vec<ModelLight> = light_defs
             .into_iter()
             .map(|def| ModelLight {
                 bone_pivot: skeleton_raw
@@ -557,8 +610,129 @@ impl AssetLoader for M2ModelLoader {
                     .get(def.bone as usize)
                     .map_or([0.0; 3], |b| b.pivot),
                 def,
+                synthetic: false,
+                flame: false,
+                spell: None,
             })
             .collect();
+        // MONKEY (fire GO lights) / MONKEY (lamp lights): a prop that authors NO casting light gets
+        // ONE derived from what it DOES author — its flame emitter, or (lamps, lanterns, sconces,
+        // chandeliers, which author no particles whatsoever) its unlit glass geoset. Both rules,
+        // their calibration and the `benilla-extract m2firescan` audit live in
+        // [`benilla_formats::fire_light`]. This is the single site the synthesis happens, so every
+        // lane that already consumes `M2Model::lights` inherits it for free and nothing downstream
+        // has to know an emitter or a render batch was ever read.
+        //
+        // Gated on `casts()` and not on emptiness: an authored block ALWAYS wins, including the
+        // directional-only and visibility-off shapes — a model whose one light block is authored
+        // dark was authored dark on purpose.
+        if !lights.iter().any(|l| l.def.casts()) {
+            let path = ctx.path().path().to_string_lossy().to_string();
+            // The FLAME route first, then the LAMP route — never both. The flame wins because it
+            // carries a REAL colour (read off the artist's own over-life ramp) where the lamp route
+            // can only pick a plausible one from a name; a model with both a flame and lamp glass
+            // (`OrcBrazierStreetLamp`) should take the measured hue, not the guessed one. Each
+            // yields the same four things: model-space position, host bone, colour, intensity —
+            // plus, MONKEY (flame flicker), WHICH route won, because that is what decides whether
+            // the light burns (flickers) or merely shines (see [`ModelLight::flame`]).
+            //
+            // MONKEY (spell light): and a THIRD route ahead of both — SPELL effects and FIREWORKS,
+            // which the two world rules veto by path (`fire_light::is_spell_path`). They are put
+            // first because the veto is theirs: a model that IS spell content can never be a
+            // placed prop, so there is nothing for the other two to say about it. What comes back
+            // is flagged ([`ModelLight::spell`]) so the PLACED lanes can keep refusing it exactly
+            // as they do today — only the entity lanes, which reap a light with its effect, take
+            // one.
+            let synth = benilla_formats::synthesize_spell_light(
+                &path,
+                emitters.iter().map(|e| &e.def),
+            )
+            .map(|fx| {
+                let src = &emitters[fx.emitter].def;
+                (
+                    src.position,
+                    src.bone,
+                    fx.color,
+                    fx.intensity,
+                    // Never a FLAME for the flicker's purposes: a spell light runs its own
+                    // lifecycle envelope (ramp in / hold / decay) and a fire wobble on top of it
+                    // would read as the effect stuttering, not as fire breathing.
+                    false,
+                    Some(SpellLightInfo {
+                        kind: fx.kind,
+                        onset: fx.onset,
+                    }),
+                )
+            })
+            .or_else(|| {
+                benilla_formats::synthesize_fire_light(&path, emitters.iter().map(|e| &e.def)).map(
+                    |fire| {
+                        let src = &emitters[fire.emitter].def;
+                        (
+                            src.position,
+                            src.bone,
+                            fire.color,
+                            fire.intensity,
+                            true,
+                            None,
+                        )
+                    },
+                )
+            })
+            .or_else(|| {
+                // MONKEY (lamp lights): a lamppost/lantern/chandelier authors NO particle emitter
+                // at all — its glow is an UNLIT (render-flag 0x01) glass geoset. The rule reads the
+                // already-built render batches, so nothing extra is parsed; the position it returns
+                // is that geoset's CENTROID (the lamp head, 4-5 yd up a lamppost), never the model
+                // origin at the base of the pole. `bounds` is the fallback for a name-route hit
+                // whose glass we can't find — see `fire_light::lamp_position`.
+                let batches: Vec<benilla_formats::EmissiveBatch<'_>> = submeshes
+                    .iter()
+                    .map(|s| benilla_formats::EmissiveBatch::from(&*s.geometry))
+                    .collect();
+                let bbox = bounds.as_ref().map(|b| (b.bbox_min, b.bbox_max));
+                benilla_formats::synthesize_lamp_light(&path, &batches, bbox)
+                    .map(|l| (l.position, l.bone, l.color, l.intensity, false, None))
+            });
+            if let Some((position, src_bone, color, intensity, flame, spell)) = synth {
+                // The light sits at the FLAME (or the lamp glass), not the model origin: a brazier's
+                // origin is under its bowl, and a light there back-lights the bowl into every
+                // surface it should be lighting (and self-shadows through the prop's own caster
+                // mesh, which the torch lane includes). Same bone convention as an authored light —
+                // a bone the skeleton doesn't carry reads as `-1` (model origin), which is what a
+                // boneless prop is.
+                let bone = i16::try_from(src_bone)
+                    .ok()
+                    .filter(|_| (src_bone as usize) < skeleton_raw.bones.len())
+                    .unwrap_or(-1);
+                lights.push(ModelLight {
+                    def: M2Light {
+                        light_type: 1, // point — the hot-spot caster; the whole reason we're here
+                        bone,
+                        position,
+                        // Diffuse only, like every world light the reference commits (its ambient
+                        // and specular are zero on world props — decision 0273).
+                        ambient_color: [0.0; 3],
+                        ambient_intensity: 0.0,
+                        diffuse_color: color,
+                        diffuse_intensity: intensity,
+                        // The GL curve is fixed (`1/(0.7d+0.03d²)`) and ignores these; they are a
+                        // cull hint no consumer reads, so a synthesised light authors none.
+                        attenuation_start: 0.0,
+                        attenuation_end: 0.0,
+                        bone_z: [0.0, 0.0, 1.0], // point lights have no direction basis
+                        visibility_off: false,
+                    },
+                    bone_pivot: skeleton_raw
+                        .bones
+                        .get(src_bone as usize)
+                        .map_or([0.0; 3], |b| b.pivot),
+                    synthetic: true,
+                    flame,
+                    spell,
+                });
+            }
+        }
         let (skeleton, inverse_bindposes) = build_skeleton(&skeleton_raw);
         let inverse_bindposes = ctx.add_labeled_asset(
             "inverse_bindposes".to_string(),
diff --git a/crates/benilla-assets/src/materials.rs b/crates/benilla-assets/src/materials.rs
index df83291d..2dbcd523 100644
--- a/crates/benilla-assets/src/materials.rs
+++ b/crates/benilla-assets/src/materials.rs
@@ -36,9 +36,9 @@ use bevy::render::render_resource::{
     AsBindGroup, BlendComponent, BlendFactor, BlendOperation, BlendState, Buffer, ColorWrites,
     CompareFunction, RenderPipelineDescriptor, SpecializedMeshPipelineError,
 };
-use bevy::shader::ShaderRef;
+use bevy::shader::{load_shader_library, ShaderRef};
 
-/// Compile the four WGSL files into the binary and register them under
+/// Compile the WGSL files into the binary and register them under
 /// `embedded://benilla_assets/shaders/…`. Call **after** Bevy's `AssetPlugin` (it fills the
 /// registry that plugin creates); [`crate::register_asset_loaders`] already does.
 pub fn register_shaders(app: &mut App) {
@@ -46,6 +46,10 @@ pub fn register_shaders(app: &mut App) {
     bevy::asset::embedded_asset!(app, "shaders/wow_model.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/wdl.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/liquid.wgsl");
+    // MONKEY (shadow hook): register the importable shadow-contribution library `benilla::shadow_hook`
+    // (loaded eagerly so `#import benilla::shadow_hook` resolves in terrain/model/static_gx). This is
+    // the ONE place the realtime directional-shadow term lives; the receivers just call into it.
+    load_shader_library!(app, "shaders/shadow_hook.wgsl");
 }
 
 /// The WDL far-band shader's source, for the law tests that live beside the renderer rather than
@@ -224,6 +228,43 @@ pub struct WowModelExt {
     /// Set once, never mutated.
     #[storage(90, read_only, buffer, visibility(vertex, fragment))]
     pub light_buf: Buffer,
+    /// MONKEY (torch shadows Phase 3A): the interior torch depth-map ARRAY — the one shared
+    /// `Depth32Float` 512×512×24 `Image` (4 fixtures × 6 cube faces) the torch depth node renders
+    /// into each frame (`benilla_world::static_gx::torch_depth`, `TorchDepthImage`). Bound as a
+    /// depth 2D-array + the image's own `GreaterEqual` comparison sampler (the `Image`'s
+    /// `ImageSamplerDescriptor { compare: Some(GreaterEqual) }` — bevy builds a real comparison
+    /// sampler from it; the derive's prepare-time check requires the format's sample type to be
+    /// `Depth`, which `Depth32Float` is). The image is created ONCE at app startup regardless of
+    /// the cvars — an absent image would stall every model material's bind group on
+    /// `RetryNextUpdate` and blank every model. Fragment-only, like static_gx's group 3.
+    #[texture(91, dimension = "2d_array", sample_type = "depth", visibility(fragment))]
+    #[sampler(92, sampler_type = "comparison", visibility(fragment))]
+    pub torch_depth: Handle<Image>,
+    /// MONKEY (static torch cache): the ≤16-fixture torch TABLE — the same 6416-byte
+    /// `TorchTableUniform` bytes static_gx's group-3 uniform carries (count / positions[16] /
+    /// view_projs[96]), as a SEPARATE shared raw buffer (`SharedTorchBuffer`) rewritten in place
+    /// every frame from `TorchShadowViews`. A raw `Buffer` like `light_buf`, deliberately NOT a
+    /// `#[uniform]` field (a per-frame-mutated uniform re-prepares every material every frame)
+    /// and NOT a region of the shared light blob (whose `LightStd430` mirror + the booth packer
+    /// would all have to grow in lock-step). `wow_model.wgsl` reads it as
+    /// `var<storage, read> torch_table` (std430 of this struct == the std140 6416 bytes: every
+    /// member is 16-aligned). Set once, never mutated.
+    #[storage(93, read_only, buffer, visibility(fragment))]
+    pub torch_buf: Buffer,
+}
+
+/// MONKEY (torch shadows Phase 3A): the two torch-receiver bindings every [`WowModelExt`] shares —
+/// threaded into the material builders beside the shared light `Buffer`, and stored on
+/// `WorldAssets` the same way. Both come from the client's startup resources
+/// (`benilla_world::static_gx::{TorchDepthImage, SharedTorchBuffer}`); this crate only clones them
+/// into materials, which is why it takes the raw handle + buffer and not those resources (the same
+/// severing `WorldAssets::open` does for the light buffer, decision 1164).
+#[derive(Clone)]
+pub struct TorchBinds {
+    /// The shared torch depth array image (→ `WowModelExt::torch_depth`).
+    pub depth: Handle<Image>,
+    /// The shared 6416-byte torch table buffer (→ `WowModelExt::torch_buf`).
+    pub table: Buffer,
 }
 
 impl MaterialExtension for WowModelExt {
@@ -259,6 +300,12 @@ impl MaterialExtension for WowModelExt {
         // at 10/11. Bevy's own SKINNED branch never fires for these meshes — that's the point.
         if layout.0.contains(crate::ATTRIBUTE_WOW_JOINT_INDEX) {
             descriptor.vertex.shader_defs.push("WOW_RIG_SKIN".into());
+            // The FRAGMENT stage keys on the same def: a skinned unit takes the whole-unit
+            // ground-point shadow sample (one fetch at its rig origin) instead of the
+            // per-fragment fetch, which would read the unit's own caster copy as an occluder.
+            if let Some(fragment) = descriptor.fragment.as_mut() {
+                fragment.shader_defs.push("WOW_RIG_SKIN".into());
+            }
             let mut attrs = Vec::with_capacity(7);
             for (attr, loc) in [
                 (Mesh::ATTRIBUTE_POSITION, 0),
@@ -638,6 +685,24 @@ pub struct TerrainExtension {
     /// `terrain.wgsl` reads it as `var<storage, read> wow_light` (rows 0-5: light + fog + farclip).
     #[storage(90, read_only, buffer)]
     pub light_buf: Buffer,
+    /// MONKEY (outdoor torch shadows: terrain): the torch receiver's three bindings, at the SAME
+    /// numbers [`WowModelExt`] uses (91 depth array / 92 comparison sampler / 93 table) and for the
+    /// same reason - a Bevy material draw sets groups 0/1/2 only, so a receiver's shadow inputs have
+    /// to ride its own material group. Both resources are created ONCE at startup
+    /// (`benilla_world::assets`, beside the shared light buffer) and are ALWAYS bound: a missing
+    /// image would stall the tile's bind group on `RetryNextUpdate` and blank the GROUND, so the
+    /// spawn site idles until `TorchShared::binds()` is `Some` rather than baking a default.
+    ///
+    /// Fragment-only, like the splat/alpha/shadow arrays above (Bevy 0.18 narrows textures and
+    /// samplers but not uniforms) - the vertex stage only picks WHICH lights, it never samples.
+    #[texture(91, dimension = "2d_array", sample_type = "depth", visibility(fragment))]
+    #[sampler(92, sampler_type = "comparison", visibility(fragment))]
+    pub torch_depth: Handle<Image>,
+    /// The 6416-byte `TorchTableUniform` bytes (count / positions[16] / view_projs[96]) as the same
+    /// shared raw storage buffer the model lane binds, rewritten in place each frame - read by
+    /// `terrain.wgsl` as the byte-identical `var<storage, read> torch_table: TorchTable`.
+    #[storage(93, read_only, buffer, visibility(fragment))]
+    pub torch_buf: Buffer,
 }
 
 impl MaterialExtension for TerrainExtension {
@@ -653,6 +718,73 @@ impl MaterialExtension for TerrainExtension {
 
 #[cfg(test)]
 mod tests {
+    /// MONKEY (outdoor torch shadows: terrain): the GROUND receiver's three contracts with the
+    /// model lane, all of which fail SILENTLY at runtime rather than at compile time.
+    ///
+    /// 1. **The bindings.** `TerrainExtension` and [`WowModelExt`] must claim the SAME numbers
+    ///    (91 depth / 92 comparison sampler / 93 table). The Rust attributes and the WGSL `@binding`
+    ///    lines are two independent declarations of one layout, and a mismatch is not a build error
+    ///    — it is a bind-group validation failure at first tile spawn, i.e. no ground.
+    /// 2. **The table layout.** All three receivers (`terrain.wgsl`, `wow_model.wgsl`, and
+    ///    `static_gx.wgsl`'s std140 twin) mirror ONE 6416-byte buffer. Comments differ per lane on
+    ///    purpose; the member lines must not, or terrain reads matrices at the wrong offsets and
+    ///    projects shadows to the wrong place with nothing in any log.
+    /// 3. **Daytime identity.** The night lane must stay behind `ext_night_w > 0.0`. `fog_params.z`
+    ///    saturates to exactly 1.0 above the daylight threshold, so that guard is what makes the
+    ///    day render the same instructions AND the same bits it was before this feature — the whole
+    ///    "cost zero by day" claim, in one line of shader.
+    #[test]
+    fn the_terrain_lane_receives_the_torch_maps() {
+        let terrain = include_str!("shaders/terrain.wgsl");
+        let model = include_str!("shaders/wow_model.wgsl");
+
+        for binding in [
+            "@binding(91) var torch_depth: texture_depth_2d_array;",
+            "@binding(92) var torch_samp: sampler_comparison;",
+            "@binding(93) var<storage, read> torch_table: TorchTable;",
+        ] {
+            assert!(
+                terrain.contains(binding) && model.contains(binding),
+                "the terrain and model torch receivers disagree on `{binding}` — the WGSL and the \
+                 AsBindGroup attributes are two declarations of one layout, and this one blanks \
+                 the ground at the first tile spawn"
+            );
+        }
+
+        // The struct's MEMBER lines only: each copy carries its own prose about its own lane.
+        let layout = |src: &str| -> Vec<String> {
+            let body = src
+                .split_once("struct TorchTable {")
+                .expect("every torch receiver declares the table")
+                .1;
+            body.split_once("\n}")
+                .expect("the struct is closed")
+                .0
+                .lines()
+                .map(str::trim)
+                .filter(|l| !l.is_empty() && !l.starts_with("//"))
+                .map(str::to_owned)
+                .collect()
+        };
+        assert_eq!(
+            layout(terrain),
+            layout(model),
+            "the terrain and model `TorchTable` copies have drifted — they mirror ONE 6416-byte \
+             buffer (count / positions[16] / view_projs[96]); a member added, reordered or resized \
+             on one side moves every matrix offset on that side only"
+        );
+
+        assert!(
+            terrain.contains(
+                "let ext_night_w = select(0.0, clamp(1.0 - sun_shadow_strength, 0.0, 1.0), \
+                 torch_ext_on());"
+            ) && terrain.contains("if (ext_night_w > 0.0) {"),
+            "terrain's exterior torch lane is no longer gated on `ext_night_w > 0.0` — daylight is \
+             now paying for (and possibly rendering) the night blend, and the day look is free to \
+             drift by a rounding step"
+        );
+    }
+
     /// The sky depth law, for the one sky element that draws on the MODEL lane: the WMO skybox
     /// ([`WowModelKey::sky_depth`]). Every other sky shader is checked the same way, together, in
     /// `benilla_world::sky_order::the_sky_depth_is_pinned_at_the_vertex_and_nowhere_else` — this
diff --git a/crates/benilla-assets/src/shaders/shadow_hook.wgsl b/crates/benilla-assets/src/shaders/shadow_hook.wgsl
new file mode 100644
index 00000000..da85a643
--- /dev/null
+++ b/crates/benilla-assets/src/shaders/shadow_hook.wgsl
@@ -0,0 +1,468 @@
+#define_import_path benilla::shadow_hook
+
+// MONKEY (shadow extension hook): the ONE place the realtime directional-shadow term is computed.
+//
+// benilla's receivers — `terrain.wgsl`, `wow_model.wgsl`, `static_gx.wgsl` — call `realtime_shadow`
+// instead of each hand-rolling the fetch + fades. Adding or changing the realtime shadow now touches
+// THIS file only; the three receiver shaders (the ones that blanked the terrain when edited by hand)
+// stay untouched. The receivers keep their own downstream gating (terrain's MCSH suppression + spec
+// gate, the model's interior/rig-skin exclusion + ambient-preserving apply, static_gx's ambient arm)
+// — those are lighting composition, not shadow sampling, so they belong to each receiver.
+//
+// It is a no-op whenever no shadow sun exists: the only Bevy `DirectionalLight` benilla ever spawns
+// is the shadow rig's (`benilla_app::shadow_core`), so `lights.n_directional_lights == 0` exactly
+// when shadows are off, and the loop below never runs. No shader-def toggle is needed.
+
+#import bevy_pbr::{
+    shadows,
+    mesh_view_bindings::lights,
+}
+
+// The realtime shadow lightens over the last SHADOW_EDGE_BAND yards of the cascade's max distance so
+// it fades in rather than popping at the resolve boundary.
+const SHADOW_EDGE_BAND: f32 = 14.0;
+
+// The realtime directional-shadow factor at `sample_pos`: 1.0 = lit, 0.0 = fully shadowed.
+//
+// - `sample_pos`   world-space point to sample the shadow map at — a per-fragment position, or a
+//                  unit's nudged rig anchor (the caller chooses; that is the rig-skin decision).
+// - `normal`       receiver normal, for the slope-aware depth bias.
+// - `view_z`       view-space z, for cascade selection.
+// - `cam_dist`     distance from the camera to the receiver fragment, for the EDGE fade.
+// - `shadow_range` the cascade's max distance (the `shadowDistance` slider) — where the edge fade ends.
+// - `night`        the sun-height strength (0 at night .. 1 by day) — the NIGHT fade.
+//
+// Both fades lighten the result toward 1.0 (no shadow). The caller passes `shadow_range`/`night`
+// from its own light buffer (the receivers declare that buffer three incompatible ways, so the hook
+// takes the scalars as arguments rather than reading it).
+fn realtime_shadow(
+    sample_pos: vec4<f32>,
+    normal: vec3<f32>,
+    view_z: f32,
+    cam_dist: f32,
+    shadow_range: f32,
+    night: f32,
+) -> f32 {
+    var shadow = 1.0;
+    if (lights.n_directional_lights > 0u) {
+        for (var light_id = 0u; light_id < lights.n_directional_lights; light_id = light_id + 1u) {
+            if ((lights.directional_lights[light_id].flags & 1u) != 0u) {
+                shadow = shadows::fetch_directional_shadow(light_id, sample_pos, normal, view_z);
+                break;
+            }
+        }
+    }
+    let edge_fade = smoothstep(shadow_range - SHADOW_EDGE_BAND, shadow_range, cam_dist);
+    return 1.0 - (1.0 - shadow) * night * (1.0 - edge_fade);
+}
+
+// MONKEY (torch shadows Phase 1): the point/cluster-based torch shadow is DEAD. benilla's world
+// camera sets `ClusterConfig::None`, which starves `clusterable_objects` AND the point-shadow prep,
+// so `fetch_point_shadow`/the clusterable scan can never fire. The replacement is a from-scratch
+// depth map (`benilla_world::static_gx::torch_depth` + `torch_map_shadow` below), sampled by the
+// static_gx interior lane through its own group-3 bindings, and (Phase 3A) by `wow_model.wgsl`'s
+// entity lane through its material's own bindings 91/92/93 — both call `torch_map_shadow` below.
+// These two functions are kept only so `interior_debug_override` (mode 2) compiles; they return
+// "unshadowed" and no receiver's lighting path calls them any more.
+fn torch_shadow(sample_pos: vec4<f32>, normal: vec3<f32>) -> f32 {
+    return 1.0;
+}
+
+fn torch_shadow_for(light_pos: vec3<f32>, sample_pos: vec4<f32>, normal: vec3<f32>) -> f32 {
+    return 1.0;
+}
+
+// MONKEY (torch shadows Phase 1): the old clusterable-caster count diagnostic. The clustering is
+// dead (see above), so this is now a constant 0 — kept only so `interior_debug_override` compiles.
+fn torch_caster_count() -> u32 {
+    return 0u;
+}
+
+// MONKEY (pcss): the contact-hardening constants.
+//
+// `TORCH_DEPTH_B` is the reverse-Z projection's depth OFFSET, mirrored from
+// `benilla_app::torch_shadow::{reverse_z_perspective, cube_view_projs}` (near 0.1, far TORCH_RANGE
+// 48 — every matrix this function is ever handed is one of those six cube faces). Under reverse-Z
+// the stored depth is an AFFINE function of the RECIPROCAL distance along the face axis:
+// `z = A/t + B`, `A = near*far/(far-near)`, `B = -near/(far-near)`. So `z - B` is proportional to
+// `1/t`, and the one quantity a penumbra needs — the ratio of two distances — is
+// `(z_blocker - B) / (z_receiver - B)` with `A` cancelling: no linearisation, no extra uniform, one
+// subtraction per term. A constant rather than something decoded out of `view_proj` because the
+// w-row of a look-at product carries the eye translation, so `B` cannot be read off a single
+// element of that matrix without dividing two of them — and a wrong `B` would silently mis-size
+// every penumbra instead of failing.
+const TORCH_DEPTH_B: f32 = -0.1 / 47.9;
+// How far out (in `soft` texels) the blocker search looks. Two: wide enough to find the caster of
+// an edge a texel or two away, narrow enough that a fragment well inside a lit area still reads
+// four empty texels and takes the cheap path.
+const TORCH_PCSS_SEARCH: f32 = 2.0;
+// Penumbra gain — extra `soft` radii per unit of `(d_receiver - d_blocker)/d_blocker`. A receiver
+// twice as far from the fixture as its blocker (ratio 1) is filtered three times as wide; the
+// Darkmoon tent (post ~2 yd from the torch, grass ~10) saturates the clamp below, and a chair leg
+// resting ON the floor (ratio ~0.05) stays within 10 % of the hard kernel — the whole point.
+const TORCH_PCSS_K: f32 = 2.0;
+// …clamped at four radii. Past that the 8 taps are too sparse for the area they cover and the
+// penumbra starts to band, and the shadow there is faint enough that widening it further is
+// invisible anyway.
+const TORCH_PCSS_MAX: f32 = 4.0;
+// Above this filter radius (texels) the 4-tap box is too sparse and earns the second ring.
+const TORCH_PCSS_WIDE: f32 = 1.5;
+
+// MONKEY (slope bias): the per-tap RECEIVER-PLANE correction's ceiling, in multiples of the
+// constant `bias`. A PCF/PCSS tap `n` texels off centre lands on a piece of the SAME surface whose
+// stored depth differs by the receiver plane's own depth gradient times `n`; `torch_map_shadow`
+// walks that tap's compare reference along the plane by exactly that much, so a tap on the
+// receiver's own plane compares equal-to-equal and can never fail, at any grazing angle. What the
+// correction must NOT do is walk so far that a tap on a real OCCLUDER also passes - that is
+// peter-panning, a shadow lifting off its contact - so it is clamped at `TORCH_SLOPE_MAX * bias`.
+//
+// THE ARITHMETIC - and a CORRECTION to round 3's. The receivers' `TORCH_NORMAL_OFFSET` note prices
+// all of this in "yards of RAY distance", which is not what `textureSampleCompareLevel` compares:
+// the stored value is `ndc.z` on the cube FACE the fragment lands in, and under a perspective
+// projection that is a function of the VIEW-SPACE Z - the component along the FACE AXIS - not of
+// the ray length. Two things follow that the round-3 table cannot show:
+//
+//   · a floor directly under a fixture lands in the DOWN face, where its view-space Z is the
+//     constant `h`, so its stored depth is CONSTANT across that whole face and there is no
+//     gradient to clear at all - acne is impossible there. It begins the moment `r > h` and the
+//     fragment crosses into a SIDE face, whose view-space Z is the HORIZONTAL distance and along
+//     which the floor runs away from the eye. On a side face the gradient works out to `2A/(f*h)`
+//     per unit uv (`A = near*far/(far-near)`, `f = 1/tan(fov/2)`) - i.e. it depends on the
+//     fixture's HEIGHT and not at all on `r`: the same at 3 yd out as at 30.
+//   · the note's normal-offset term `0.15*(h/t)` is INVERTED. Moving the sample point 0.15 yd up
+//     off a grazing floor moves the place where its own shadow ray meets that floor by
+//     `0.15*(t/h)` - amplified by the grazing angle, not reduced by it. So the offset is worth
+//     about `(t/h)^2` times what round 3 credited it with, which is why a knee-high fixture's pool
+//     was in fact clean to ~10 yd rather than to ~2.1.
+//
+// Re-measured exactly (scratchpad `slopebias_exact.py`: the real reverse-Z cube face, the real
+// `torch_face` pick on the OFFSET point, the widened kernel's 8 taps at 3 and 6 texels, each
+// SNAPPED to its texel centre, compared against the real floor plane). BREAK RADIUS = how far a
+// fixture `h` yd above a flat floor lights before its own worst tap starts to fail:
+//
+//     h (yd)      before        after
+//     4.0         clean         clean        a chandelier, a lamppost head
+//     3.0         clean         clean        a WALL TORCH - always was fine, and stays fine
+//     2.0        25.8 yd        clean        a brazier
+//     1.5        14.1 yd        clean
+//     1.0        10.1 yd        clean        the IMP's hand flame - the reported case
+//     0.5         7.3 yd        clean        a candle standing on the floor
+//     0.25        7.1 yd       11.7 yd       CLAMPED - see below
+//
+// "clean" = no tap fails anywhere out to the projection's usable 46 yd, i.e. the acne is GONE and
+// not merely pushed outward. Where a tap was already passing the margin simply widens, at h = 1 yd:
+// +3.5e-4 -> +2.3e-3 at r = 9, +1.7e-3 -> +3.6e-3 at r = 5; and where it was failing, -5.1e-4 ->
+// +1.5e-3 at r = 15. The h = 3 wall-torch rows move 1.0x-2.7x in the same direction and never
+// change verdict, which is the "forge floor unchanged, still attached at contact" requirement.
+//
+// The BLOCKER SEARCH matters as much as the taps. At h = 1, r = 15 its own 3-texel taps were
+// self-detecting (-5.1e-4). That darkens nothing, but it hands `TORCH_PCSS_K` a blocker ratio made
+// entirely of bias error - a pool going soft with nothing in it. Corrected: +1.5e-3.
+//
+// WHY 4 AND NOT MORE. The correction the outermost tap WANTS is 2.8e-3 at h = 1 and 6.8e-3 at
+// h = 0.5, against the `4*bias` = 4e-3 ceiling: free at h = 1, clamped at h = 0.5 - and clamped is
+// still enough there (+3.5e-3 at r = 9). It only falls short under a QUARTER-yard fixture, a light
+// effectively lying on the ground, where the surface is near-edge-on to it, `max(N.L, 0)` has
+// already taken the term toward zero, and refusing to move further is the conservative answer. A
+// TILTED receiver wants LESS, not more (2.7e-4 at 45 deg, 3.0e-4 at 75 deg: the face pick swings
+// back to the DOWN face and the gradient collapses), so raising the ceiling would buy nothing
+// anywhere except the one case where it is deliberately declining to act, while starting to lift
+// genuine contact shadows - the single failure mode a shadow bias must never have.
+const TORCH_SLOPE_MAX: f32 = 4.0;
+
+// MONKEY (slope bias): ONE tap's compare reference - the centre reference walked along the RECEIVER
+// PLANE by `dot(grad, off)` and bounded at +/-`lim`. `grad` is `d(ndc.z)/d(uv)` restricted to that
+// plane (built once per call in `torch_map_shadow`), `off` is the tap's uv displacement from the
+// centre. Three ALU and a clamp, no texture read. It is a function rather than four inline
+// expressions so a tap's OFFSET and its REFERENCE cannot drift apart - they are the same argument.
+fn torch_plane_ref(ref_depth: f32, grad: vec2<f32>, off: vec2<f32>, lim: f32) -> f32 {
+    return ref_depth + clamp(dot(grad, off), -lim, lim);
+}
+
+// MONKEY (pcss): one RAW depth texel of a torch map — the blocker search's read. `textureLoad`
+// takes no sampler and imposes no uniformity requirement, which is what makes the search legal
+// inside the receivers' per-fixture loop. The clamp is the border rule: a search that walks off the
+// face re-reads its edge texel, the same answer the comparison sampler's ClampToEdge address mode
+// gives the PCF taps beside it.
+fn torch_map_depth(
+    depth_tex: texture_depth_2d_array,
+    layer: i32,
+    uv: vec2<f32>,
+    dims: vec2<f32>,
+) -> f32 {
+    let c = clamp(vec2<i32>(floor(uv * dims)), vec2<i32>(0, 0), vec2<i32>(dims) - vec2<i32>(1, 1));
+    return textureLoad(depth_tex, c, layer, 0);
+}
+
+// MONKEY (torch shadows Phase 1): the depth-map projector. Because `shadow_hook` is imported by
+// receivers WITHOUT the group-3 torch bindings (wow_model, terrain), the texture + comparison
+// sampler come in AS PARAMETERS — the caller supplies them only where they are bound (static_gx).
+//   - `view_proj`  the fixture's down-looking reverse-Z matrix.
+//   - `layer`      which array layer (fixture index) to sample.
+//   - `world_pos`  the receiving fragment's world position.
+//   - `normal`     MONKEY (slope bias): the receiving surface's world-space normal, used ONLY to
+//                  build the receiver plane whose depth gradient each tap's compare reference is
+//                  walked along (see `TORCH_SLOPE_MAX`). It need not be unit and may be the zero
+//                  vector - the M2 corpus authors those, and a zero normal simply switches the
+//                  slope term off, leaving the constant bias exactly as it was. Callers pass the
+//                  SAME normal they already offset `world_pos` along (`TORCH_NORMAL_OFFSET`), so
+//                  the offset point and the plane through it agree by construction.
+//   - `depth_tex`/`comp`  the group-3 depth array + `GreaterEqual` comparison sampler.
+//   - `bias`       reverse-Z receiver bias (nudges the compare ref up to kill self-shadow acne).
+//                  MONKEY (slope bias): still a CONSTANT floor under every tap - the slope term is
+//                  added on top of it per tap, never in place of it.
+//   - `soft`       MONKEY (torch caster selection): the BASE PCF tap-radius scale
+//                  (`interiorShadowSoft`, 0.5..3, carried in the table's `count.y` LOW half as
+//                  `soft x 100`). The four taps sit at ±0.5 texel × this; 1 is the historical
+//                  half-texel box. MONKEY (pcss): it is now the radius at a CONTACT (a receiver
+//                  touching its blocker) — the contact-hardening search below grows it with the
+//                  blocker distance, so `soft` sets how sharp the sharpest edge in the scene is
+//                  and every penumbra scales off it.
+//   - `fade`       MONKEY (outdoor torch shadows): WHICH far fade ends the shadow.
+//                  **Negative = the interior/legacy behaviour, bit-for-bit** — the reverse-Z
+//                  far-plane fade computed from `ndc.z` below. Zero-or-positive = the CALLER's own
+//                  fade weight, used verbatim (0 = no shadow left, 1 = full strength).
+//
+//                  Why an override at all: the projection is near/far `0.1/48`
+//                  (`torch_shadow::cube_view_projs`), so under reverse-Z `ndc.z` is
+//                  `near·(far−t)/((far−near)·t)` = **0.0079 at t = 10 yd**, which
+//                  `smoothstep(0, 0.06, ·)` turns into a 5 % shadow. For a candle whose pool is
+//                  3-4 yd that is a correct soft end; for a campfire whose pool is 15-25 yd it
+//                  erases the shadow exactly where the shadow IS the effect. The fix cannot live
+//                  in here — it wants to be a function of WORLD distance from the fixture, and
+//                  this function is deliberately a pure projector that never sees the fixture — so
+//                  the exterior lane computes `1 − smoothstep(0.8R, R, d)` at its call site.
+// Returns 1.0 outside the frustum / behind the light; a PCF factor otherwise (0 = shadowed).
+//
+// MONKEY (pcss): CONTACT-HARDENING. The old kernel was one fixed ±0.5·soft texel box everywhere,
+// which is why a torch beside a Darkmoon tent post threw the canvas onto the grass fifteen yards
+// away as a razor-edged cut-out: a real penumbra grows with the receiver's distance FROM ITS
+// BLOCKER, and a constant kernel has no way to know that distance. The three steps below recover
+// it from the map itself — search for blockers, estimate how far in front of the receiver they
+// are, widen the filter by that much — so a chair leg stays crisp where it meets the floor while
+// the tent's edge goes soft where the canvas is metres above the grass.
+//
+// The blocker search reads RAW depth with `textureLoad`, not through the comparison sampler: the
+// array is bound as `texture_depth_2d_array` (wgpu sample type Depth), and a Depth binding serves
+// BOTH `textureSampleCompare*` (through `comp`) and an unfiltered `textureLoad` that takes no
+// sampler at all — so no binding, layout or pipeline changed. That is worth insisting on, because
+// the alternative approximation (infer the blocker from the FRACTION of blocked compares at two or
+// three radii) only ever answers "how deep inside the shadow am I", never "how far in front of me
+// is the caster", and those two differ by exactly the quantity a penumbra is made of.
+//
+// Cost: 4 unfiltered loads, then 4 comparison taps (the shipped kernel, unchanged) whenever the
+// search finds no blocker — which is every fully-lit fragment, i.e. most of a pool — or 8 when the
+// widened radius earns them. Worst case 8 compares + 4 loads per fixture per fragment.
+// MONKEY (slope bias) adds NO texture read at all: ~90 ALU once per call (two crosses, two
+// `mat4x4 * vec4`, a 2x2 solve) to build the receiver-plane gradient, then a dot-clamp-add — about
+// 5 ALU — on each of the 4 search taps and 4 or 8 PCF taps. The gradient cannot hoist out of the
+// receivers' per-fixture loop (it depends on the fixture's own face matrix), but it is bounded by
+// `EXT_SEL_SHADOWED` there exactly as the taps are.
+fn torch_map_shadow(
+    view_proj: mat4x4<f32>,
+    layer: i32,
+    world_pos: vec3<f32>,
+    normal: vec3<f32>,
+    depth_tex: texture_depth_2d_array,
+    comp: sampler_comparison,
+    bias: f32,
+    soft: f32,
+    fade: f32,
+) -> f32 {
+    let clip = view_proj * vec4<f32>(world_pos, 1.0);
+    if (clip.w <= 0.0) {
+        return 1.0;
+    }
+    let ndc = clip.xyz / clip.w;
+    if (ndc.x < -1.0 || ndc.x > 1.0 || ndc.y < -1.0 || ndc.y > 1.0 || ndc.z < 0.0 || ndc.z > 1.0) {
+        return 1.0;
+    }
+    let uv = ndc.xy * vec2<f32>(0.5, -0.5) + vec2<f32>(0.5);
+    let dims = vec2<f32>(textureDimensions(depth_tex).xy);
+    let inv_dims = 1.0 / dims;
+    // MONKEY (torch caster selection): the base radius, clamped off zero so a table that never got
+    // a scale still samples a real (hard) box rather than four copies of one texel.
+    let base = max(soft, 0.05);
+    // Reverse-Z: the fragment is lit iff its own depth is at least the stored nearest depth, so the
+    // compare ref is `ndc.z + bias` against `GreaterEqual`. UNCHANGED bias semantics: this is the
+    // CENTRE reference, and the blocker test and every comparison tap are derived from this one
+    // expression, so a surface can no more blocker-detect itself than it could shadow itself.
+    // MONKEY (slope bias): "derived from" rather than "is" - each tap now adds its own
+    // receiver-plane term on top (`torch_plane_ref` below), which strengthens that property rather
+    // than weakening it: the taps that used to self-detect were exactly the off-centre ones.
+    let ref_depth = ndc.z + bias;
+
+    // MONKEY (slope bias) — RECEIVER-PLANE DEPTH BIAS. `bias` is a constant and the thing it has to
+    // clear is not: a tap `n` texels off centre reads a piece of the SAME surface whose stored depth
+    // differs by the receiver plane's own gradient times `n`, and on a floor lit from a low angle
+    // that gradient is the whole problem (`TORCH_SLOPE_MAX` has the measured numbers — a knee-high
+    // flame's floor starts losing to it past 10 yd, a candle's past 7, and the taps that fail
+    // print as faint rings out at the rim of the pool where the term is still visible). So every
+    // tap gets its OWN reference, walked along the receiver's plane by what
+    // that plane does over that tap's displacement: a tap sitting on the plane then compares
+    // equal-to-equal and cannot fail at any grazing angle, while a tap on a real occluder is
+    // untouched — the occluder is not on this plane, which is what makes it an occluder.
+    //
+    // `grad` is `d(ndc.z)/d(uv)` restricted to the plane through `world_pos` with normal `normal`,
+    // computed ANALYTICALLY rather than from `dpdx`/`dpdy` of the ndc. Two reasons, both hard:
+    //   · every call site is inside a receiver's per-fixture table scan, with data-dependent
+    //     `continue`s and an early `return` (`torch_map_at`, `torch_terrain_shadow`,
+    //     `torch_entity_shadow_at`) — NON-UNIFORM control flow, where WGSL's derivative-uniformity
+    //     rule makes `dpdx` a diagnostic at best and a neighbouring-fixture read at worst;
+    //   · screen-space derivatives are a QUAD difference, so they are wrong by construction on a
+    //     two-pixel-wide sliver and along every silhouette — exactly the geometry (fence rails,
+    //     chair legs, tent ropes) this lane spends its taps on.
+    // The analytic form needs no quad and no uniformity, and is EXACT for a plane.
+    //
+    // Any two independent vectors IN the plane give the same gradient, so the tangents are left
+    // un-normalised and `normal` need not be unit: only the plane's direction SPACE matters and the
+    // 2x2 solve is invariant to how it is spanned. `a` picks the axis the normal is least aligned
+    // with, so the first cross is never near-degenerate. A ZERO normal (the M2 corpus authors them
+    // — see `wow_normalize` in the receivers) leaves `grad` at zero, i.e. the old constant-bias
+    // behaviour, bit-for-bit.
+    var grad = vec2<f32>(0.0);
+    if (dot(normal, normal) > 1e-12) {
+        let a = select(vec3<f32>(1.0, 0.0, 0.0), vec3<f32>(0.0, 0.0, 1.0),
+                       abs(normal.x) > abs(normal.z));
+        let t1 = cross(normal, a);
+        let t2 = cross(normal, t1);
+        // d(clip) along each tangent, then through the perspective divide:
+        // `d(ndc) = (d(clip).xyz - ndc * d(clip).w) / clip.w`.
+        let c1 = view_proj * vec4<f32>(t1, 0.0);
+        let c2 = view_proj * vec4<f32>(t2, 0.0);
+        let inv_w = 1.0 / clip.w;
+        let g1 = (c1.xyz - ndc * c1.w) * inv_w;
+        let g2 = (c2.xyz - ndc * c2.w) * inv_w;
+        let u1 = g1.xy * vec2<f32>(0.5, -0.5);   // the same ndc -> uv flip `uv` above uses
+        let u2 = g2.xy * vec2<f32>(0.5, -0.5);
+        // Solve `dot(grad, u_i) = g_i.z` for i = 1, 2. `det` collapses only as the plane goes
+        // EDGE-ON to the fixture, where the plane projects to a line in the map, `max(N·L, 0)` has
+        // already taken the lit term to zero, and a zero gradient is the right answer anyway.
+        let det = u1.x * u2.y - u1.y * u2.x;
+        if (abs(det) > 1e-9) {
+            let inv = 1.0 / det;
+            grad = vec2<f32>((g1.z * u2.y - u1.y * g2.z) * inv,
+                             (u1.x * g2.z - g1.z * u2.x) * inv);
+        }
+    }
+    // …and the ceiling on what any one tap may be moved by. See `TORCH_SLOPE_MAX`.
+    let slope_lim = TORCH_SLOPE_MAX * bias;
+
+    // MONKEY (pcss) 1/3 — BLOCKER SEARCH. Four raw reads on the diagonals of a box of half-width
+    // `soft * TORCH_PCSS_SEARCH` texels, averaging the depths that lie IN FRONT of the receiver.
+    // Four taps at one radius rather than a ring at several: they only have to answer "is there a
+    // caster near me, and roughly how far in front", and denser searching costs more than the extra
+    // precision buys on a 512² face whose texels are ~10 cm at a candle's range.
+    let search = base * TORCH_PCSS_SEARCH * inv_dims;
+    // MONKEY (slope bias): the offsets are NAMED so the search's reference and its sample are the
+    // same displacement, exactly as in the PCF kernel below.
+    let s0 = vec2<f32>(-1.0, -1.0) * search;
+    let s1 = vec2<f32>( 1.0, -1.0) * search;
+    let s2 = vec2<f32>(-1.0,  1.0) * search;
+    let s3 = vec2<f32>( 1.0,  1.0) * search;
+    let b0 = torch_map_depth(depth_tex, layer, uv + s0, dims);
+    let b1 = torch_map_depth(depth_tex, layer, uv + s1, dims);
+    let b2 = torch_map_depth(depth_tex, layer, uv + s2, dims);
+    let b3 = torch_map_depth(depth_tex, layer, uv + s3, dims);
+    var blocker = 0.0;
+    var blockers = 0.0;
+    // MONKEY (slope bias): the SEARCH is plane-corrected too, and it has to be. Left on the flat
+    // reference, a grazing floor detects ITSELF as its own blocker, and the penumbra width below is
+    // then estimated from a depth difference that is pure bias error — a pool that goes soft with
+    // nothing in it. Same law, same `grad`, same clamp as the taps.
+    if (b0 > torch_plane_ref(ref_depth, grad, s0, slope_lim)) { blocker += b0; blockers += 1.0; }
+    if (b1 > torch_plane_ref(ref_depth, grad, s1, slope_lim)) { blocker += b1; blockers += 1.0; }
+    if (b2 > torch_plane_ref(ref_depth, grad, s2, slope_lim)) { blocker += b2; blockers += 1.0; }
+    if (b3 > torch_plane_ref(ref_depth, grad, s3, slope_lim)) { blocker += b3; blockers += 1.0; }
+
+    // MONKEY (pcss) 2/3 — PENUMBRA WIDTH. `radius` stays at `base` when the search found nothing: a
+    // caster thinner than the search box (a chair leg, a tent rope, a candlestick) must NOT be
+    // widened away to nothing, and such a fragment is then filtered by exactly the kernel this
+    // function has always used.
+    var radius = base;
+    if (blockers > 0.0) {
+        // `(d_receiver - d_blocker) / d_blocker`, exact — see TORCH_DEPTH_B: `z - B` is
+        // proportional to `1/distance`, so the quotient of the two `z - B` terms IS the quotient of
+        // the two distances, and the projection's scale factor cancels. The receiver term uses the
+        // UNBIASED `ndc.z` (the bias exists to keep a surface off its own stored depth, not to move
+        // the surface), and `max` only guards f32 noise: inside the frustum a detected blocker is
+        // always the nearer of the two.
+        let ratio = max((blocker / blockers - TORCH_DEPTH_B) / (ndc.z - TORCH_DEPTH_B) - 1.0, 0.0);
+        radius = min(base * (1.0 + TORCH_PCSS_K * ratio), base * TORCH_PCSS_MAX);
+    }
+
+    // MONKEY (pcss) 3/3 — PCF at that radius. The 4-tap box below `TORCH_PCSS_WIDE` texels is the
+    // shipped kernel bit-for-bit (`radius == base` reproduces the old `texel` expression exactly);
+    // past it that box would alias into four separate soft bands, so a second ring of four cardinal
+    // taps at the full radius fills the area in.
+    let texel = inv_dims * radius;
+    // MONKEY (slope bias): every tap carries its OWN plane-corrected reference. With `grad` zero -
+    // a receiver square-on to the fixture, or a zero normal - `torch_plane_ref` returns `ref_depth`
+    // unchanged and this kernel is the shipped one bit-for-bit.
+    let p0 = vec2<f32>(-0.5, -0.5) * texel;
+    let p1 = vec2<f32>( 0.5, -0.5) * texel;
+    let p2 = vec2<f32>(-0.5,  0.5) * texel;
+    let p3 = vec2<f32>( 0.5,  0.5) * texel;
+    var sum = 0.0;
+    sum += textureSampleCompareLevel(depth_tex, comp, uv + p0, layer,
+                                     torch_plane_ref(ref_depth, grad, p0, slope_lim));
+    sum += textureSampleCompareLevel(depth_tex, comp, uv + p1, layer,
+                                     torch_plane_ref(ref_depth, grad, p1, slope_lim));
+    sum += textureSampleCompareLevel(depth_tex, comp, uv + p2, layer,
+                                     torch_plane_ref(ref_depth, grad, p2, slope_lim));
+    sum += textureSampleCompareLevel(depth_tex, comp, uv + p3, layer,
+                                     torch_plane_ref(ref_depth, grad, p3, slope_lim));
+    var pcf = sum * 0.25;
+    if (radius > TORCH_PCSS_WIDE) {
+        let p4 = vec2<f32>(-1.0,  0.0) * texel;
+        let p5 = vec2<f32>( 1.0,  0.0) * texel;
+        let p6 = vec2<f32>( 0.0, -1.0) * texel;
+        let p7 = vec2<f32>( 0.0,  1.0) * texel;
+        sum += textureSampleCompareLevel(depth_tex, comp, uv + p4, layer,
+                                         torch_plane_ref(ref_depth, grad, p4, slope_lim));
+        sum += textureSampleCompareLevel(depth_tex, comp, uv + p5, layer,
+                                         torch_plane_ref(ref_depth, grad, p5, slope_lim));
+        sum += textureSampleCompareLevel(depth_tex, comp, uv + p6, layer,
+                                         torch_plane_ref(ref_depth, grad, p6, slope_lim));
+        sum += textureSampleCompareLevel(depth_tex, comp, uv + p7, layer,
+                                         torch_plane_ref(ref_depth, grad, p7, slope_lim));
+        pcf = sum * 0.125;
+    }
+    // Phase 5: the six cube faces tile the whole sphere, so there is no cone edge to soften — a fade
+    // there would punch a lit seam along every face border. Only the far plane fades (reverse-Z:
+    // ndc.z → 0 at far), so a shadow at the fixture's range limit ends softly.
+    // MONKEY (outdoor torch shadows): …unless the caller supplied its own (see `fade`). `select`
+    // rather than a branch so both arms cost the same and the interior arm is the identical
+    // expression it always was.
+    let ndc_fade = smoothstep(0.0, 0.06, ndc.z);
+    return mix(1.0, pcf, select(fade, ndc_fade, fade < 0.0));
+}
+
+// MONKEY (interior debug): the interior lane's diagnostic overlay. `mode` is decoded from the
+// receiver's `wmo_fog_params.w` (`1 + debug`); the receivers call this at the END of their interior
+// branch so ONLY interior-lit fragments are recoloured — a wrongly-classified outdoor entity then
+// stands out against the normally-shaded world. `mode == 0` returns the real `rgb` unchanged.
+//   1 CLASSIFICATION → solid green (this fragment took the interior lane)
+//   2 SHADOW         → the torch-shadow factor as greyscale (black shadowed .. white lit)
+//   3 CASTER COUNT   → red 0 / green 1 / blue 2 / white 3+ shadow proxies visible to this view
+fn interior_debug_override(
+    mode: u32,
+    rgb: vec3<f32>,
+    sample_pos: vec4<f32>,
+    normal: vec3<f32>,
+) -> vec3<f32> {
+    if (mode == 1u) {
+        return vec3<f32>(0.0, 1.0, 0.0);
+    }
+    if (mode == 2u) {
+        return vec3<f32>(torch_shadow(sample_pos, normal));
+    }
+    if (mode == 3u) {
+        let n = torch_caster_count();
+        if (n == 0u) { return vec3<f32>(1.0, 0.0, 0.0); }
+        if (n == 1u) { return vec3<f32>(0.0, 1.0, 0.0); }
+        if (n == 2u) { return vec3<f32>(0.0, 0.0, 1.0); }
+        return vec3<f32>(1.0, 1.0, 1.0);
+    }
+    return rgb;
+}
diff --git a/crates/benilla-assets/src/shaders/terrain.wgsl b/crates/benilla-assets/src/shaders/terrain.wgsl
index e5ce32c2..cecef46e 100644
--- a/crates/benilla-assets/src/shaders/terrain.wgsl
+++ b/crates/benilla-assets/src/shaders/terrain.wgsl
@@ -29,14 +29,20 @@
     mesh_functions,
     forward_io::Vertex,
     view_transformations::position_world_to_clip,
-    mesh_view_bindings::view,
+    mesh_view_bindings::{lights, view},
+    shadows,
 }
+// MONKEY (shadow hook): the realtime directional-shadow term (fetch + edge/night fade) lives here.
+#import benilla::shadow_hook
 
 @group(#{MATERIAL_BIND_GROUP}) @binding(100) var layer_array: texture_2d_array<f32>;
 @group(#{MATERIAL_BIND_GROUP}) @binding(104) var alpha_array: texture_2d_array<f32>;
 @group(#{MATERIAL_BIND_GROUP}) @binding(105) var splat_samp: sampler;
 @group(#{MATERIAL_BIND_GROUP}) @binding(110) var shadow_array: texture_2d_array<f32>;
 
+// A fully covered character shadow retains 45% of the authored terrain colour.
+const SHADOW_SUN_FLOOR: f32 = 0.45;
+
 // Per-tile Vec4 uniforms packed into ONE buffer (binding 106) — the field order here MUST match the
 // Rust `TerrainExtension` struct. Light + fog live in the shared global-light storage buffer (below);
 // what's left is just the per-tile layer tiling factor.
@@ -64,12 +70,175 @@ struct WowLight {
     grade: vec4<f32>,         // reserved (the 0282 interior A/B retired; 0163). Layout only.
     _wmo_fog: array<vec4<f32>, 2>, // rows 18-19: the interior fog triple — unread by terrain.
     // The dynamic point-light table (decision 0278), packed by `global_light::build_light_data`:
-    // row 20 `.x` = live entry count; then TWO rows per light — `[pos.xyz, range]`, `[rgb, 0]`.
+    // row 20 `.x` = live entry count; then TWO rows per light — `[pos.xyz, range]`, `[rgb, lane]`.
+    // MONKEY (light lanes): `lane` = 0 for an EXTERIOR light, > 0.5 (and equal to the fixture's
+    // reach in yards) for an INTERIOR one. Terrain consumes only the exterior half.
     point_count: vec4<f32>,
     points: array<vec4<f32>, 512>,
 };
 @group(#{MATERIAL_BIND_GROUP}) @binding(90) var<storage, read> wow_light: WowLight;
 
+// MONKEY (outdoor torch shadows: terrain): the GROUND receiver's torch bindings - the SAME depth
+// array static_gx's group 3 samples and the SAME 6416-byte table, riding this material's own group
+// (`TerrainExtension` bindings 91/92/93) because a Bevy material draw sets groups 0/1/2 only.
+// ALWAYS bound (the image and buffer exist from startup), so no shader-def guards this block; only
+// the fragment stage reads it. The struct text is COPIED VERBATIM from wow_model.wgsl - std430 here,
+// std140 in static_gx, identical bytes because every member is 16-aligned - and a drift between the
+// three copies would not be a compile error, it would be terrain sampling the wrong matrices.
+struct TorchTable {
+    // MONKEY (static torch cache): byte-identical in ALL THREE shaders and TorchTableUniform.
+    // count@0 (16): x high-water slot count, y soft*100, z dynamic/live-bank mask, w flags.
+    // positions@16 (256), view_projs@272 (6144): total 6416 bytes. A mismatch hides buildings.
+    // MONKEY (live bank rank): 96 static layers + 48 live layers; matrices stay slot-addressed.
+    count: vec4<u32>,
+    positions: array<vec4<f32>, 16>,
+    view_projs: array<mat4x4<f32>, 96>,
+}
+@group(#{MATERIAL_BIND_GROUP}) @binding(91) var torch_depth: texture_depth_2d_array;
+@group(#{MATERIAL_BIND_GROUP}) @binding(92) var torch_samp: sampler_comparison;
+@group(#{MATERIAL_BIND_GROUP}) @binding(93) var<storage, read> torch_table: TorchTable;
+// Reverse-Z receiver bias - KEEP IN SYNC with static_gx.wgsl / wow_model.wgsl's TORCH_BIAS (0.001,
+// the known-good value; larger detaches every shadow far from the torch).
+const TORCH_BIAS: f32 = 0.001;
+// NORMAL-OFFSET for the GROUND (yd): sample the map a hand's width above the surface along its own
+// normal. Terrain is the one receiver whose casters REST on it - a crate, a fence post, a standing
+// NPC - so the contact point is where receiver and caster depths agree to within a texel, i.e.
+// exactly where a plain compare produces acne. Offsetting along the terrain normal (not straight
+// up) is what keeps a SLOPE clean: on a 30 deg bank a vertical offset buys only `0.15*cos(30)` of
+// separation while the depth gradient across a texel has grown by `1/cos(30)`, so the margin
+// collapses on precisely the surfaces that need it most. The same 0.15 the entity lane uses, so a
+// character and the ground under it are offset alike and their shadows meet without a gap.
+const TORCH_NORMAL_OFFSET: f32 = 0.15;
+// MONKEY (torch caster selection, MIRRORED from static_gx.wgsl): the live PCF tap-radius scale
+// (count.y LOW half) and MONKEY (shadow floor)'s strength (HIGH half),
+// unpacked from the table's `count.y` (stored x100 - the row is `vec4<u32>`).
+fn torch_soft() -> f32 {
+    return max(f32(torch_table.count.y & 0xffffu) * 0.01, 0.05);
+}
+// MONKEY (shadow floor): the live SHADOW STRENGTH (`torchShadowStrength`, 0..1, default 0.7),
+// unpacked from `count.y`'s HIGH half (`(strength x 100) << 16 | soft x 100` - see
+// `TorchTableUniform::pack`; the low half is `torch_soft` above and `count.w`'s flags are
+// untouched). It is applied as `mix(1, s, w * strength)` where the cross-fade weight already
+// multiplies the shadow factor, which is algebraically the same thing as flooring the factor
+// itself (`1 - w*strength*(1-s)` either way) for one extra multiply and no extra tap.
+//
+// WHY a floor at all: a torch map is the ONLY occlusion in the direct term, so a blocked fragment
+// used to drop that term to exactly zero - a pitch-black, razor-edged scar of tent canvas across
+// Darkmoon's grass, table legs printed on the Darkshire inn floor. Nothing in this renderer
+// bounces, so the 30 % that survives at the default IS the bounce: the fill/ambient arms are
+// untouched (they never saw this factor), only the DIRECT arm is floored. 1 restores the shipped
+// pitch-black look exactly, 0 disables torch shadows without disturbing the lane behind them.
+fn torch_strength() -> f32 {
+    return clamp(f32(torch_table.count.y >> 16u) * 0.01, 0.0, 1.0);
+}
+// MONKEY (outdoor torch shadows, MIRRORED from static_gx.wgsl - keep in sync): the EXTERIOR lane's
+// world-distance fade radius (yd) and the CPU's one-bit lane gate in `count.w`. See the static_gx
+// copies for the full rationale (the interior `ndc.z` fade is already down to 5 % at 10 yd, which
+// erases a campfire's 15-25 yd pool).
+const TORCH_EXT_FADE_YD: f32 = 44.0;
+const TORCH_EXT_LANE: u32 = 1u;
+// MONKEY (torch lane perf, MIRRORED from static_gx.wgsl): below THIS much unshadowed direct
+// contribution a fragment skips the torch table scan and its four comparison taps entirely, because
+// the shadow factor multiplies that contribution and can therefore only ever subtract less than this
+// from the frame. Terrain's combine is a plain modulate rather than the interior exposure rolloff,
+// so the worst possible step across the guard's boundary is 1e-4 of a fully-lit texel - two orders
+// under one 8-bit code. Most of the skips are exact zeros anyway (`nl` IS 0 on ground facing away
+// from the fire), so the threshold only has to be small enough to be invisible.
+const TORCH_SKIP_EPS: f32 = 1e-4;
+// The CPU's one-bit verdict: `exteriorShadows` AND night AND at least one promoted exterior
+// fixture. EVERYTHING this lane costs terrain hangs off this single uniform read.
+fn torch_ext_on() -> bool {
+    return (torch_table.count.w & TORCH_EXT_LANE) != 0u;
+}
+
+// MONKEY (Phase 5, COPIED VERBATIM from wow_model.wgsl - keep in sync): the cube face that contains
+// direction `d` (fixture -> fragment) - the major axis, signed. Face order is the contract with
+// `benilla_app::torch_shadow::cube_view_projs`: 0 +X, 1 -X, 2 +Y, 3 -Y, 4 +Z, 5 -Z.
+fn torch_face(d: vec3<f32>) -> u32 {
+    let a = abs(d);
+    if (a.x >= a.y && a.x >= a.z) {
+        return select(1u, 0u, d.x > 0.0);
+    }
+    if (a.y >= a.z) {
+        return select(3u, 2u, d.y > 0.0);
+    }
+    return select(5u, 4u, d.z > 0.0);
+}
+
+// MONKEY (outdoor torch shadows: terrain): this fixture's OWN cast shadow on a GROUND fragment -
+// `wow_model.wgsl`'s `torch_entity_shadow_at` with the exterior fade already chosen, because terrain
+// has no interior lane to share the body with (an MCNK cell is outdoors by definition, and the
+// interior half of the light table is skipped before ranking). Correlate the `wow_light` fixture at
+// `light_pos` to a promoted torch (position match within 1 yd), pick the cube face facing the
+// fragment, and sample that layer through the shared projector. 1.0 (unshadowed) when no map matches
+// - the lane is off, or the fixture was not among the promoted slots.
+fn torch_terrain_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+    // MONKEY (torch lane perf): the empty table is the common case, so answer it before the normal
+    // offset and the loop set-up.
+    if (torch_table.count.x == 0u) {
+        return 1.0;
+    }
+    // Normal-offset the sample point off the ground (see TORCH_NORMAL_OFFSET).
+    let Ps = P + N * TORCH_NORMAL_OFFSET;
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        // MONKEY (static torch cache): holes and pending uploads never sample stale layers.
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let fixture = torch_table.positions[i].xyz;
+        if (distance(fixture, light_pos) < 1.0) {
+            let face = torch_face(Ps - fixture);
+            let layer = i * 6u + face;
+            // MONKEY (live bank rank): count.z is CPU-ready-filtered; holes must not consume live
+            // cubes. Keep the projection on the static slot while compacting depth only.
+            let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+            let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+            // The EXTERIOR world-distance fade, measured from the FIXTURE (not the camera): this is
+            // "how far does this fire's shadow carry", a property of the fire. Chosen just inside the
+            // cube projection's own 48 yd far plane so the frustum edge is never a hard cut.
+            let fade = 1.0 - smoothstep(0.8 * TORCH_EXT_FADE_YD, TORCH_EXT_FADE_YD, distance(fixture, Ps));
+            // MONKEY (slope bias): `N` is the ground normal the sample point was already
+            // offset along, so the plane the projector biases against is the one this fragment
+            // actually lies on.
+            let s = shadow_hook::torch_map_shadow(
+                torch_table.view_projs[layer], i32(depth_layer), Ps, N, torch_depth, torch_samp,
+                TORCH_BIAS, torch_soft(), fade);
+            // MONKEY (torch caster selection): `.w` is the slot's FADE WEIGHT, so a promoted fixture's
+            // shadow ramps in over ~1/3 s and a demoted one ramps out. The ground and the NPC standing
+            // on it MUST use the same weight or one shadow would pop while the other faded.
+            // MONKEY (shadow floor): and `torch_strength()` is the DIRECT-term floor folded
+            // into that same weight (see the function). `w * strength` rather than a second `mix`
+            // because the two are the same expression.
+            return mix(1.0, s, torch_table.positions[i].w * torch_strength());
+        }
+    }
+    return 1.0;
+}
+
+// MONKEY (torch debug, interiorDebug 2 on TERRAIN): the MIN raw cube-map shadow factor over every
+// promoted fixture (ignoring the fixture match) - mirrors static_gx's `torch_debug_factor` and
+// wow_model's `torch_entity_debug_factor`, so the GROUND's sampling can be SEEN as greyscale:
+// all-white = the table is empty / the projection misses the ground; shaped dark = the depth map
+// reaches the terrain and any remaining fault is downstream of sampling (correlation, weighting).
+fn torch_terrain_debug_factor(P: vec3<f32>, N: vec3<f32>) -> f32 {
+    let Ps = P + N * TORCH_NORMAL_OFFSET;
+    var s = 1.0;
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let face = torch_face(Ps - torch_table.positions[i].xyz);
+        let layer = i * 6u + face;
+        // MONKEY (live bank rank): debug samples the same compact bank as the lit path.
+        let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+        let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+        // MONKEY (slope bias): the overlay biases against the SAME plane the lit path does, or
+        // `interiorDebug 2` would keep showing acne the render no longer has.
+        let raw = shadow_hook::torch_map_shadow(
+            torch_table.view_projs[layer], i32(depth_layer), Ps, N, torch_depth, torch_samp,
+            TORCH_BIAS, torch_soft(), -1.0);
+        // MONKEY (torch caster selection): the WEIGHTED factor, matching the real render.
+        s = min(s, mix(1.0, raw, torch_table.positions[i].w));
+    }
+    return s;
+}
+
 // Custom vertex→fragment payload: the standard fields the splat fragment needs, PLUS `specular` — the
 // per-vertex-clamped sun glint that must be Gouraud-interpolated (Q14). Same struct on both stages, so
 // `@builtin(position)` is clip-position out / frag-coord in (`world_position` is unused until Step 5 fog).
@@ -89,6 +258,29 @@ struct TerrainVsOut {
     // hard knee, the director's "hard square". Sun N·L moving per-pixel → per-vertex is the
     // faithful direction (Step 3's own note: indistinguishable on the smooth term).
     @location(6) primary: vec3<f32>,
+    // The receiver normal is carried so the real cascaded shadow lookup can apply a slope-aware
+    // bias. This is forward-pass data only; the terrain shadow caster is a stock Bevy proxy.
+    @location(7) world_normal: vec3<f32>,
+    // MONKEY (outdoor torch shadows: terrain; ext light k8): WHICH <=`EXT_SEL_K` exterior table
+    // entries `primary`'s point term was summed from, packed 8 bits each across FOUR u32s (see
+    // `EXT_SEL_EMPTY` / `ext_sel_get`). FLAT, because it is a CHOICE and not a quantity -
+    // interpolating packed indices across a triangle would produce a different, meaningless one. It
+    // lets the fragment stage re-shadow the VERTEX's own selection instead of re-ranking, which is
+    // what keeps the selection popping at chunk granularity (the authored behaviour) rather than
+    // drawing a hard line mid-cell. Widened from ONE u32 of three 10-bit ranks to TWO u32s of eight
+    // 8-bit ranks and then to FOUR u32s of twelve - three extra interstage components in all (28
+    // for this struct, against a 60-component limit) - see `EXT_SEL_K` for why three, and then
+    // eight, stopped being enough.
+    @location(8) @interpolate(flat) ext_sel: vec4<u32>,
+    // MONKEY (outdoor torch shadows: terrain): `primary` WITHOUT the point term and WITHOUT the
+    // clamp - just `ambient + sun*max(N.L,0)`. `primary` is clamped per VERTEX (the GL T&L locus,
+    // see its note above) and that clamp is lossy: once a hot torch has saturated a vertex there is
+    // no way to subtract the point term back out in the fragment stage. So the sun/ambient half
+    // rides its own slot and the night lane rebuilds `clamp(base + shadowed_points)` from it. This
+    // costs 3 interstage components and is read ONLY inside the night branch; the day path still
+    // reads `primary` and is therefore bit-identical. Unclamped is safe to interpolate: it is
+    // linear in `N.L` and the clamp that used to bound it is re-applied per fragment.
+    @location(9) base_lit: vec3<f32>,
 }
 
 // Terrain's point-light **candidacy half-width** (yd): the reference's guaranteed covered box is
@@ -124,41 +316,232 @@ const TERRAIN_REACH: f32 = 33.570166;
 // The M2 lane in wow_model.wgsl still uses the packed per-light range — its own `w` is 0 (a ±10 yd
 // box, a *different* byte-pinned number), a change that would move the approved interior look, so it
 // is the director's to weigh. The two lanes diverge on purpose; do not "fix" them back into one.
-fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
+// MONKEY (outdoor torch shadows: terrain, MIRRORED from wow_model.wgsl / static_gx.wgsl - keep in
+// sync): the <=`EXT_SEL_K`-nearest selection packed into FOUR u32s, twelve 8-bit indices (rank 0 in
+// the low byte of `.x`) with `EXT_SEL_EMPTY` for an unfilled rank. It exists so the per-FRAGMENT
+// shadowed term below can re-evaluate the VERTEX stage's choice rather than making its own -
+// re-ranking per fragment would draw a hard line wherever the ranking flips, and on terrain that
+// line would run straight through the middle of an MCNK cell, which is exactly the chunk-shaped
+// popping the 0285 anchor removed.
+//
+// MONKEY (ext light k12) - **WHY K WENT 3 -> 8.** Three is the reference FFP's own commit limit (GL
+// slots 1-3; wow-re `wmo-surface-dynamic-light` sections 4/6) and it was the right number for the
+// reference's SPARSE, hand-authored light set: with two or three authored lights in a village the
+// nearest three IS all of them, and no two draw units can disagree. benilla does not have that set
+// - `fire_light.rs` SYNTHESISES a point light for every torch, lantern, brazier and campfire
+// GameObject/doodad in range, so a lamp-lit set piece now puts 15+ exterior fixtures inside ONE
+// chunk's candidacy box (measured at the Darkmoon Faire: 12 `Free Standing Torch 01` + 3
+// `General Lantern 01` within reach of the player's chunk, plus a stall lamp and the fireworks'
+// spell lights). Once the candidates outnumber the slots, adjacent draw units keep DIFFERENT
+// threes; and because the boundary between draw units is a straight line - an MCNK cell edge, or
+// the jump from a cell-anchored chunk to the origin-anchored bench standing on it - the
+// disagreement reads as a HARD STRAIGHT EDGE across a torch's pool of light (the director's
+// "scars"), and as a bench lit by a firework over ground that is not. More slots make neighbouring
+// units AGREE, so a pool ends where the FALLOFF ends instead of where the cell does; the only open
+// question is how many is enough, and the next paragraph answers it with the measurement.
+//
+// 8 bits per rank caps the LIVE table at 255 real entries, `EXT_SEL_EMPTY` = 255 being the
+// sentinel; `global_light::MAX_LIVE_POINT_LIGHTS` enforces that CPU-side. The buffer still carries
+// 256 slots, so `LightStd430` keeps its 8528 B and no mirror struct moves.
+//
+// MONKEY (ext light k12) - **AND WHY 8 -> 12, one round later.** Eight was MARGINAL the day it
+// landed and the note here said so. The Darkmoon Faire's densest chunk holds THIRTEEN candidates
+// and EIGHT of them stand strictly inside its own 33.33 yd cell, so a torch 2.5 yd outside the edge
+// - lighting the grass right at the seam - cannot win a slot under any ranking, and that chunk goes
+// on disagreeing with its neighbour about it. On that particular seam K=8 did not help, it made
+// things WORSE (0.198 -> 0.356 of a falloff unit): raising K let the SPARSE neighbour take in
+// lights the dense chunk still had no room for, so the two sets grew further apart, not closer.
+// Twelve is the first K at which every chunk around the player keeps everything it can see bar one:
+//
+//   worst ABSOLUTE seam jump, the four chunks meeting at the corner nearest WoW (-9557, 99)
+//   (`k12_table.py` in the scratchpad; falloff units, colour and N.L factored out, the byte-verified
+//   `1/(0.7d + 0.03d^2)`, 200 samples along each shared edge)
+//     seam                     cands      K=3      K=8     K=12     K=16
+//     (-288,2)|(-288,3)         6 | 2   0.0418   0.1117   0.1117   0.1117
+//     (-288,2)|(-287,2)        6 | 13   0.6425   0.0882   0.0669   0.1281
+//     (-288,3)|(-287,3)         2 | 7   0.2888   0.0862   0.0862   0.0862
+//     (-287,2)|(-287,3)        13 | 7   0.1980   0.3556   0.1144   0.1406
+//     WORST                            0.6425   0.3556   0.1144   0.1406
+//
+// Read the last two columns together. At K>=13 every chunk keeps ALL its candidates, so 0.1406 is
+// the CANDIDACY BOX's own floor - the residual disagreement two chunks have because their gather
+// boxes are centred 33 yd apart - and no K can touch it (widening the box is a separate change, and
+// it is the byte-verified one). K=12 measures 0.1144, slightly UNDER that floor, because the dense
+// chunk drops exactly one far candidate its neighbour also barely weights. So twelve ENDS this line
+// of attack: 16 is not better, only wider.
+//
+// The own-origin case in the same table - a bench standing on the ground, ranking from its own
+// position, against the chunk under it - goes 79 % / 71 % / 52 % apart at K=3, to 31 % / 27 % / 5 %
+// at K=8, to 3 % / 1 % / 5 % at K=12. That is the "bench lit by a firework over dark grass" closing.
+//
+// RAISING K FURTHER: `ext_sel_get` and the pack tail index the selection vector dynamically
+// (`sel[s >> 2u]`) and the rank arrays are zero-constructed and filled, so K is not spelled out
+// anywhere but here. The vector is `vec4<u32>` now and holds SIXTEEN rank slots, so K = 13..16 is
+// this constant ALONE - no type site, no interstage field, no `EXT_SEL_NONE` edit. Past 16 the next
+// step is a second `vec4<u32>` (four more interstage components) and `ext_sel_get` learning which
+// vector to read, which is a real change rather than a constant.
+const EXT_SEL_K: u32 = 12u;
+const EXT_SEL_EMPTY: u32 = 255u;
+
+// MONKEY (ext light k12): how many of the `EXT_SEL_K` ranks pay for a CUBE-MAP OCCLUSION lookup in
+// the night lane. The ranking is by distance, so ranks 0..2 are the three fixtures whose term
+// dominates this fragment; ranks 3..11 are the long tail that fixes the SELECTION (the scars) and
+// contribute a soft, low-amplitude wash where a hard-edged shadow would not be legible anyway.
+// Holding the shadowed count at the OLD K keeps the per-fragment cost of the night lane exactly
+// what it was - three table scans and their taps - while the selection itself gets twelve deep.
+const EXT_SEL_SHADOWED: u32 = 3u;
+
+// Unpack rank `s` (0..`EXT_SEL_K`-1) from the four-word selection. MIRRORED - keep in sync.
+fn ext_sel_get(sel: vec4<u32>, s: u32) -> u32 {
+    return (sel[s >> 2u] >> (8u * (s & 3u))) & 255u;
+}
+
+// The RANKING half of the old `point_light_sum`: the same interior-lane skip, the same Chebyshev
+// candidacy box, the same tie order (strictly-less inserts, so an equal distance leaves the earlier
+// table index at the better rank).
+//
+// MONKEY (ext light k12): `box` is the draw unit's HORIZONTAL half-extent in yards, and it changes
+// what "nearest" MEANS - ranking is now by the distance from the light to the unit's AABB, not to
+// the unit's anchor POINT. Terrain's unit is the 33.33 yd MCNK cell, so a torch standing 2 yd
+// outside a cell's edge is 2 yd from the nearest ground that cell draws, yet ~18 yd from its
+// CENTRE, which is how it used to lose its slot to three torches clustered near the middle while
+// lighting nothing of the grass right under it. Clamping the light into the cell box
+// (`max(|d| - box, 0)` per horizontal axis) ranks it the way the ground actually sees it, and - the
+// point of the exercise - makes two ADJACENT cells rank a light on their shared edge almost
+// identically, so their sets agree there. The VERTICAL stays unbounded, exactly as the reference's
+// hash sweep is and as `mcnk_cell_anchor` (which keeps the vertex's own y) already implies.
+// `box = 0` reproduces the old point-anchored ranking BIT-FOR-BIT - that is what the own-origin
+// units (props, entities) pass.
+//
+// CANDIDACY deliberately stays on the anchor POINT: it is the byte-verified gather box, and
+// widening it is a different question from how the survivors are ordered.
+fn point_light_pick(anchor: vec3<f32>, box: f32) -> vec4<u32> {
     let count = u32(wow_light.point_count.x);
-    var sel = array<u32, 3>(0u, 0u, 0u);
-    var sd = array<f32, 3>(1e30, 1e30, 1e30);
+    var sel = array<u32, EXT_SEL_K>();
+    var sd = array<f32, EXT_SEL_K>();
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        sd[s] = 1e30;
+    }
     for (var i = 0u; i < count; i = i + 1u) {
+        // MONKEY (light lanes): skip INTERIOR fixtures. The colour row's `.w` is `0` on an exterior
+        // source and the fixture's reach in yards (always ≥ 1) on one that claims a room, so
+        // `> 0.5` is the lane test. Terrain is exterior by definition: an inn's candles reaching
+        // the grass at the base of its wall — a warm pool on the lawn at night — is the whole bug,
+        // and it is here rather than in the pack because the fixtures MUST stay packed for the
+        // interior lane to light the room they belong to. Skipped BEFORE the ≤`EXT_SEL_K`
+        // ranking, so an interior fixture cannot even occupy a slot an outdoor fire should
+        // have had.
+        if (wow_light.points[2u * i + 1u].w > 0.5) {
+            continue;
+        }
         let pos_range = wow_light.points[2u * i];
         let dv = pos_range.xyz - anchor;
-        let d2 = dot(dv, dv);
         // The hash sweep is horizontal (the grid keys on WoW x/y = Bevy z/x) and has no vertical
-        // bound; ranking below is the full 3-D distance, as `0x71bf90` does.
+        // bound; the ranking below is the full 3-D distance, as `0x71bf90` does.
         if (max(abs(dv.x), abs(dv.z)) > TERRAIN_REACH) {
             continue;
         }
-        if (d2 < sd[0]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = sd[0]; sel[1] = sel[0];
-            sd[0] = d2; sel[0] = i;
-        } else if (d2 < sd[1]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = d2; sel[1] = i;
-        } else if (d2 < sd[2]) {
-            sd[2] = d2; sel[2] = i;
+        // MONKEY (ext light k12): distance to the draw unit's BOX (see the header note). With
+        // `box = 0` both `max`es are identities and this is exactly the old `dot(dv, dv)`.
+        let e = max(abs(dv.xz) - vec2<f32>(box), vec2<f32>(0.0));
+        let d2 = dot(e, e) + dv.y * dv.y;
+        // MONKEY (ext light k12): an `EXT_SEL_K`-deep insertion in place of the hand-unrolled 3-deep
+        // cascade. Both loops are bounded by a module const, so the compiler unrolls them; the
+        // comparison is strictly-less, which keeps the old tie order (first-found wins).
+        //
+        // The guard on the WORST kept rank first: `sd` is sorted, so a candidate that cannot beat
+        // `sd[K-1]` cannot beat anything, and the scan below would walk all eight slots only to
+        // decide that. It makes the REJECT path - which is what nearly every table entry takes once
+        // the set is full - ONE comparison, i.e. cheaper than the three the old cascade spent, so
+        // widening K did not make the common case more expensive. Exactly equivalent to letting the
+        // scan run: `d2 >= sd[K-1]` is precisely the condition under which it returns `r = K`.
+        if (d2 >= sd[EXT_SEL_K - 1u]) {
+            continue;
+        }
+        var r = EXT_SEL_K;
+        for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+            if (d2 < sd[s]) {
+                r = s;
+                break;
+            }
+        }
+        if (r < EXT_SEL_K) {
+            for (var s = EXT_SEL_K - 1u; s > r; s = s - 1u) {
+                sd[s] = sd[s - 1u];
+                sel[s] = sel[s - 1u];
+            }
+            sd[r] = d2;
+            sel[r] = i;
         }
     }
+    // Pack low-byte-first, `EXT_SEL_EMPTY` for a rank nothing reached. No real index can collide
+    // with the sentinel: the live table caps at 255 (`MAX_LIVE_POINT_LIGHTS`).
+    var packed = vec4<u32>(0u, 0u, 0u, 0u);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = select(EXT_SEL_EMPTY, sel[s], sd[s] <= 9.9e29);
+        packed[s >> 2u] |= idx << (8u * (s & 3u));
+    }
+    return packed;
+}
+
+// The EVALUATION half - the byte-verified falloff `1/(0.7d + 0.03d^2)` x `max(N.L, 0)` x the
+// committed colour, in rank order, stopping at the first empty rank exactly as the old
+// `sd[s] > 9.9e29` break did (an unfilled rank packs as `EXT_SEL_EMPTY`, and no real index can
+// collide with it: the live table caps at 255). MONKEY (ext light k12): up to `EXT_SEL_K` terms now,
+// still Gouraud (per vertex) and still linear in the falloff, so nothing about the day lane's FORM
+// changed - a chunk simply stops dropping the fixtures its neighbour kept.
+fn point_light_eval(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
     var sum = vec3<f32>(0.0);
-    for (var s = 0u; s < 3u; s = s + 1u) {
-        if (sd[s] > 9.9e29) {
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
             break;
         }
-        let pos_range = wow_light.points[2u * sel[s]];
-        let to_light = pos_range.xyz - P;
+        let to_light = wow_light.points[2u * idx].xyz - P;
         let d = length(to_light);
         let atten = 1.0 / (0.7 * d + 0.03 * d * d);
         let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
-        sum += wow_light.points[2u * sel[s] + 1u].rgb * (atten * nl);
+        sum += wow_light.points[2u * idx + 1u].rgb * (atten * nl);
+    }
+    return sum;
+}
+
+// MONKEY (outdoor torch shadows: terrain): the SHADOWED evaluation - the SAME entries the
+// vertex picked, each multiplied by its OWN fixture's cube-map occlusion, so a crate between the
+// campfire and this patch of grass darkens the campfire's term while the brazier across the road is
+// untouched. This is what step (a) already did for WMO exteriors and models; without it a
+// character's shadow stopped dead at the grass.
+//
+// MONKEY (ext light k12): the SUM runs to `EXT_SEL_K`, but only the first `EXT_SEL_SHADOWED` ranks
+// pay for an occlusion lookup - each of those costs a <=16-slot table scan and four comparison taps,
+// so the per-fragment cost of this lane is pinned at exactly what it was before the widening while
+// the selection itself got twelve deep. Ranks 3..11 are the distance-ordered tail: they are what
+// makes a torch's pool agree across a cell edge, and they arrive unshadowed, which at their
+// amplitude is not a look the eye can separate from a shadowed one. Reached only under
+// `torch_ext_on()` - so it is night-only and dead with `exteriorShadows 0`. `TORCH_SKIP_EPS` drops
+// the scan entirely wherever the unshadowed term is already invisible, which on terrain is most of
+// the frame (ground facing away from the fire, or far enough out that the falloff has taken the
+// term below a code).
+fn point_light_eval_shadowed(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
+            break;
+        }
+        let fixture = wow_light.points[2u * idx].xyz;
+        let to_light = fixture - P;
+        let d = length(to_light);
+        let atten = 1.0 / (0.7 * d + 0.03 * d * d);
+        let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
+        // MONKEY (torch lane perf): the occlusion is a factor on a term that is already zero on any
+        // ground facing away from the fire.
+        let ext_w = atten * nl;
+        var occ = 1.0;
+        if (s < EXT_SEL_SHADOWED && ext_w > TORCH_SKIP_EPS) {
+            occ = torch_terrain_shadow(fixture, P, N);
+        }
+        sum += wow_light.points[2u * idx + 1u].rgb * (ext_w * occ);
     }
     return sum;
 }
@@ -188,6 +571,11 @@ fn mcnk_cell_anchor(P: vec3<f32>) -> vec3<f32> {
     return vec3<f32>((ix + 0.5) * cell - half, P.y, (iz + 0.5) * cell - half);
 }
 
+// MONKEY (ext light k12): the MCNK cell's HORIZONTAL half-extent (yd) - the `box` a cell-anchored
+// draw unit ranks by. The same grid constant as above, halved: 533.33333/16/2 = 16.666666. An
+// own-origin unit passes 0 instead. MIRRORED in wow_model.wgsl / static_gx.wgsl - keep in sync.
+const MCNK_CELL_HALF: f32 = 533.33333 / 32.0;
+
 @vertex
 fn vertex(in: Vertex) -> TerrainVsOut {
     var out: TerrainVsOut;
@@ -196,6 +584,7 @@ fn vertex(in: Vertex) -> TerrainVsOut {
         mesh_functions::mesh_position_local_to_world(world_from_local, vec4<f32>(in.position, 1.0));
     out.clip_position = position_world_to_clip(out.world_position.xyz);
     let world_normal = mesh_functions::mesh_normal_local_to_world(in.normal, in.instance_index);
+    out.world_normal = world_normal;
     out.uv = in.uv;
     out.uv_b = in.uv_b;
     out.color = in.color;
@@ -211,13 +600,23 @@ fn vertex(in: Vertex) -> TerrainVsOut {
     out.specular = clamp(wow_light.light_spec.rgb * pow(ndoth, wow_light.light_spec.w), vec3<f32>(0.0), vec3<f32>(1.0));
 
     // STEP 3 at the faithful locus — the WHOLE diffuse sum, clamped HERE per vertex (see the
-    // struct note). Sun: `ambient + diffuse·max(N·L,0)` on the MCNR normal; points: the ≤3-nearest
-    // committed lights of this vertex's MCNK chunk cell — the terrain draw unit (0285) — at the
+    // struct note). Sun: `ambient + diffuse·max(N·L,0)` on the MCNR normal; points: the
+    // ≤`EXT_SEL_K`-nearest committed lights of this vertex's MCNK chunk cell — the terrain draw
+    // unit (0285), ranked from the CELL BOX (`MCNK_CELL_HALF`, see `point_light_pick`) — at the
     // byte-verified `1/(0.7d + 0.03d²)`, raw over-gamut colours in.
     let ndotl = max(dot(n, l), 0.0);
-    let points = point_light_sum(out.world_position.xyz, n, mcnk_cell_anchor(out.world_position.xyz));
+    // MONKEY (outdoor torch shadows: terrain): the selection is PUBLISHED so the fragment stage can
+    // shadow this same selection at night without re-ranking. One table walk still, not two -
+    // the sum was always `eval(pick(..))`, it is just no longer inlined.
+    let sel = point_light_pick(mcnk_cell_anchor(out.world_position.xyz), MCNK_CELL_HALF);
+    out.ext_sel = sel;
+    let points = point_light_eval(sel, out.world_position.xyz, n);
+    let sun_lighting = wow_light.light_diffuse.rgb * ndotl;
+    // The sun/ambient half on its own slot, UNCLAMPED (see `base_lit`) - the night lane's only way
+    // back to a `primary` that does not already have the unshadowed point term baked into it.
+    out.base_lit = wow_light.light_ambient.rgb + sun_lighting;
     out.primary = clamp(
-        wow_light.light_ambient.rgb + wow_light.light_diffuse.rgb * ndotl + points,
+        wow_light.light_ambient.rgb + sun_lighting + points,
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
@@ -277,11 +676,63 @@ fn fragment(in: TerrainVsOut) -> @location(0) vec4<f32> {
     specmask = mix(specmask, s3.a, a.b);
 
     // STEP 3 (diffuse) arrives from the vertex stage, ALREADY summed (ambient + sun N·L + the
-    // chunk's ≤3 committed point lights) and ALREADY clamped — Gouraud of the clamped vertex
+    // chunk's committed point lights) and ALREADY clamped — Gouraud of the clamped vertex
     // colour, byte-faithful to GL T&L (see the `primary` struct note; the MCNR normal and the
     // DayNight sun share a space per the Phase-0 validation). The MCSH ×(0.3·s + 0.7) factor below
     // still scales the whole modulate, as the traced combine does.
-    let primary = in.primary;
+    // Fetch the character coverage here, but apply it as a NEUTRAL scalar after the terrain's
+    // authored lighting below. Subtracting the warm sun RGB left only Elwynn's green ambient and
+    // produced a green silhouette on yellow morning ground. The era-style projected shadow is a
+    // greyscale attenuation: it darkens the existing hue instead of changing it.
+    // Keep the raw fetch for the specular gate below. The realtime map now contains CHARACTERS
+    // only; MCSH contains the static world's baked blockers. They are independent occluders, so
+    // the character map must never replace (and thereby brighten) the authored terrain bake.
+    // MONKEY (shadow hook): the realtime shadow — fetch + edge fade (toward the `shadowDistance`
+    // range in `_wmo_fog[1].z`) + night fade (`fog_params.z`) — is computed by `benilla::shadow_hook`.
+    // Terrain keeps only its own MCSH suppression + spec gate below; `sun_shadow_strength` feeds the
+    // MCSH fade-back.
+    let view_z = (view.view_from_world * in.world_position).z;
+    let cam_dist = distance(in.world_position.xyz, view.world_position.xyz);
+    let sun_shadow_strength = wow_light.fog_params.z;
+    // Hoisted out of the `realtime_shadow` call (same expression, same bits) because the torch lane
+    // below needs the same normal for its normal-offset sample.
+    let n_lit = normalize(in.world_normal);
+    let world_shadow = shadow_hook::realtime_shadow(
+        in.world_position,
+        n_lit,
+        view_z,
+        cam_dist,
+        wow_light._wmo_fog[1].z,
+        sun_shadow_strength,
+    );
+    // MONKEY (outdoor torch shadows: terrain): the exterior point term, CAST-SHADOWED at night.
+    //
+    // `in.primary` is the Gouraud (per-vertex, per-vertex-CLAMPED) diffuse, and it stays the only
+    // thing this lane reads by day. After dark the same entries the vertex picked
+    // (`in.ext_sel`) are re-evaluated PER FRAGMENT with each fixture's own cube-map occlusion folded
+    // in, re-summed onto the sun/ambient half (`in.base_lit`) and re-clamped here - the clamp has to
+    // move to the fragment because the shadow is a per-fragment quantity, and clamping the sum is
+    // still the faithful GL order (saturate the light sum, then modulate the texture).
+    //
+    // Written as a BLEND rather than a swap, for the same two reasons the model and WMO lanes are:
+    //   - `fog_params.z` is EXACTLY 1.0 whenever the sun is above the daylight threshold
+    //     (`global_light::sun_shadow_strength` is a smoothstep that saturates), so `ext_night_w` is
+    //     exactly 0, the branch is not entered, and DAYTIME IS THE SAME BITS - not "a mix that ought
+    //     to round back to `in.primary`". Nothing here is evaluated by day at any cost.
+    //   - at dusk the shadow, and the Gouraud->per-fragment change of the term itself, arrive on the
+    //     same clock the sun shadows leave on instead of snapping at a threshold.
+    // `torch_ext_on()` is the CPU's one-bit verdict (`exteriorShadows` AND night AND at least one
+    // promoted exterior fixture), so with the cvar off this is dead too.
+    var primary = in.primary;
+    let ext_night_w = select(0.0, clamp(1.0 - sun_shadow_strength, 0.0, 1.0), torch_ext_on());
+    if (ext_night_w > 0.0) {
+        let primary_night = clamp(
+            in.base_lit + point_light_eval_shadowed(in.ext_sel, in.world_position.xyz, n_lit),
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        );
+        primary = mix(in.primary, primary_night, ext_night_w);
+    }
 
     // STEP 4: MCSH baked shadow. On the reference path (pixelShaders+specular) terrain is ONE pass
     // through `terrainp_s.bls`, which carries the MCSH bit in the blend texture's alpha (1.0 lit / 0.0
@@ -294,16 +745,44 @@ fn fragment(in: TerrainVsOut) -> @location(0) vec4<f32> {
         let mcsh = textureSample(shadow_array, splat_samp, auv, i32(round(si))).r;
         shadow_lit = 1.0 - mcsh;
     }
+    // MONKEY (world shadows): when the realtime WORLD-shadow lane is active (`worldShadows` on), the
+    // BAKED MCSH terrain shadows are redundant — the realtime map now shadows the static world
+    // (trees + buildings) too — and keeping both double-shadows. So drop MCSH then. This keys on the
+    // world lane flag (`sh_c16.w`, packed by `global_light::build_light_data`), NOT on the mere
+    // presence of a directional light: the shared shadow sun ALSO exists for CHARACTER-only shadows,
+    // and those must leave the world's baked MCSH intact. With the world lane off, `shadow_lit_eff`
+    // keeps MCSH and only the realtime `character_shadow_term` adds the dynamic character shadow.
+    // The world lane suppresses baked MCSH — but only by `sun_shadow_strength`, so as the realtime
+    // world shadow fades at night the baked MCSH fades back IN. By day (strength 1) MCSH is fully
+    // replaced; at night (strength 0) the authored bake returns; dusk crossfades. Character-only
+    // (lane flag off) never suppresses MCSH.
+    let world_shadow_lane = wow_light.sh_c16.w > 0.5;
+    let mcsh_suppress = select(0.0, sun_shadow_strength, world_shadow_lane);
+    let shadow_lit_eff = mix(shadow_lit, 1.0, mcsh_suppress);
+    let spec_gate = min(shadow_lit, world_shadow);
+    let character_shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, world_shadow);
 
     // The faithful `terrainp_s` combine (Q15):
     //   diffuse  = tex · primary · (0.3·shadow + 0.7)   → a flat −30% in shadow, NO colour tint
     //   specular = per-vertex sheen · gloss_mask · shadow → gated to ZERO in shadow (no sheen in shade)
     // (`tex·primary` is the MODULATE-1× diffuse; the sheen is added after, separate-specular.) Then
     // LDR-clamp; gamma/byte throughout; raw gamma out (GAMMA LANE, 0161).
-    let diffuse_term = color * primary * (0.3 * shadow_lit + 0.7);
-    let spec_term = in.specular * specmask * shadow_lit;
+    let diffuse_term = color * primary * (0.3 * shadow_lit_eff + 0.7) * character_shadow_term;
+    let spec_term = in.specular * specmask * spec_gate;
     var tuned = clamp(diffuse_term + spec_term, vec3<f32>(0.0), vec3<f32>(1.0));
 
+    // MONKEY (torch debug, interiorDebug 2 on TERRAIN): the ground's OWN cube-map sampling as
+    // greyscale, the same instrument static_gx and wow_model already paint on walls and bodies. The
+    // mode rides `wmo_fog_params.w` packed as `1 + debug` (rows 18-19 here, hence `_wmo_fog[1]`), so
+    // a zero - the interior lane off entirely - decodes to mode 0 and this is dead. Only mode 2 is
+    // answered: 1/3/4 are questions about the INTERIOR lane and the WMO group classes, and terrain
+    // belongs to neither, so leaving it normally shaded is what makes those three views readable.
+    // Placed before the fog so a distant reading still fogs like the surfaces beside it.
+    let idbg = u32(max(wow_light._wmo_fog[1].w - 1.0, 0.0) + 0.5);
+    if (idbg == 2u) {
+        tuned = vec3<f32>(torch_terrain_debug_factor(in.world_position.xyz, n_lit));
+    }
+
     // STEP 5: gamma-space linear fog (q6). Applied AFTER tone/curve (so the diagnostic knobs see
     // the unfogged lit pixel) and BEFORE the viz bypass + raw output. The fog coordinate is
     // PLANAR eye-Z (view-space depth along the camera forward axis), NOT radial distance: the
diff --git a/crates/benilla-assets/src/shaders/wow_model.wgsl b/crates/benilla-assets/src/shaders/wow_model.wgsl
index 6f78406a..0af0af19 100644
--- a/crates/benilla-assets/src/shaders/wow_model.wgsl
+++ b/crates/benilla-assets/src/shaders/wow_model.wgsl
@@ -47,9 +47,12 @@
     pbr_functions::alpha_discard,
     pbr_bindings,
     forward_io::VertexOutput,
-    mesh_view_bindings::view,
+    mesh_view_bindings::{lights, view},
+    shadows,
     mesh_functions,
 }
+// MONKEY (shadow hook): the realtime directional-shadow term (fetch + edge/night fade) lives here.
+#import benilla::shadow_hook
 
 // Our own fragment output — bevy's `forward_io::FragmentOutput` verbatim (`@location(0) color` and
 // nothing else, bevy_pbr 0.18.1 `forward_io.wgsl`), kept as a named struct so the lane's output
@@ -104,6 +107,9 @@ struct ModelParams {
 };
 @group(#{MATERIAL_BIND_GROUP}) @binding(100) var<uniform> m: ModelParams;
 
+// A fully covered character shadow retains 45% of the authored model lighting.
+const SHADOW_SUN_FLOOR: f32 = 0.45;
+
 // The shared global light (lighting::global_light): ONE storage buffer every material reads, updated
 // once/frame in place — replaces the per-material light/fog uniforms the old apply_wow_lighting re-pushed
 // each frame. The model reads rows 0-2 (ambient/diffuse/sun) + fog, plus rows 6-12: the disassembled
@@ -137,9 +143,12 @@ struct WowLight {
     sh_c13_r: vec4<f32>,
     sh_c13_g: vec4<f32>,
     sh_c13_b: vec4<f32>,
-    // xyz = the true c16 quad band (x²−y², per channel), live with the block above. w = FREE — it
-    // carried the 0273 point gain, then the 0750/0751 sun dial, then 0799's response A/B, and every
-    // one of those is retired. Nothing writes it and nothing reads it; claim it if you need a lane.
+    // xyz = the true c16 quad band (x²−y², per channel), live with the block above. `.w` is the
+    // SHARED world-shadow / bake-floor lane, and it is no longer free: its INTEGER part is the
+    // `worldShadows` flag (`terrain.wgsl`'s MCSH gate reads `> 0.5`) and MONKEY (bake floor) its
+    // FRACTION is `interiorBakeFloor × interiorGain × BAKE_LANE_SCALE`, which the interior entity
+    // lane below decodes. (It had carried the 0273 point gain, the 0750/0751 sun dial and 0799's
+    // response A/B before those were retired — hence the long-standing "free" note here.)
     sh_c16: vec4<f32>,
     _water: array<vec4<f32>, 4>, // rows 13-16: the liquid swatches — unread by models.
     // x = SIDN night fraction (1 overnight, 0 by day — scales m.sidn.rgb).
@@ -151,9 +160,16 @@ struct WowLight {
     wmo_fog_color: vec4<f32>,    // rgb interior fog (gamma); w = enable (mirrors fog_color.w)
     wmo_fog_params: vec4<f32>,   // x = start yd; y = end yd; zw = free lanes (retired A/B dials)
     // The dynamic point-light table (decision 0278), packed by `global_light::build_light_data`:
-    // row 20 `.x` = live entry count; then TWO rows per light — `[pos.xyz, range]`, `[rgb, 0]`.
+    // row 20 `.x` = live entry count; then TWO rows per light — `[pos.xyz, range]`, `[rgb, lane]`.
     // Rides this buffer (not bevy's clusterables) because the view layout exposes those to the
     // fragment stage only, and the Gouraud term is evaluated in the VERTEX stage.
+    //
+    // MONKEY (light lanes): the colour row's `.w` splits the table into two DISJOINT halves.
+    // `0` = an EXTERIOR light (nothing claims a room) — read only by `point_light_sum`. Anything
+    // `> 0.5` = an INTERIOR fixture — read only by `interior_room_light`, and the value itself is
+    // that fixture's REACH IN YARDS (its authored MOLT attenuation end, or the M2 intensity
+    // bucket, already scaled by the live `interiorAttenScale`). One float carries both because a
+    // packed reach is always ≥ 1 yd and can never be mistaken for the exterior 0.
     point_count: vec4<f32>,
     points: array<vec4<f32>, 512>,
     // The interior-prop SH probe table (lighting::prop_probes — 7 rows per slot, 8192 slots; keep in
@@ -196,6 +212,179 @@ struct WowLight {
 };
 @group(#{MATERIAL_BIND_GROUP}) @binding(90) var<storage, read> wow_light: WowLight;
 
+// MONKEY (torch shadows Phase 3A): the ENTITY receiver's torch bindings — the SAME depth array
+// static_gx's group 3 samples (one shared `Image`, rendered by `static_gx::torch_depth`) and the
+// SAME 6416-byte table, riding the material's own group (`WowModelExt` bindings 91/92/93) because
+// a Bevy material draw sets groups 0/1/2 only. ALWAYS bound (the image and buffer exist from
+// startup), so no shader-def guards this block; only the fragment stage reads it. The struct is
+// std430 here and std140 in static_gx — identical bytes, every member is 16-aligned.
+struct TorchTable {
+    // MONKEY (static torch cache): byte-identical in BOTH shaders and TorchTableUniform.
+    // count@0 (16): x high-water slot count, y soft*100, z dynamic/live-bank mask, w reserved.
+    // positions@16 (256), view_projs@272 (6144): total 6416 bytes. A mismatch hides buildings.
+    // MONKEY (live bank rank): 96 static layers + 48 live layers; matrices stay slot-addressed.
+    count: vec4<u32>,
+    positions: array<vec4<f32>, 16>,
+    view_projs: array<mat4x4<f32>, 96>,
+}
+@group(#{MATERIAL_BIND_GROUP}) @binding(91) var torch_depth: texture_depth_2d_array;
+@group(#{MATERIAL_BIND_GROUP}) @binding(92) var torch_samp: sampler_comparison;
+@group(#{MATERIAL_BIND_GROUP}) @binding(93) var<storage, read> torch_table: TorchTable;
+// Reverse-Z receiver bias — KEEP IN SYNC with static_gx.wgsl's TORCH_BIAS (0.001, the known-good
+// value; larger detaches every shadow far from the torch).
+const TORCH_BIAS: f32 = 0.001;
+// NORMAL-OFFSET for entity receivers (yd): sample the map a hand's width OUTSIDE the surface along
+// its normal. An entity's caster is the CPU-skinned copy of the same body; the GPU-skinned receiver
+// differs by tiny pose/interpolation deltas, so with a plain depth compare every fragment sits a
+// hair BEHIND its own caster and the body shadows itself everywhere (a solid-black NPC in
+// interiorDebug 2, flickering shadows in the real render). Pushing the sample point out of the skin
+// makes self-occlusion impossible while a pillar or another character still casts onto it.
+const TORCH_NORMAL_OFFSET: f32 = 0.15;
+// MONKEY (torch caster selection, MIRRORED from static_gx.wgsl): the live PCF tap-radius scale
+// (count.y LOW half) and MONKEY (shadow floor)'s strength (HIGH half),
+// unpacked from the table's `count.y` (stored x100 — the row is `vec4<u32>`).
+fn torch_soft() -> f32 {
+    return max(f32(torch_table.count.y & 0xffffu) * 0.01, 0.05);
+}
+// MONKEY (shadow floor): the live SHADOW STRENGTH (`torchShadowStrength`, 0..1, default 0.7),
+// unpacked from `count.y`'s HIGH half (`(strength x 100) << 16 | soft x 100` - see
+// `TorchTableUniform::pack`; the low half is `torch_soft` above and `count.w`'s flags are
+// untouched). It is applied as `mix(1, s, w * strength)` where the cross-fade weight already
+// multiplies the shadow factor, which is algebraically the same thing as flooring the factor
+// itself (`1 - w*strength*(1-s)` either way) for one extra multiply and no extra tap.
+//
+// WHY a floor at all: a torch map is the ONLY occlusion in the direct term, so a blocked fragment
+// used to drop that term to exactly zero - a pitch-black, razor-edged scar of tent canvas across
+// Darkmoon's grass, table legs printed on the Darkshire inn floor. Nothing in this renderer
+// bounces, so the 30 % that survives at the default IS the bounce: the fill/ambient arms are
+// untouched (they never saw this factor), only the DIRECT arm is floored. 1 restores the shipped
+// pitch-black look exactly, 0 disables torch shadows without disturbing the lane behind them.
+fn torch_strength() -> f32 {
+    return clamp(f32(torch_table.count.y >> 16u) * 0.01, 0.0, 1.0);
+}
+// MONKEY (outdoor torch shadows, MIRRORED from static_gx.wgsl — keep in sync): the EXTERIOR lane's
+// world-distance fade radius (yd) and the CPU's one-bit lane gate in `count.w`. See the static_gx
+// copies for the full rationale (the interior `ndc.z` fade is already down to 5 % at 10 yd, which
+// erases a campfire's 15-25 yd pool).
+const TORCH_EXT_FADE_YD: f32 = 44.0;
+const TORCH_EXT_LANE: u32 = 1u;
+// MONKEY (torch lane perf): below THIS much unshadowed direct contribution a fragment skips the
+// torch table scan and its four comparison taps entirely, because the shadow factor is multiplied
+// into that contribution and can therefore only ever subtract less than this from the frame.
+//
+// Sized off what the eye can see, not off "small": the interior budget goes through the
+// `1 - exp(-x * exposure)` rolloff, which for a term this small is just `x * exposure`, so at the
+// shipped `interiorExposure 2.5` the worst possible step across the guard's boundary is
+// 2.5e-4 linear = well under one 8-bit code. A tenth of this (1e-3) would have been a visible
+// ~8/255 contour along the iso-surface where the guard flips. Most of the skips it buys are exact
+// zeros anyway -- `window` IS 0 past the fixture's reach and `nl` IS 0 on a surface facing away --
+// so the threshold only has to be small enough to be invisible, never large enough to be useful.
+const TORCH_SKIP_EPS: f32 = 1e-4;
+fn torch_ext_on() -> bool {
+    return (torch_table.count.w & TORCH_EXT_LANE) != 0u;
+}
+
+// MONKEY (Phase 5, MIRRORED from static_gx.wgsl — keep in sync): the cube face that contains
+// direction `d` (fixture → fragment) — the major axis, signed. Face order is the contract with
+// `benilla_app::torch_shadow::cube_view_projs`: 0 +X, 1 −X, 2 +Y, 3 −Y, 4 +Z, 5 −Z.
+fn torch_face(d: vec3<f32>) -> u32 {
+    let a = abs(d);
+    if (a.x >= a.y && a.x >= a.z) {
+        return select(1u, 0u, d.x > 0.0);
+    }
+    if (a.y >= a.z) {
+        return select(3u, 2u, d.y > 0.0);
+    }
+    return select(5u, 4u, d.z > 0.0);
+}
+
+// MONKEY (torch shadows Phase 3A): this interior fixture's OWN cast shadow on an ENTITY fragment —
+// exactly static_gx.wgsl's `torch_surface_shadow` (keep in sync): correlate the `wow_light`
+// fixture at `light_pos` to a promoted torch (position match within 1 yd), pick the cube face
+// facing the fragment, and sample that layer through the shared projector. 1.0 (unshadowed) when
+// no map matches — the lane is off, or the fixture was not among the ≤4 promoted.
+//
+// MONKEY (outdoor torch shadows): `fade_radius` picks the far fade and is the ONLY lane difference
+// (`0` = the interior/legacy `ndc.z` fade, bit-for-bit; `> 0` = the exterior world-distance fade
+// measured from the fixture). MIRRORS static_gx.wgsl's `torch_map_at`.
+fn torch_entity_shadow_at(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>, fade_radius: f32) -> f32 {
+    // MONKEY (torch lane perf): MIRRORS static_gx.wgsl's `torch_map_at` — the empty table is the
+    // common case, so answer it before the normal offset and the loop set-up.
+    if (torch_table.count.x == 0u) {
+        return 1.0;
+    }
+    // Normal-offset the sample point out of the body (see TORCH_NORMAL_OFFSET).
+    let Ps = P + N * TORCH_NORMAL_OFFSET;
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        // MONKEY (static torch cache): holes and pending uploads never sample stale layers.
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let fixture = torch_table.positions[i].xyz;
+        if (distance(fixture, light_pos) < 1.0) {
+            let face = torch_face(Ps - fixture);
+            let layer = i * 6u + face;
+            // MONKEY (live bank rank): count.z is CPU-ready-filtered; holes must not consume
+            // live cubes. Keep the projection on the static slot while compacting depth only.
+            let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+            let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+            // MONKEY (outdoor torch shadows): negative = the interior contract (let the projector
+            // use its own reverse-Z far fade); otherwise this lane's world-distance weight.
+            let fade = select(
+                -1.0,
+                1.0 - smoothstep(0.8 * fade_radius, fade_radius, distance(fixture, Ps)),
+                fade_radius > 0.0,
+            );
+            // MONKEY (slope bias): the entity's own normal - the one `Ps` was offset along.
+            let s = shadow_hook::torch_map_shadow(
+                torch_table.view_projs[layer], i32(depth_layer), Ps, N, torch_depth, torch_samp,
+                TORCH_BIAS, torch_soft(), fade);
+            // MONKEY (torch caster selection, MIRRORED from static_gx.wgsl): `.w` is the slot's
+            // FADE WEIGHT, so a promoted fixture's shadow ramps in over ~1/3 s and a demoted one
+            // ramps out. An entity and the floor under it MUST use the same weight or the NPC's
+            // shadow would pop while the floor's faded.
+            // MONKEY (shadow floor): and `torch_strength()` is the DIRECT-term floor folded
+            // into that same weight (see the function). `w * strength` rather than a second `mix`
+            // because the two are the same expression.
+            return mix(1.0, s, torch_table.positions[i].w * torch_strength());
+        }
+    }
+    return 1.0;
+}
+
+// The INTERIOR lane's call - unchanged behaviour (`fade_radius 0` => the reverse-Z `ndc.z` fade).
+fn torch_entity_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+    return torch_entity_shadow_at(light_pos, P, N, 0.0);
+}
+
+// MONKEY (outdoor torch shadows): the EXTERIOR lane's call - a campfire/brazier/lamppost throwing
+// the player, an NPC or a doodad's shadow across the ground and the wall behind them.
+fn torch_entity_exterior_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+    return torch_entity_shadow_at(light_pos, P, N, TORCH_EXT_FADE_YD);
+}
+
+// MONKEY (torch debug, interiorDebug 2 on ENTITIES): the MIN raw cube-map shadow factor over every
+// promoted fixture (ignoring the fixture match) — mirrors static_gx's `torch_debug_factor`, so an
+// entity's sampling can be SEEN as greyscale: all-white = the table is empty / the projection misses;
+// shaped dark = the depth map reaches the entity and any fault is downstream of sampling.
+fn torch_entity_debug_factor(P: vec3<f32>, N: vec3<f32>) -> f32 {
+    let Ps = P + N * TORCH_NORMAL_OFFSET;
+    var s = 1.0;
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let face = torch_face(Ps - torch_table.positions[i].xyz);
+        let layer = i * 6u + face;
+        // MONKEY (live bank rank): debug samples the same compact bank as the lit path.
+        let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+        let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+        // MONKEY (slope bias): same plane as the lit path, so `interiorDebug 2` stays honest.
+        let raw = shadow_hook::torch_map_shadow(
+            torch_table.view_projs[layer], i32(depth_layer), Ps, N, torch_depth, torch_samp,
+            TORCH_BIAS, torch_soft(), -1.0);
+        // MONKEY (torch caster selection): the WEIGHTED factor, matching the real render.
+        s = min(s, mix(1.0, raw, torch_table.positions[i].w));
+    }
+    return s;
+}
+
 // Vanilla M2 cutout alpha-test reference (224/255 on ≤ WotLK) — kept in sync with
 // `debug_panel::VANILLA_ALPHA_KEY_REF`. Used to re-apply the hard cutout on the distance-fade blend
 // twin so its silhouette matches the steady cutout exactly.
@@ -241,6 +430,15 @@ struct WowVsOut {
 #ifdef WOW_MERGED_SLOT
     @location(10) @interpolate(flat) merged_slot: u32,
 #endif
+    // MONKEY (outdoor torch shadows; ext light k8): WHICH <=`EXT_SEL_K` exterior table entries
+    // `point_lit` was summed from, packed 8 bits each across FOUR u32s (see `EXT_SEL_NONE` /
+    // `ext_sel_get`). FLAT, because it is a choice and not a quantity - interpolating packed
+    // indices would produce a different, meaningless one. `EXT_SEL_NONE` on every lane that takes
+    // no exterior point term (interior WMO surfaces, interior props), which makes the night lane a
+    // no-op there by construction. Widened from ONE u32 of three 10-bit ranks to TWO u32s of eight
+    // 8-bit ranks and then to FOUR u32s of twelve - three extra interstage components in all (25
+    // for this struct, against a 60-component limit) - see `EXT_SEL_K`.
+    @location(11) @interpolate(flat) ext_sel: vec4<u32>,
 }
 
 // The dynamic point-light term at a world-space point (decisions 0016/0273/0278, selection 0285) —
@@ -251,7 +449,8 @@ struct WowVsOut {
 // table instead lit every candelabra pole in the abbey from a dozen sideways fixtures the real
 // client never commits for it — the director's "stands must not light up with the point gain".
 //
-// So: pass 1 picks the ≤3 nearest table entries to `anchor` (the unit position — a light's packed
+// So: pass 1 picks the ≤`EXT_SEL_K` nearest table entries to `anchor` (the unit position, or its
+// AABB where it has one — a light's packed
 // range bounds candidacy); pass 2 evaluates ONLY those at the vertex — the byte-verified falloff
 // `1/(0.7·d + 0.03·d²)`, diffuse-only (committed ambient/specular are zero), on the SUBMITTED normal
 // (the FFP never enables GL_LIGHT_MODEL_TWO_SIDE — no per-face flip). A selected light reaches every
@@ -280,43 +479,432 @@ fn wow_normalize(v: vec3<f32>) -> vec3<f32> {
     return select(vec3<f32>(0.0), normalize(v), l2 > 1e-12);
 }
 
-fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
+// MONKEY (outdoor torch shadows, MIRRORED from static_gx.wgsl — keep in sync): the
+// ≤`EXT_SEL_K`-nearest EXTERIOR selection packed into FOUR u32s, twelve 8-bit indices (rank 0 in the
+// low byte of `.x`) with `EXT_SEL_EMPTY` for an unfilled rank. It exists so the per-FRAGMENT
+// shadowed term below can re-evaluate the VERTEX stage's choice rather than making its own —
+// re-ranking per fragment would draw a hard line wherever the ranking flips, which is precisely
+// what the Gouraud term never does.
+//
+// MONKEY (ext light k12) - **WHY K WENT 3 -> 8.** Three is the reference FFP's own commit limit (GL
+// slots 1-3; wow-re `wmo-surface-dynamic-light` sections 4/6) and it was the right number for the
+// reference's SPARSE, hand-authored light set: with two or three authored lights in a village the
+// nearest three IS all of them, and no two draw units can disagree. benilla does not have that set
+// - `fire_light.rs` SYNTHESISES a point light for every torch, lantern, brazier and campfire
+// GameObject/doodad in range, so a lamp-lit set piece now puts 15+ exterior fixtures inside ONE
+// chunk's candidacy box (measured at the Darkmoon Faire: 12 `Free Standing Torch 01` + 3
+// `General Lantern 01` within reach of the player's chunk, plus a stall lamp and the fireworks'
+// spell lights). Once the candidates outnumber the slots, adjacent draw units keep DIFFERENT
+// threes; and because the boundary between draw units is a straight line - an MCNK cell edge, or
+// the jump from a cell-anchored chunk to the origin-anchored bench standing on it - the
+// disagreement reads as a HARD STRAIGHT EDGE across a torch's pool of light (the director's
+// "scars"), and as a bench lit by a firework over ground that is not. More slots make neighbouring
+// units AGREE, so a pool ends where the FALLOFF ends instead of where the cell does; the only open
+// question is how many is enough, and the next paragraph answers it with the measurement.
+//
+// 8 bits per rank caps the LIVE table at 255 real entries, `EXT_SEL_EMPTY` = 255 being the
+// sentinel; `global_light::MAX_LIVE_POINT_LIGHTS` enforces that CPU-side. The buffer still carries
+// 256 slots, so `LightStd430` keeps its 8528 B and no mirror struct moves.
+//
+// MONKEY (ext light k12) - **AND WHY 8 -> 12, one round later.** Eight was MARGINAL the day it
+// landed and the note here said so. The Darkmoon Faire's densest chunk holds THIRTEEN candidates
+// and EIGHT of them stand strictly inside its own 33.33 yd cell, so a torch 2.5 yd outside the edge
+// - lighting the grass right at the seam - cannot win a slot under any ranking, and that chunk goes
+// on disagreeing with its neighbour about it. On that particular seam K=8 did not help, it made
+// things WORSE (0.198 -> 0.356 of a falloff unit): raising K let the SPARSE neighbour take in
+// lights the dense chunk still had no room for, so the two sets grew further apart, not closer.
+// Twelve is the first K at which every chunk around the player keeps everything it can see bar one:
+//
+//   worst ABSOLUTE seam jump, the four chunks meeting at the corner nearest WoW (-9557, 99)
+//   (`k12_table.py` in the scratchpad; falloff units, colour and N.L factored out, the byte-verified
+//   `1/(0.7d + 0.03d^2)`, 200 samples along each shared edge)
+//     seam                     cands      K=3      K=8     K=12     K=16
+//     (-288,2)|(-288,3)         6 | 2   0.0418   0.1117   0.1117   0.1117
+//     (-288,2)|(-287,2)        6 | 13   0.6425   0.0882   0.0669   0.1281
+//     (-288,3)|(-287,3)         2 | 7   0.2888   0.0862   0.0862   0.0862
+//     (-287,2)|(-287,3)        13 | 7   0.1980   0.3556   0.1144   0.1406
+//     WORST                            0.6425   0.3556   0.1144   0.1406
+//
+// Read the last two columns together. At K>=13 every chunk keeps ALL its candidates, so 0.1406 is
+// the CANDIDACY BOX's own floor - the residual disagreement two chunks have because their gather
+// boxes are centred 33 yd apart - and no K can touch it (widening the box is a separate change, and
+// it is the byte-verified one). K=12 measures 0.1144, slightly UNDER that floor, because the dense
+// chunk drops exactly one far candidate its neighbour also barely weights. So twelve ENDS this line
+// of attack: 16 is not better, only wider.
+//
+// The own-origin case in the same table - a bench standing on the ground, ranking from its own
+// position, against the chunk under it - goes 79 % / 71 % / 52 % apart at K=3, to 31 % / 27 % / 5 %
+// at K=8, to 3 % / 1 % / 5 % at K=12. That is the "bench lit by a firework over dark grass" closing.
+//
+// RAISING K FURTHER: `ext_sel_get` and the pack tail index the selection vector dynamically
+// (`sel[s >> 2u]`) and the rank arrays are zero-constructed and filled, so K is not spelled out
+// anywhere but here. The vector is `vec4<u32>` now and holds SIXTEEN rank slots, so K = 13..16 is
+// this constant ALONE - no type site, no interstage field, no `EXT_SEL_NONE` edit. Past 16 the next
+// step is a second `vec4<u32>` (four more interstage components) and `ext_sel_get` learning which
+// vector to read, which is a real change rather than a constant.
+const EXT_SEL_K: u32 = 12u;
+const EXT_SEL_EMPTY: u32 = 255u;
+// Twelve empty ranks. MONKEY (ext light k12): FOUR words - the vector holds sixteen 8-bit rank
+// slots and only the first `EXT_SEL_K` are ever read, so filling all four with the sentinel costs
+// nothing and leaves no word that could be mistaken for a real index if K is raised again. (The
+// PACK tail below builds its `vec4<u32>` from ZERO and writes only ranks 0..K-1, so its unused high
+// word reads as index 0 rather than the sentinel - harmless, because no loop here ever looks past
+// `EXT_SEL_K`.)
+const EXT_SEL_NONE: vec4<u32> = vec4<u32>(4294967295u, 4294967295u, 4294967295u, 4294967295u);
+
+// MONKEY (ext light k12): how many of the `EXT_SEL_K` ranks pay for a CUBE-MAP OCCLUSION lookup in
+// the night lane. The ranking is by distance, so ranks 0..2 are the three fixtures whose term
+// dominates this fragment; ranks 3..11 are the long tail that fixes the SELECTION (the scars) and
+// contribute a soft, low-amplitude wash where a hard-edged shadow would not be legible anyway.
+// Holding the shadowed count at the OLD K pins the per-fragment cost of the night lane at exactly
+// what it was - three table scans and their taps - while the selection itself gets twelve deep.
+const EXT_SEL_SHADOWED: u32 = 3u;
+
+// Unpack rank `s` (0..`EXT_SEL_K`-1) from the four-word selection. MIRRORED - keep in sync.
+fn ext_sel_get(sel: vec4<u32>, s: u32) -> u32 {
+    return (sel[s >> 2u] >> (8u * (s & 3u))) & 255u;
+}
+
+// The ranking half of `point_light_sum` (same tests, same order, same ties — strictly-less
+// inserts, so an equal distance leaves the earlier table index at the better rank).
+//
+// MONKEY (ext light k12): `box` is the draw unit's HORIZONTAL half-extent in yards, and it changes
+// what "nearest" MEANS - ranking is by the distance from the light to the unit's AABB, not to the
+// unit's anchor POINT. A cell-anchored unit (terrain's 33.33 yd MCNK chunk, clutter, an
+// exterior-class WMO street) passes `MCNK_CELL_HALF`: a torch standing 2 yd outside a cell's edge
+// is 2 yd from the nearest surface that cell draws, yet ~18 yd from its CENTRE, which is how it
+// used to lose its slot to three torches clustered near the middle while lighting nothing of the
+// ground right under it. Clamping the light into the box (`max(|d| - box, 0)` per horizontal axis)
+// ranks it the way the surface actually sees it, and - the point of the exercise - makes two
+// ADJACENT cells rank a light on their shared edge almost identically, so their sets agree there.
+// The VERTICAL stays unbounded, exactly as the reference's hash sweep is. `box = 0` reproduces the
+// old point-anchored ranking BIT-FOR-BIT, and that is what the own-origin units (props, entities)
+// pass, so nothing on those lanes moves.
+//
+// CANDIDACY deliberately stays on the anchor POINT (`dc2` below): it is the byte-verified gather
+// test, and widening it is a different question from how the survivors are ordered.
+fn point_light_pick(anchor: vec3<f32>, box: f32) -> vec4<u32> {
     let count = u32(wow_light.point_count.x);
-    var sel = array<u32, 3>(0u, 0u, 0u);
-    var sd = array<f32, 3>(1e30, 1e30, 1e30);
+    var sel = array<u32, EXT_SEL_K>();
+    var sd = array<f32, EXT_SEL_K>();
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        sd[s] = 1e30;
+    }
     for (var i = 0u; i < count; i = i + 1u) {
-        let pos_range = wow_light.points[2u * i];
-        let dv = pos_range.xyz - anchor;
-        let d2 = dot(dv, dv);
-        if (d2 > pos_range.w * pos_range.w) {
+        // MONKEY (light lanes): skip INTERIOR fixtures (colour row `.w > 0.5`) — they light the
+        // room that claims them and nothing else. Before the split, a proximity-admitted inn
+        // fixture reached every exterior receiver near the building through its own walls. Skipped
+        // BEFORE the ≤`EXT_SEL_K` ranking, so it cannot take a slot an outdoor fire should have
+        // had.
+        if (wow_light.points[2u * i + 1u].w > 0.5) {
             continue;
         }
-        if (d2 < sd[0]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = sd[0]; sel[1] = sel[0];
-            sd[0] = d2; sel[0] = i;
-        } else if (d2 < sd[1]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = d2; sel[1] = i;
-        } else if (d2 < sd[2]) {
-            sd[2] = d2; sel[2] = i;
+        let pos_range = wow_light.points[2u * i];
+        let dv = pos_range.xyz - anchor;
+        let dc2 = dot(dv, dv);
+        if (dc2 > pos_range.w * pos_range.w) {
+            continue;
+        }
+        // MONKEY (ext light k12): rank by the distance to the draw unit's BOX (see the header
+        // note). With `box = 0` both `max`es are identities and this is exactly the old `dc2`.
+        let e = max(abs(dv.xz) - vec2<f32>(box), vec2<f32>(0.0));
+        let d2 = dot(e, e) + dv.y * dv.y;
+        // MONKEY (ext light k12): an `EXT_SEL_K`-deep insertion in place of the hand-unrolled
+        // 3-deep cascade. Both loops are bounded by a module const, so the compiler unrolls them;
+        // the comparison is strictly-less, which keeps the old tie order (first-found wins).
+        //
+        // The guard on the WORST kept rank first: `sd` is sorted, so a candidate that cannot beat
+        // `sd[K-1]` cannot beat anything, and the scan below would walk all eight slots only to
+        // decide that. It makes the REJECT path - which is what nearly every table entry takes once
+        // the set is full - ONE comparison, i.e. cheaper than the three the old cascade spent, so
+        // widening K did not make the common case more expensive. Exactly equivalent to letting the
+        // scan run: `d2 >= sd[K-1]` is precisely the condition under which it returns `r = K`.
+        if (d2 >= sd[EXT_SEL_K - 1u]) {
+            continue;
+        }
+        var r = EXT_SEL_K;
+        for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+            if (d2 < sd[s]) {
+                r = s;
+                break;
+            }
+        }
+        if (r < EXT_SEL_K) {
+            for (var s = EXT_SEL_K - 1u; s > r; s = s - 1u) {
+                sd[s] = sd[s - 1u];
+                sel[s] = sel[s - 1u];
+            }
+            sd[r] = d2;
+            sel[r] = i;
         }
     }
+    // Pack low-byte-first, `EXT_SEL_EMPTY` for a rank nothing reached. No real index can collide
+    // with the sentinel: the live table caps at 255 (`MAX_LIVE_POINT_LIGHTS`).
+    var packed = vec4<u32>(0u, 0u, 0u, 0u);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = select(EXT_SEL_EMPTY, sel[s], sd[s] <= 9.9e29);
+        packed[s >> 2u] |= idx << (8u * (s & 3u));
+    }
+    return packed;
+}
+
+// The evaluation half — the byte-verified falloff `1/(0.7d + 0.03d²)` × `max(N·L, 0)` × the
+// committed colour, in rank order, stopping at the first empty rank exactly as the old
+// `sd[s] > 9.9e29` break did. Shared by both pickers (their sum loops were already identical).
+// MONKEY (ext light k12): up to `EXT_SEL_K` terms now, still Gouraud (per vertex) and still linear
+// in the falloff, so nothing about the day lane's FORM changed — a unit simply stops dropping the
+// fixtures its neighbour kept.
+fn point_light_eval(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
     var sum = vec3<f32>(0.0);
-    for (var s = 0u; s < 3u; s = s + 1u) {
-        if (sd[s] > 9.9e29) {
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
             break;
         }
-        let pos_range = wow_light.points[2u * sel[s]];
-        let to_light = pos_range.xyz - P;
+        let to_light = wow_light.points[2u * idx].xyz - P;
         let d = length(to_light);
         let atten = 1.0 / (0.7 * d + 0.03 * d * d);
         let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
-        sum += wow_light.points[2u * sel[s] + 1u].rgb * (atten * nl);
+        sum += wow_light.points[2u * idx + 1u].rgb * (atten * nl);
     }
     return sum;
 }
 
+// MONKEY (outdoor torch shadows): the SHADOWED evaluation — the same entries the vertex picked,
+// each multiplied by its OWN fixture's cube-map occlusion (normal-offset, like every entity sample
+// on this lane), so a fence between the player and campfire A darkens A's term while lamppost B's
+// is untouched. Reached only under `torch_ext_on()`, so nothing here runs in daylight or with
+// `exteriorShadows 0`.
+//
+// MONKEY (ext light k12): the SUM runs to `EXT_SEL_K`, but only the first `EXT_SEL_SHADOWED` ranks
+// pay for an occlusion lookup, so the per-fragment cost of this lane is pinned at exactly what it
+// was before the widening while the selection itself got twelve deep. Ranks 3..11 are the
+// distance-ordered tail — the terms that make a torch's pool agree across a draw-unit boundary —
+// and they arrive unshadowed, which at their amplitude is not a look the eye can separate from a
+// shadowed one.
+fn point_light_eval_shadowed(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
+            break;
+        }
+        let fixture = wow_light.points[2u * idx].xyz;
+        let to_light = fixture - P;
+        let d = length(to_light);
+        let atten = 1.0 / (0.7 * d + 0.03 * d * d);
+        let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
+        // MONKEY (torch lane perf, MIRRORED from static_gx.wgsl): the occlusion is a factor on a
+        // term that is already zero on any surface facing away from the fire.
+        let ext_w = atten * nl;
+        var occ = 1.0;
+        if (s < EXT_SEL_SHADOWED && ext_w > TORCH_SKIP_EPS) {
+            occ = torch_entity_exterior_shadow(fixture, P, N);
+        }
+        sum += wow_light.points[2u * idx + 1u].rgb * (ext_w * occ);
+    }
+    return sum;
+}
+
+fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
+    return point_light_eval(point_light_pick(anchor, 0.0), P, N);
+}
+
+// MONKEY (dynamic interiors): the per-FRAGMENT room light — MIRRORED from `static_gx.wgsl`
+// (`interior_room_light`; keep in sync). MONKEY (light lanes / interior attenuation): the loop is
+// over the INTERIOR half of the table only (colour row `.w > 0.5`), and that same `.w` is each
+// fixture's REACH in yards — its authored MOLT attenuation end (M2 sources bucket by intensity),
+// scaled live by `interiorAttenScale`; it bounds the loop, shapes the fill and drives the direct
+// window. `interiorAttenScale 0` packs the legacy 48 yd — under the soft profile below that is the
+// widest, flattest pool the lane can make, the nearest thing left to the pre-window flat lane (no
+// longer the byte-exact restore it was, because the window's SHAPE moved with it).
+// Every in-range light of the room-gated table, no
+// nearest-K selection at all: DIRECT (falloff × wrapped Lambert, so a floor-level hearth still lights
+// the floor) + FILL (normal-free, half-desaturated bounce) + the base ambient. The knobs are the
+// live cvars packed into `point_count.yzw` (`.y` ambient, `.z` fill gain, `.w` exposure — the
+// caller's multiplier before the rolloff). Here it lights INDOOR units and GameObjects (gated on the
+// camera-independent probe slot) so they match the fixture-lit room around them instead of the
+// day/night CGLight, and takes the SAME per-fixture torch shadows (Phase 3A: the shared depth
+// array through this material's own group-2 bindings) as the surfaces.
+const INTERIOR_WRAP: f32 = 0.5;
+
+// MONKEY (bake floor): the ENTITY half of `static_gx.wgsl`'s interior bake floor. Keep
+// `BAKE_LANE_SCALE` byte-identical with that file and with
+// `benilla_world::lighting::BAKE_LANE_SCALE`: the value rides the FRACTION of `sh_c16.w` (whose
+// integer part is the world-shadow flag), with `interiorGain` already folded in by the packer.
+const BAKE_LANE_SCALE: f32 = 0.49;
+// The surfaces get `vc.rgb * k` — each batch's OWN authored MOCV. An entity has no MOCV: it is an
+// M2 standing in the room, not a piece of the room's mesh, and nothing on this lane knows which
+// WMO group it is in (the entity call passes `room_inst`/`room_group` as 0 — the ungated stub —
+// and the claim binding is `static_gx`-only, group 3). Computing a per-group mean MOCV luminance
+// at spawn and threading it onto the entity's record would be the better answer, but there is no
+// entity->group record on this path to put it in; inventing one is a spawn-side plumbing change of
+// its own. So the entity lane uses a FLAT MEAN — deliberately, and this is the note that says so.
+//
+// 0.45 is MEASURED, not guessed: over the Lion's Pride Inn's 70 INT+TRANS batches
+// (`benilla-extract wmolights`), the per-batch mean MOCV luminances run 0.183 (the cellar `g10`)
+// to 0.692 (the hearth floor under L9), median 0.433, quartiles 0.310/0.522 — and the
+// TRIANGLE-WEIGHTED mean, i.e. what an entity is actually likely to be standing among, is
+// **0.451**. So an entity is lifted by about what the floor under it is, which is the whole
+// requirement: a chair in the inn’s fixture-starved vestibule must not be a black cut-out against
+// the wall behind it. At the owner’s cvars and `interiorBakeFloor 0.12` that chair renders
+// 0.083 x its texture where the wall beside it renders 0.108 — near enough that it reads as part
+// of the room, which is all a flat mean can promise.
+//
+// ZERO on the exterior lane by construction — this term is only reachable inside the
+// `is_interior || matte_indoor` branch below, which is also gated on `wmo_fog_params.w > 0.5`.
+const INTERIOR_BAKE_ENTITY_MEAN: f32 = 0.45;
+// MONKEY (soft falloff): the interior pool's PROFILE — **keep this whole block byte-identical
+// between wow_model.wgsl and static_gx.wgsl.**
+//
+// The colour row's `.w` packs each fixture's EFFECTIVE RADIUS `R`: its authored MOLT
+// `attenuation_end` (an M2 source buckets by intensity instead) already multiplied by the live
+// `interiorAttenScale` (default 1.6). MONKEY (pool energy): the EXTENT terms — the direct window
+// and the fill span — are still written as fractions of `R`, so the cvar stays a pure zoom on how
+// far every pool REACHES; the core is not, so it is no longer also a brightness dial.
+//
+// The RETIRED profile was the reference's `1/(0.7d + 0.03d²)` windowed by
+// `1 − smoothstep(0.65R, R, d)` at `R` = the authored reach. That window closed a still-BRIGHT
+// curve — 0.28 of its 1 yd value at 0.65R — over the last 35 % of the radius, i.e. a bright disc
+// with a visible rim and black beyond it. That is the abbey candelabra ring. Three changes replace
+// it, and the ring cannot come back because the curve is already dim wherever the window bites:
+//  · CORE — `1/(1 + (d/r0)²)`: inverse square with a soft core. MONKEY (pool energy): `r0` is a
+//    CONSTANT `INTERIOR_CORE_YD` **yards**, not a fraction of `R` any more. It was `0.26·R`, and
+//    that tied a fixture's BRIGHTNESS to its REACH — the pool's total ENERGY grew as `R²`. The
+//    Goldshire inn's `R ≈ 11-15` fixtures therefore ran a 2.1× (at 3 yd) to 2.9× (at 5 yd) hotter
+//    curve than Northshire abbey's `R ≈ 7`; ten of them overlap in one room, the
+//    `1 − exp(−x·exposure)` rolloff saturated, and the inn read as one flat yellow while the
+//    abbey — whose pools the owner signed off — sat exactly where it should. Reach must BOUND a
+//    pool, not fuel it. So the energy is now one curve for every fixture and only the WINDOW and
+//    the fill span still scale with `R`: two fixtures of different reach read IDENTICALLY until
+//    the shorter one's window closes. `1.75 yd` is what the abbey already had (`0.26 × 6.7` — its
+//    median authored end 4.2 at the default `interiorAttenScale` 1.6), so the under-candle level
+//    the exposure was tuned against is preserved to within ±10 % across the abbey's own reach
+//    spread (−5 % at its median fixture) and nothing about the approved look moves.
+//  · GAIN — `INTERIOR_CORE_GAIN` normalises the core against the retired hyperbolic's 1 yd value,
+//    `1/(0.7 + 0.03) = 1.3699`. With a CONSTANT `r0` that normalisation is the same for every
+//    fixture instead of holding only at the median reach, which is the whole point; it lands at
+//    `1.5/(1 + (1/1.75)²) = 1.1308`, i.e. 0.83 × the hyperbolic — the abbey's own current level.
+//    (Gain 1.817 would restore 1.3699 exactly; that is a 21 % brighter room than the approved
+//    one, so it is deliberately NOT taken. Change the GAIN, never the core radius, to re-level.)
+//  · WINDOW — `(clamp01(1 − (d/R)^p))²`, the UE4-style windowing: value AND derivative both vanish
+//    at `d = R` (C1, so no rim), ≈1 over most of the radius, and it only ever removes energy the
+//    curve has already lost.
+// MONKEY (pool energy): the direct term (before the wrapped Lambert) at d = 1 / 3 / 5 / 8 / 12 yd,
+// abbey-class `R = 7` beside inn-class `R = 13` —
+//   was   R=7  1.152 / 0.403 / 0.164 / 0     / 0       R=13  1.379 / 0.839 / 0.470 / 0.224 / 0.033
+//   now   R=7  1.131 / 0.381 / 0.153 / 0     / 0       R=13  1.131 / 0.381 / 0.164 / 0.067 / 0.009
+// The two "now" rows are the SAME curve until R=7's window bites (where it is already down to
+// 0.15); R=13 only keeps a longer, dimmer TAIL, because its window is wider. That is the fix.
+//
+// FILL keeps its EXACT form (`(1 − d/r)²`, which is `interior_window(d, r, 1.0)`) and only widens:
+// its radius is `INTERIOR_FILL_SPAN·R`, so the floor BETWEEN two pools takes a gentle wash instead
+// of the bare ambient floor. Its value at the fixture is still 1, so `interiorFill` keeps the
+// meaning it was tuned with.
+const INTERIOR_CORE_YD: f32 = 1.75;
+const INTERIOR_CORE_GAIN: f32 = 1.5;
+const INTERIOR_DIRECT_POW: f32 = 10.0;
+const INTERIOR_FILL_SPAN: f32 = 1.5;
+const INTERIOR_FILL_POW: f32 = 1.0;
+// `(clamp01(1 − (d/r)^p))²`. The inner clamp keeps `pow` off a negative base; `max(r, …)` keeps it
+// off a zero divisor (the packer floors R at 1.0, but a shader must not lean on a producer's
+// invariant). `clamp(…, 0, 1)` rather than `saturate` — nothing else in this shader set uses
+// `saturate`, and the two are the same instruction.
+fn interior_window(d: f32, r: f32, p: f32) -> f32 {
+    let w = clamp(1.0 - pow(clamp(d / max(r, 1e-4), 0.0, 1.0), p), 0.0, 1.0);
+    return w * w;
+}
+// MONKEY (room gate): the ENTITY/prop copy has no claim-table binding and no per-fragment room
+// key (`static_gx.wgsl` owns both — the claim table hangs off its own group 2), so every fixture is
+// admitted here, exactly as before this change. Follow-up: an entity already knows the room it
+// STANDS in (the interior classifier's down-ray, `carried_light`'s `WmoGroupVis::single`), so the
+// same gate could ride a per-instance key pushed through the model material.
+fn interior_room_admits(i: u32, room_inst: u32, room_group: u32) -> bool {
+    return true;
+}
+fn interior_room_light(P: vec3<f32>, N: vec3<f32>, room_inst: u32, room_group: u32) -> vec3<f32> {
+    let count = u32(wow_light.point_count.x);
+    let k_fill = wow_light.point_count.z;
+    var direct = vec3<f32>(0.0);
+    var fill = vec3<f32>(0.0);
+    for (var i = 0u; i < count; i = i + 1u) {
+        let color_lane = wow_light.points[2u * i + 1u];
+        // MONKEY (light lanes): only a fixture that CLAIMS a room lights this room (keep in sync
+        // with static_gx.wgsl). `.w` is 0 on every exterior source, so a campfire burning outside
+        // the door stops reaching the floor inside it.
+        if (color_lane.w < 0.5) {
+            continue;
+        }
+        // MONKEY (room gate): and only a fixture that claims THIS ROOM lights this room's surfaces.
+        // Before this, the whole INT half of the table lit every interior fragment of every
+        // building in range and the only occlusion was the <=6 promoted cube-shadow casters — so an
+        // inn's ground-floor candles lit its basement THROUGH the floor, and an upstairs corridor
+        // wall glowed from the fixture in the room behind it. Tested here, before the distance
+        // test, because it is the term that throws away the most: a room claims one or two of the
+        // table's fixtures, not all of them.
+        if (!interior_room_admits(i, room_inst, room_group)) {
+            continue;
+        }
+        // MONKEY (soft falloff): `.w` is ALSO this fixture's EFFECTIVE RADIUS `R` in yards — the
+        // authored MOLT `attenuation_end` (or the M2 intensity bucket) already multiplied by the
+        // live `interiorAttenScale` at pack time. It replaces the flat 48 yd candidacy radius in
+        // `pos_range.w` on this lane, which is why a 10-candle inn read as one uniform wash.
+        let reach_yd = color_lane.w;
+        // Candidacy is the FILL radius, not R: the wash reaches further than the direct pool (see
+        // the profile block), and rejecting at R would cut it off exactly at the pool's own edge —
+        // putting the rim back one term down.
+        let fill_yd = INTERIOR_FILL_SPAN * reach_yd;
+        let pos_range = wow_light.points[2u * i];
+        let to_light = pos_range.xyz - P;
+        let d2 = dot(to_light, to_light);
+        if (d2 > fill_yd * fill_yd) {
+            continue;
+        }
+        let d = sqrt(d2);
+        let c = color_lane.rgb;
+        // Normalised for BOTH terms (keep in sync with static_gx.wgsl): the table commits RAW
+        // over-gamut colour × intensity; a hot forge would wash the direct term to white.
+        let c_norm = c / max(1.0, max(c.r, max(c.g, c.b)));
+        // MONKEY (soft falloff): inverse square with the authored-start soft core, normalised so
+        // the 1 yd value is the retired hyperbolic's (profile block above).
+        // MONKEY (pool energy): a CONSTANT core radius in yards (profile block above) — the reach
+        // no longer scales the pool's brightness, only its window. `max` keeps the divide honest
+        // if the constant is ever tuned toward 0.
+        let r0 = max(INTERIOR_CORE_YD, 1e-3);
+        let atten = INTERIOR_CORE_GAIN / (1.0 + (d / r0) * (d / r0));
+        let window = interior_window(d, reach_yd, INTERIOR_DIRECT_POW);
+        let nl = max(
+            (dot(N, to_light / max(d, 1e-4)) + INTERIOR_WRAP) / (1.0 + INTERIOR_WRAP),
+            0.0,
+        );
+        // Phase 3A per-fixture cast shadow (keep in sync with static_gx.wgsl's
+        // `torch_surface_shadow` call): this fixture's OWN cube map, sampled through the
+        // material's group-2 torch bindings — a pillar between an NPC and torch A darkens A's
+        // term without touching torch B's, exactly as on the surfaces around it.
+        // MONKEY (torch lane perf, MIRRORED from static_gx.wgsl): skip the table scan and its four
+        // comparison taps where the direct term this occlusion multiplies is already nothing —
+        // past the fixture's reach (`window` is exactly 0 there) or on a surface facing away from
+        // it. An entity and the floor under it must agree about the shadow they show, so the
+        // threshold and the shape of the guard are the same on both sides.
+        let direct_w = atten * nl * window;
+        var s = 1.0;
+        if (direct_w > TORCH_SKIP_EPS) {
+            s = torch_entity_shadow(pos_range.xyz, P, N);
+        }
+        direct += c_norm * direct_w * s;
+        // MONKEY (soft falloff): the fill's profile is UNCHANGED in FORM — `(1 − d/r)²`, which is
+        // exactly `interior_window(d, r, 1.0)` — and only its radius moved, from R to
+        // `INTERIOR_FILL_SPAN·R`. That is the whole "gentle wash between the pools": at the fixture
+        // it is still 1 (so `interiorFill` keeps its tuned meaning) and it decays to 0 at 2R with a
+        // vanishing derivative, so the floor half-way between two candles is dim, not black.
+        let c_fill = mix(c_norm, vec3<f32>(dot(c_norm, vec3<f32>(0.299, 0.587, 0.114))), 0.5);
+        // DOMINANT fixture, not the sum (keep in sync with static_gx.wgsl): fill must not scale
+        // with candle count or a dense room saturates flat. Fill is indirect, so not shadowed.
+        fill = max(fill, c_fill * (k_fill * interior_window(d, fill_yd, INTERIOR_FILL_POW)));
+    }
+    return direct + fill + vec3<f32>(wow_light.point_count.y);
+}
+
 // The MCNK chunk cell center under a world point — the light-selection anchor for geometry merged in
 // WORLD space (clutter; terrain.wgsl mirrors this): the reference draws terrain per 33.33-yd MCNK
 // chunk and gathers that unit's lights like any other. Grid constants per the ADT format (chunk =
@@ -331,6 +919,92 @@ fn mcnk_cell_anchor(P: vec3<f32>) -> vec3<f32> {
     return vec3<f32>((ix + 0.5) * cell - half, P.y, (iz + 0.5) * cell - half);
 }
 
+// MONKEY (ext light k12): the MCNK cell's HORIZONTAL half-extent (yd) - the `box` a cell-anchored
+// draw unit ranks by. The same grid constant as above, halved: 533.33333/16/2 = 16.666666. An
+// own-origin unit passes 0 instead. MIRRORED in terrain.wgsl - keep in sync.
+const MCNK_CELL_HALF: f32 = 533.33333 / 32.0;
+
+// MONKEY (wmo exterior points): the EXTERIOR-lane point term for a WMO's OUTDOOR-class surfaces —
+// MIRRORED VERBATIM from `static_gx.wgsl` (`wmo_exterior_point_sum`; that file owns the full
+// rationale — keep the two bodies identical). This copy exists because the retained WMO collector
+// declines a small minority of batches (env-mapped, depth-flag oddities) and they fall through to
+// this entity pipeline: a Trade District street lit on one pipeline and black on the other is
+// worse than either. It reuses this file's OWN `mcnk_cell_anchor` (identical constants to
+// static_gx's private copy) — a WMO batch's anchor is its PLACEMENT origin, one point for the whole
+// of Stormwind, so ranking from it would commit the same three lights to every street in the city;
+// the 33.33 yd MCNK cell is the unit terrain ranks by, so a street and the road it runs into rank
+// the SAME candidates and agree at the seam. Candidacy is terrain's Chebyshev box, not this file's
+// 48 yd sphere, for that same agreement reason.
+const WMO_EXT_REACH: f32 = 33.570166;
+// MONKEY (outdoor torch shadows): the ranking half, split out for the same reason as
+// `point_light_pick` — the fragment stage re-evaluates the VERTEX's choice, never its own.
+fn wmo_exterior_pick(P: vec3<f32>) -> vec4<u32> {
+    let anchor = mcnk_cell_anchor(P);
+    let count = u32(wow_light.point_count.x);
+    var sel = array<u32, EXT_SEL_K>();
+    var sd = array<f32, EXT_SEL_K>();
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        sd[s] = 1e30;
+    }
+    for (var i = 0u; i < count; i = i + 1u) {
+        // Exterior lane only: an interior fixture's `.w` is its reach (≥ 1), an exterior source's
+        // is 0. A building's own candles must not pool on the street outside its wall.
+        if (wow_light.points[2u * i + 1u].w > 0.5) {
+            continue;
+        }
+        let dv = wow_light.points[2u * i].xyz - anchor;
+        // Terrain's hash sweep is horizontal and unbounded vertically; the ranking below is the
+        // full 3-D distance, as `0x71bf90` does.
+        if (max(abs(dv.x), abs(dv.z)) > WMO_EXT_REACH) {
+            continue;
+        }
+        // MONKEY (ext light k12): rank by the distance to the MCNK cell's BOX, not to its centre -
+        // see `point_light_pick`. This is the term that makes a street and the road it runs into
+        // agree about a torch standing on the seam between them.
+        let e = max(abs(dv.xz) - vec2<f32>(MCNK_CELL_HALF), vec2<f32>(0.0));
+        let d2 = dot(e, e) + dv.y * dv.y;
+        // MONKEY (ext light k12): an `EXT_SEL_K`-deep insertion in place of the hand-unrolled
+        // 3-deep cascade. Both loops are bounded by a module const, so the compiler unrolls them;
+        // the comparison is strictly-less, which keeps the old tie order (first-found wins).
+        //
+        // The guard on the WORST kept rank first: `sd` is sorted, so a candidate that cannot beat
+        // `sd[K-1]` cannot beat anything, and the scan below would walk all eight slots only to
+        // decide that. It makes the REJECT path - which is what nearly every table entry takes once
+        // the set is full - ONE comparison, i.e. cheaper than the three the old cascade spent, so
+        // widening K did not make the common case more expensive. Exactly equivalent to letting the
+        // scan run: `d2 >= sd[K-1]` is precisely the condition under which it returns `r = K`.
+        if (d2 >= sd[EXT_SEL_K - 1u]) {
+            continue;
+        }
+        var r = EXT_SEL_K;
+        for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+            if (d2 < sd[s]) {
+                r = s;
+                break;
+            }
+        }
+        if (r < EXT_SEL_K) {
+            for (var s = EXT_SEL_K - 1u; s > r; s = s - 1u) {
+                sd[s] = sd[s - 1u];
+                sel[s] = sel[s - 1u];
+            }
+            sd[r] = d2;
+            sel[r] = i;
+        }
+    }
+    // Pack low-byte-first, `EXT_SEL_EMPTY` for a rank nothing reached. No real index can collide
+    // with the sentinel: the live table caps at 255 (`MAX_LIVE_POINT_LIGHTS`).
+    var packed = vec4<u32>(0u, 0u, 0u, 0u);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = select(EXT_SEL_EMPTY, sel[s], sd[s] <= 9.9e29);
+        packed[s >> 2u] |= idx << (8u * (s & 3u));
+    }
+    return packed;
+}
+fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    return point_light_eval(wmo_exterior_pick(P), P, N);
+}
+
 // The vertex input — bevy 0.18's `forward_io::Vertex` fields at bevy's shader locations (the
 // VERTEX_* defs come from the base mesh-pipeline specialize, driven by what the mesh authors;
 // tangents / morphs never — no model mesh has them), PLUS the owned-palette joint attributes at
@@ -594,21 +1268,44 @@ fn vertex(vertex: WowVertex) -> WowVsOut {
 #endif
 
     // Dynamic point lights, by receiver class (wow-re trace-forensics-abbey-interior-d3d §2/§4):
-    // WMO surfaces take NONE (zero point lights on every observed WMO surface batch — the earlier
-    // "point-lit abbey wall" was a mis-identified unit draw), and interior M2 props take none HERE
-    // (their group-MOLR point lobes are folded into the per-instance SH probe). Everything else —
-    // exterior doodads, entities, clutter — keeps the FFP ≤3-nearest selection: clutter (merged in
+    // INTERIOR WMO surfaces take NONE (zero point lights on every observed WMO surface batch —
+    // the earlier "point-lit abbey wall" was a mis-identified unit draw; they light per FRAGMENT
+    // instead, `interior_room_light`), and interior M2 props take none HERE (their group-MOLR
+    // point lobes are folded into the per-instance SH probe). Everything else —
+    // exterior doodads, entities, clutter — keeps the nearest-`EXT_SEL_K` selection: clutter (merged in
     // world space) anchors at its MCNK chunk cell (the terrain draw unit it belongs to), every M2
     // at its INSTANCE origin (wow-re wmo-surface-dynamic-light §6 — the receiving unit's own
     // position, deliberately not the skinned per-vertex matrix).
-    if (m.model_flags.x > 0.5 || m.model_flags.z > 0.5) {
+    if (m.model_flags.x > 0.5 && m.model_flags.z < 0.5) {
+        // MONKEY (wmo exterior points): an EXTERIOR-class WMO group (`model_flags.z` clear = MOGP
+        // `& 0x48` set) is a street, a courtyard, a porch — drawn by the exterior law, the same law
+        // the terrain beside it is drawn by, so it takes the exterior point term terrain takes. The
+        // §2 "zero on every WMO surface" finding was measured on abbey INTERIOR rooms and reading
+        // it as a blanket zero is what left Stormwind's Trade District torches lighting nothing but
+        // the NPC beside them. Mirrors `static_gx.wgsl`'s branch (which draws the vast majority of
+        // these batches) — keep the two in step.
+        // MONKEY (outdoor torch shadows): the pick is PUBLISHED so the fragment stage can shadow
+        // this same selection at night without re-ranking. One table walk still, not two -
+        // the sum was always `eval(pick(..))`, it is just no longer inlined.
+        let sel = wmo_exterior_pick(out.world_position.xyz);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, out.world_position.xyz, out.world_normal);
+    } else if (m.model_flags.x > 0.5 || m.model_flags.z > 0.5) {
         out.point_lit = vec3<f32>(0.0);
+        out.ext_sel = EXT_SEL_NONE;
     } else {
         var anchor = mesh_world_from_local[3].xyz;
+        // MONKEY (ext light k12): CLUTTER is merged in world space and anchors at its MCNK cell, so
+        // it ranks by that cell's BOX like the terrain under it; a standalone M2 keeps its own
+        // origin, i.e. `box = 0` — the old point ranking, unchanged.
+        var box = 0.0;
         if (m.clutter_fade.w > 0.5) {
             anchor = mcnk_cell_anchor(out.world_position.xyz);
+            box = MCNK_CELL_HALF;
         }
-        out.point_lit = point_light_sum(out.world_position.xyz, out.world_normal, anchor);
+        let sel = point_light_pick(anchor, box);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, out.world_position.xyz, out.world_normal);
     }
     return out;
 }
@@ -1100,6 +1797,62 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // through `point_diffuse` below like any exterior entity.
     let is_rig = m.sun_scale.x >= 1.5;
     let lit = select(select(lit_exterior, lit_interior, is_interior), lit_m2_interior, is_rig);
+    // MONKEY (shadow hook): the realtime shadow (fetch + edge/night fade) is computed by
+    // `benilla::shadow_hook`. This lane keeps only the rig-skin SAMPLE-POINT choice + the
+    // interior/rig exclusion + ambient-preserving apply below.
+    var player_shadow = 1.0;
+    let view_z = (view.view_from_world * in.world_position).z;
+    let shadow_cam_dist = distance(in.world_position.xyz, view.world_position.xyz);
+#ifdef WOW_RIG_SKIN
+    // A skinned UNIT samples the map ONCE at its rig origin (between the feet), nudged 2.5 units
+    // TOWARD the sun, and dims uniformly — the reference's per-unit response. Per-fragment sampling
+    // is wrong here: the caster proxy holds a CPU-skinned copy of this very body, so a body fragment
+    // reads its own limbs/weapon as occluders (self-shadow speckle). Gated on the directional-enable
+    // flag so an interior-lit unit never takes an exterior dim (player_shadow stays 1.0).
+    if (wow_light.light_sun.w > 0.5) {
+        let sun_ray = normalize(wow_light.light_sun.xyz);
+        let anchor = vec4<f32>(
+            wow_light.rig_origin[(fade_tag >> 19u) & 0x7ffu].xyz - 2.5 * sun_ray,
+            1.0,
+        );
+        player_shadow = shadow_hook::realtime_shadow(
+            anchor,
+            vec3<f32>(0.0, 1.0, 0.0),
+            view_z,
+            shadow_cam_dist,
+            wow_light.wmo_fog_params.z,
+            wow_light.fog_params.z,
+        );
+    }
+#else
+    player_shadow = shadow_hook::realtime_shadow(
+        in.world_position,
+        wow_normalize(in.world_normal),
+        view_z,
+        shadow_cam_dist,
+        wow_light.wmo_fog_params.z,
+        wow_light.fog_params.z,
+    );
+#endif
+    // The realtime map blocks only the directional sun. Preserve the authored ambient/probe
+    // contribution instead of multiplying the whole lighting result; the latter makes interiors,
+    // point-lit props, and shadow-side characters globally too dark.
+    //
+    // `is_rig` (the glue create-booth lane) is excluded DELIBERATELY: a booth scene's light is
+    // entirely its authored rig — there is no world sun to block. World units are `ShadeSel::Lit`
+    // and receive through the WOW_RIG_SKIN ground sample above. The `player_shadow < 0.999`
+    // arm keeps `worldShadows 0` (and a fully sunlit fragment) byte-identical: `ambient +
+    // (lit − ambient) × 1.0` is not guaranteed to round back to `lit`.
+    let shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, player_shadow);
+    let lit_with_shadow = select(
+        lit,
+        clamp(
+            wow_light.light_ambient.rgb + (lit - wow_light.light_ambient.rgb) * shadow_term,
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        ),
+        !is_interior && !is_rig && player_shadow < 0.999,
+    );
     // Gamma-space albedo — the lane (0161): the buffer holds bytes, lighting math runs on the
     // authored values. (The old fog_params.z linear-space A/B is dead — settled by the lane.)
     // `m.tint` is the animated M2Color RGB (identity 1 for static batches) — the same per-batch
@@ -1125,13 +1878,39 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     }
     let sidn_e = m.sidn.rgb * (wow_light.grade.x * sidn_w);
     // WoW dynamic point lights (decisions 0016/0273/0278, selection 0285) — exterior doodads,
-    // entities, clutter, and terrain receive their unit's committed lights: the ≤3 NEAREST to the
-    // receiving unit's own position, never the whole scene (`point_light_sum`). WMO surfaces take
-    // ZERO (observed on every WMO surface batch in the abbey capture) and interior props fold their
-    // group-MOLR lobes into the SH probe instead — both zeroed in the VERTEX stage. The term
+    // entities, clutter, and terrain receive their unit's committed lights: the ≤`EXT_SEL_K` NEAREST to the
+    // receiving unit's own position or AABB, never the whole scene (`point_light_sum`). INTERIOR WMO
+    // surfaces take ZERO (observed on every WMO surface batch in the abbey capture — an interior
+    // capture, hence the MONKEY split above) and interior props fold their group-MOLR lobes into
+    // the SH probe instead — both zeroed in the VERTEX stage; an EXTERIOR-class WMO group takes
+    // the exterior-lane term (`wmo_exterior_point_sum`) there instead, ranked from its MCNK cell
+    // like the terrain it adjoins, which is what puts a street torch on the cobbles. The term
     // arrives GOURAUD-INTERPOLATED — per-vertex like the reference FFP, whose tessellation-scale
     // smoothing is the authored look. Diffuse-only (committed ambient/specular are zero).
-    let point_diffuse = in.point_lit;
+    // MONKEY (outdoor torch shadows): ...and after dark that Gouraud term is CAST-SHADOWED.
+    //
+    // The same entries the vertex stage picked (`in.ext_sel`) are re-evaluated PER FRAGMENT
+    // with each fixture's own cube-map occlusion folded in, and the two results are blended by
+    // `night_w = 1 - sun_shadow_strength`. Written as a blend rather than a swap for two reasons:
+    //   - `fog_params.z` is EXACTLY 1.0 whenever the sun is above the daylight threshold
+    //     (`global_light::sun_shadow_strength` is a smoothstep that saturates), so `night_w` is
+    //     exactly 0 and the branch is not entered - DAYLIGHT IS THE SAME BITS, not "a mix that
+    //     ought to round back to b".
+    //   - at dusk the shadow, and the Gouraud->per-fragment change of the term itself, arrive on
+    //     the same clock the sun shadows leave on instead of snapping at some threshold.
+    // `torch_ext_on()` is the CPU's one-bit verdict (`exteriorShadows` AND night AND at least one
+    // promoted exterior fixture), so with the cvar off this is dead too. `n_lit` is the same
+    // normal every other lit term here uses, so the normal-offset sample leaves the skin the way
+    // the interior entity lane's does.
+    var point_diffuse = in.point_lit;
+    let ext_night_w = select(0.0, clamp(1.0 - wow_light.fog_params.z, 0.0, 1.0), torch_ext_on());
+    if (ext_night_w > 0.0) {
+        point_diffuse = mix(
+            in.point_lit,
+            point_light_eval_shadowed(in.ext_sel, in.world_position.xyz, n_lit),
+            ext_night_w,
+        );
+    }
 
     // Hover/target model brighten (tag bit 31): the client's per-model highlight emissive —
     // `glMaterialfv(GL_EMISSION, +64/255)` per channel (shipped config default 0xff404040), verified
@@ -1156,7 +1935,7 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
         // MOCV multiplies the lit terms (GL_COLOR_MATERIAL) but NOT the emission terms — SIDN and
         // the highlight add alongside, exactly the FFP's material-emission placement.
         let primary = clamp(
-            vc * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+            vc * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -1186,7 +1965,7 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
         // writes a colour. (Left off the `is_wmo` branch on purpose: a WMO surface is not a CM2
         // instance and has no tint slot of its own.)
         let primary = clamp(
-            inst_tint * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+            inst_tint * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -1196,12 +1975,80 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // (`sidn_e` is zero for every M2 batch; a WMO batch without MOCV lands here too and keeps it —
     // harmlessly, since a WMO instance's tint slot is the identity slot 0.)
     let primary = clamp(
-        inst_tint * (lit + point_diffuse) + sidn_e + vec3<f32>(highlight),
+        inst_tint * (lit_with_shadow + point_diffuse) + sidn_e + vec3<f32>(highlight),
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
     lit_rgb = albedo * primary;
 #endif
+    // MONKEY (dynamic interiors, `interiorLight` on): an INDOOR unit / GameObject / WMO prop — the
+    // entity's OWN light-node classification (tag bit 30, `interior_fogged`), never a WMO surface,
+    // never the create booth's authored rig — takes the fixture-lit room light
+    // (`interior_room_light`, mirrored from `static_gx.wgsl`) instead of the day/night CGLight or
+    // the baked probe, so it matches the surfaces around it (the tavern's chairs and NPCs stayed
+    // bake-bright in a torch-lit room). The instance tint still modulates; the same soft rolloff
+    // as the surfaces; and (Phase 3A) the same per-fixture torch shadows, from the shared map.
+    // CAMERA-INDEPENDENT indoor test: `is_interior` (`model_flags.z`) — the SAME signal the WMO
+    // surface lane and the original interior-prop lane trust to route an entity to interior lighting,
+    // set from the anchor's down-ray classification, not the camera. (The earlier gates were both
+    // wrong: `interior_fogged` is the MFOG bit the camera rewrites every frame — an indoor unit went
+    // dark when the camera left; `probe != 0` is non-zero for EVERY entity, indoor or out, since an
+    // exterior entity also carries a day/night SH probe slot — so every outdoor GO/unit lit as
+    // interior, the debug-1 green everywhere.)
+    // PLUS the classifier's MATTE law (tag bit 14, `mesh_tag::MATTE_INDOOR_BIT`): the anchor
+    // stands indoors but its material stayed in exterior mode (no bake to fold) — the same room,
+    // the same lane. Without it a moving unit whose verdict flickers Bake↔Matte at one spot
+    // (the down-ray marginally hitting the baked floor) switched its lane off and on. Read only
+    // in exterior material mode: in interior mode those bits are the probe slot.
+    let matte_indoor = !is_interior && (fade_tag & 0x4000u) != 0u;
+    if ((is_interior || matte_indoor) && !is_wmo && !is_rig && wow_light.wmo_fog_params.w > 0.5) {
+        let room = interior_room_light(in.world_position.xyz, n_lit, 0u, 0u);
+        // MONKEY (indoor highlight): the hover/target emissive (`highlight`, tag bit 31) rides THIS
+        // lane's light sum too. It is the same GL_EMISSION placement as the exterior branches above
+        // — added to the material's ambient+diffuse product INSIDE the [0,1] saturate, with the
+        // texture (`albedo`) modulating the clamped result — so an indoor chair lifts by exactly the
+        // +64/255 an outdoor one does. It has to be folded HERE, not left in `lit_rgb`, because this
+        // lane REPLACES the exterior result a few lines down (`mix(lit_rgb, room_rgb, lane_w)`):
+        // with `lane_w` at 1 (a settled indoor unit) the exterior sum that carried the lift was
+        // discarded wholesale, which is why hovering a chair inside a Stormwind house brightened
+        // nothing at all while the same chair on the street did.
+        // The clamp is a no-op when nothing is hovered (`highlight` 0, and both factors are already
+        // ≤1), so the un-hovered indoor look is bit-identical to before.
+        // Placed BEFORE the debug branch on purpose: modes 1/2/3 all discard `room_rgb` and return
+        // their own diagnostic colour, so `interiorDebug` is untouched by this.
+        // MONKEY (bake floor): the room's own bake floor, so an entity in a fixture-starved room is
+        // not a black silhouette against a dimly lit wall. A flat room mean rather than the
+        // surfaces' per-batch `vc.rgb` — see `INTERIOR_BAKE_ENTITY_MEAN` for why the per-group
+        // number is not reachable on this lane. Inside the same rolloff as the surfaces, so a
+        // torch-lit NPC is moved by single-digit percent and an unlit one is carried.
+        let bake = INTERIOR_BAKE_ENTITY_MEAN * (fract(wow_light.sh_c16.w) / BAKE_LANE_SCALE);
+        var room_rgb = albedo * clamp(
+            inst_tint * (vec3<f32>(1.0) - exp(-(room + vec3<f32>(bake)) * wow_light.point_count.w))
+                + vec3<f32>(highlight),
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        );
+        let idbg = u32(max(wow_light.wmo_fog_params.w - 1.0, 0.0) + 0.5);
+        if (idbg == 2u) {
+            // The entity's OWN cube-map sampling as greyscale (the shared stub would show white).
+            room_rgb = vec3<f32>(torch_entity_debug_factor(in.world_position.xyz, n_lit));
+        } else {
+            room_rgb = shadow_hook::interior_debug_override(idbg, room_rgb, in.world_position, n_lit);
+        }
+        // MONKEY (portal lane fade): CROSSFADE, not a switch. `lit_rgb` still holds this part's
+        // EXTERIOR result (day/night × its ground-shade byte) — the "outside" colour — and the
+        // classifier ramps tag bits 15..=18 from 0 to 15 over ~half a second as the entity's
+        // anchor crosses the portal, so the two lanes blend the way the surfaces at the seam
+        // already do. Without it a character stepping through a doorway went from night-dark to
+        // torch-warm in ONE frame while the wall beside it faded.
+        //
+        // Forced to 1.0 in INTERIOR material mode: there those bits are the middle of the SH probe
+        // slot (`mesh_tag`'s two payload modes), so reading them as a weight would fade an indoor
+        // baked unit by its probe INDEX. The classifier only ever commits the interior material at
+        // full weight anyway — every frame of an actual blend is written in exterior mode.
+        let lane_w = select(f32((fade_tag >> 15u) & 0xfu) / 15.0, 1.0, is_interior);
+        lit_rgb = mix(lit_rgb, room_rgb, lane_w);
+    }
     // The fullbright/UNLIT path takes the tint too, unlike the highlight: with GL_LIGHTING off the
     // same gx state (SetState(1)) is a plain `glColor` modulate on the texture, while GL_EMISSION is
     // dead. So a ghost's glow cards tint with its body.
diff --git a/crates/benilla-assets/src/world_assets/mod.rs b/crates/benilla-assets/src/world_assets/mod.rs
index 4416ffcd..94bd6a98 100644
--- a/crates/benilla-assets/src/world_assets/mod.rs
+++ b/crates/benilla-assets/src/world_assets/mod.rs
@@ -24,7 +24,7 @@ use bevy::image::Image;
 use bevy::prelude::*;
 use bevy::render::render_resource::{Buffer, Face};
 
-use crate::materials::{WowModelExt, WowModelMaterial, VANILLA_ALPHA_KEY_REF};
+use crate::materials::{TorchBinds, WowModelExt, WowModelMaterial, VANILLA_ALPHA_KEY_REF};
 use crate::SpatialCache;
 use benilla_formats::{blp_to_rgba, read_texture_native_chain, tga_to_rgba, Chain, ModelBlend};
 
@@ -101,6 +101,10 @@ pub struct WorldAssets {
     /// can clone it into every deduped model material's `light_buf` without threading a `Buffer` through
     /// the many call sites. One buffer for the whole scene, updated in place each frame.
     pub shared_light: Buffer,
+    /// MONKEY (torch shadows Phase 3A): the shared torch depth image + torch table buffer, held
+    /// beside `shared_light` for the same reason — cloned into every deduped model material's
+    /// `torch_depth`/`torch_buf` without threading them through the call sites.
+    pub torch: TorchBinds,
 }
 
 /// Identity of a deduped model material: a textured material is uniquely determined by its texture
@@ -388,7 +392,10 @@ impl WorldAssets {
     /// sit under the renderer: the store's only use of it is `clone()` into every deduped model
     /// material's `light_buf`, so the parameter severs what would otherwise be a dependency on the
     /// lighting layout and, through it, the rig-palette regions (decision 1164).
-    pub fn open(chain: Chain, shared_light: Buffer) -> Self {
+    ///
+    /// `torch` (MONKEY, torch shadows Phase 3A) is the same shape of seam for the torch-shadow
+    /// receiver bindings: the raw image handle + table buffer, cloned into every model material.
+    pub fn open(chain: Chain, shared_light: Buffer, torch: TorchBinds) -> Self {
         Self {
             chain: Arc::new(Mutex::new(chain)),
             textures: SpatialCache::default(),
@@ -402,6 +409,7 @@ impl WorldAssets {
             loose_root: None,
             model_materials: SpatialCache::default(),
             shared_light,
+            torch,
         }
     }
 
@@ -754,6 +762,9 @@ impl WorldAssets {
                 anim_slots: Vec4::ZERO,
                 // The shared global light (light/fog/SH come from here, updated in place each frame).
                 light_buf: self.shared_light.clone(),
+                // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
+                torch_depth: self.torch.depth.clone(),
+                torch_buf: self.torch.table.clone(),
             },
         });
         self.model_materials.insert(key, handle.clone());
diff --git a/crates/benilla-formats/src/bin/benilla-extract/main.rs b/crates/benilla-formats/src/bin/benilla-extract/main.rs
index 537cf192..7a550899 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/main.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/main.rs
@@ -690,6 +690,15 @@ enum Command {
         /// models if omitted.
         prefix: Option<String>,
     },
+    /// MONKEY (fire GO lights): the twin of `m2lightscan` for the models that author NO light —
+    /// which ones would take a **synthesised** one from their flame particle emitter, and what
+    /// colour/intensity the heuristic derives (`benilla_formats::fire_light`). The offline audit
+    /// of a rule that is applied to ~430 fire props at load, none of which the reference lights.
+    M2firescan {
+        /// Internal-path prefix filter (e.g. `world\generic`), case-insensitive; all models if
+        /// omitted.
+        prefix: Option<String>,
+    },
     /// Sweep every WMO ROOT and cross-tab the two halves of the skybox mechanism: the root's
     /// **MOSB** skybox model against its groups' `0x40000` flag. `0x40000` is undocumented, so this
     /// is what *identifies* it — across all 815 roots the bit never appears without a MOSB. Note
@@ -795,6 +804,32 @@ enum Command {
         /// Case-insensitive substring of the prop's model path (e.g. `lightray`); all if omitted.
         filter: Option<String>,
     },
+    /// MONKEY (interior attenuation): dump one WMO root's **MOLT fixture table** — type,
+    /// `useAtten`, colour × intensity, the authored attenuation start/end (yd), model-space
+    /// position, and the groups whose MOLR names each fixture (its rooms). Closes with what our
+    /// fixed falloff `1/(0.7d + 0.03d²)` is still worth at each fixture's own authored end: the
+    /// number behind "why does a 20-candle room read uniform".
+    Wmolights {
+        /// Internal path to the WMO **root** (forward or back slashes accepted).
+        internal_path: String,
+        /// MONKEY (trans day law): also dump ONE group's per-VERTEX rows - position + the MOCV
+        /// alpha the shader interpolates as `trans_a` - plus every portal's vertex bounds. The
+        /// batch table above gives a batch's alpha RANGE and mean; a per-vertex blend law can only
+        /// be evaluated against the actual vertices, which is what this prints.
+        #[arg(long)]
+        verts: Option<usize>,
+    },
+    /// MONKEY (interior prop lights): sweep every WMO **root** and audit whether its rooms have
+    /// any light at all — MOLT omni fixtures, MODD props that would SYNTHESISE one (the
+    /// `fire_light` flame/lamp routes), how many of those the 2.5 yd MOLT dedupe drops, and how
+    /// many INTERIOR groups no source claims, before and after the prop lane is admitted indoors.
+    Wmolamps {
+        /// Only roots whose internal path starts with this (e.g. `world\wmo\azeroth`).
+        prefix: Option<String>,
+        /// Also name the still-unlit interior groups of every root whose path contains this.
+        #[arg(long)]
+        detail: Option<String>,
+    },
     /// Sweep every WMO **root** (optionally under a path prefix) and list the placed MODD props
     /// the INTERIOR lighting lane commits as **literal black**. That lane's entire base light is
     /// the MODD entry's own baked colour (ambient `cap96`, diffuse `floor112` — `0x694e90` →
@@ -1072,6 +1107,7 @@ fn main() -> Result<()> {
             scan::partscan(&mut chain, mask, prefix.as_deref())?;
         }
         Command::M2lightscan { prefix } => scan::m2lightscan(&mut chain, prefix.as_deref())?,
+        Command::M2firescan { prefix } => scan::m2firescan(&mut chain, prefix.as_deref())?,
         Command::Skyboxscan => scan::skyboxscan(&mut chain)?,
         Command::Lightbands {
             map,
@@ -1112,6 +1148,13 @@ fn main() -> Result<()> {
             internal_path,
             filter,
         } => scan::wmodoodads(&mut chain, &internal_path, filter.as_deref())?,
+        Command::Wmolights {
+            internal_path,
+            verts,
+        } => scan::wmolights(&mut chain, &internal_path, verts)?,
+        Command::Wmolamps { prefix, detail } => {
+            scan::wmolamps(&mut chain, prefix.as_deref(), detail.as_deref())?
+        }
         Command::Darkpropscan { prefix } => scan::darkpropscan(&mut chain, prefix.as_deref())?,
         Command::Placescan {
             map,
diff --git a/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs b/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs
index 6d0bb77d..1b3ff638 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs
@@ -2,8 +2,10 @@
 //! lanes, on both sides of the WMO/M2 boundary.
 //!
 //! `darkpropscan` asks which placed WMO props the interior lane commits as literal black
-//! (decision 0969's census), `m2lightscan` which M2s author dynamic light blocks at all, and
-//! `shadeat` reads the terrain MCSH shadow bit that decides a doodad's sun gain.
+//! (decision 0969's census), `m2lightscan` which M2s author dynamic light blocks at all,
+//! `m2firescan` which of the ones that DON'T would have a light SYNTHESISED from their flame
+//! emitter (MONKEY, fire GO lights), and `shadeat` reads the terrain MCSH shadow bit that decides a
+//! doodad's sun gain.
 
 use std::collections::BTreeMap;
 
@@ -313,6 +315,167 @@ pub fn m2lightscan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
     Ok(())
 }
 
+/// MONKEY (fire GO lights) / MONKEY (lamp lights): sweep every `.m2` (optionally under a prefix)
+/// and report which models would take a **synthesised** light, and BY WHICH ROUTE — the offline
+/// audit of [`benilla_formats::fire_light`]'s two heuristics, which is the only way to see what a
+/// rule applied to ~4000 world props actually does before shipping it.
+///
+/// The three routes, in the order the bake tries them:
+/// - `flame` — a flame PARTICLE EMITTER. Per hit: the winning emitter's index/texture, the colour
+///   read off its over-life ramp, the size bucket and the emitter's model-local position.
+/// - `name` — the model's basename is lamp/lantern/chandelier/sconce vocabulary.
+/// - `emissive` — no name hit, but an UNLIT + transparent + glow-textured render batch.
+///
+/// The lamp routes print `pos` as the emissive geoset's CENTROID and `+Zbase` as its height above
+/// the model's own bounding-box floor — the number the whole lamp feature turns on, because a light
+/// at the model origin sits at the foot of the pole. `BBOX` marks a hit that found no unlit
+/// geometry and fell back to the bounding-box top centre.
+///
+/// Models that ALREADY author a casting point light are counted separately and skipped — the
+/// authored block always wins, and the populations must never be conflated. The closing summary is
+/// the deliverable: per-route totals, buckets, per-family counts, and a colour tally so an
+/// over-broad texture key shows up as a flood of one hue.
+pub fn m2firescan(chain: &mut Chain, prefix: Option<&str>) -> Result<()> {
+    let names = super::m2_names(chain, prefix)?;
+    let (mut scanned, mut authored, mut hits) = (0u32, 0u32, 0u32);
+    let mut buckets: BTreeMap<&'static str, u32> = BTreeMap::new();
+    // MONKEY (lamp lights): which of the three detection routes fired, per model.
+    let mut routes: BTreeMap<&'static str, u32> = BTreeMap::new();
+    let mut families: BTreeMap<String, u32> = BTreeMap::new();
+    // Rounded `(r, g, b) × 100` -> (count, one example).
+    let mut color_tally: BTreeMap<(i32, i32, i32), (u32, String)> = BTreeMap::new();
+    let mut rows: Vec<String> = Vec::new();
+
+    for name in names {
+        let Ok(bytes) = chain.read_file(&name) else {
+            continue;
+        };
+        scanned += 1;
+        // The authored block wins entirely — same gate the asset bake applies.
+        if benilla_formats::parse_m2_lights(&bytes).iter().any(|l| l.casts()) {
+            authored += 1;
+            continue;
+        }
+        let emitters = benilla_formats::parse_m2_particle_emitters(&bytes).unwrap_or_default();
+        // MONKEY (lamp lights): route 1 is the flame emitter; routes 2/3 read the model's RENDER
+        // BATCHES, so the submesh parse only runs where the flame route found nothing (which is
+        // most of the corpus, but the parse is the same one the asset bake does anyway).
+        let (route, color, intensity, bucket, detail) = match
+            benilla_formats::synthesize_fire_light(&name, &emitters)
+        {
+            Some(fire) => {
+                let e = &emitters[fire.emitter];
+                let detail = format!(
+                    "E{}  {:<44}  size {:.3} rate {:.1} strength {:.3}  pos ({:.2}, {:.2}, {:.2}) bone {}",
+                    fire.emitter,
+                    e.texture.as_deref().unwrap_or("-"),
+                    benilla_formats::fire_light::peak_size(e),
+                    e.timing.peak_rate(),
+                    benilla_formats::fire_light::fire_strength(e),
+                    e.position[0], e.position[1], e.position[2],
+                    e.bone,
+                );
+                (
+                    benilla_formats::LightRoute::Flame,
+                    fire.color,
+                    fire.intensity,
+                    fire.bucket,
+                    detail,
+                )
+            }
+            None => {
+                let Ok(subs) = benilla_formats::parse_m2_render_submeshes(&bytes, "", &[]) else {
+                    continue;
+                };
+                let batches: Vec<benilla_formats::EmissiveBatch<'_>> =
+                    subs.iter().map(benilla_formats::EmissiveBatch::from).collect();
+                let bounds = benilla_formats::parse_m2_bounds(&bytes).ok();
+                let bbox = bounds.as_ref().map(|b| (b.bbox_min, b.bbox_max));
+                let Some(lamp) = benilla_formats::synthesize_lamp_light(&name, &batches, bbox)
+                else {
+                    continue;
+                };
+                // How high the light ended up above the model's own floor — the whole point of
+                // reading the geoset instead of using the origin. A lamppost must read ~4-5 yd.
+                let base = bbox.map_or(0.0, |(lo, _)| lo[2]);
+                let detail = format!(
+                    "{:<6}  {:<44}  pos ({:.2}, {:.2}, {:.2}) +Zbase {:.2} bone {}",
+                    match lamp.batch {
+                        Some(i) => format!("B{i}"),
+                        None => "BBOX".to_string(),
+                    },
+                    lamp.batch
+                        .and_then(|i| subs[i].texture.as_deref())
+                        .unwrap_or("(bbox top centre)"),
+                    lamp.position[0], lamp.position[1], lamp.position[2],
+                    lamp.position[2] - base,
+                    lamp.bone,
+                );
+                (lamp.route, lamp.color, lamp.intensity, lamp.bucket, detail)
+            }
+        };
+        hits += 1;
+        *routes.entry(route.label()).or_default() += 1;
+        *buckets.entry(bucket).or_default() += 1;
+        *families.entry(super::family_of(&name)).or_default() += 1;
+        let key = (
+            (color[0] * 100.0).round() as i32,
+            (color[1] * 100.0).round() as i32,
+            (color[2] * 100.0).round() as i32,
+        );
+        color_tally.entry(key).or_insert_with(|| (0, name.clone())).0 += 1;
+        rows.push(format!(
+            "{name}\n    [{:<8}] rgb ({:.3}, {:.3}, {:.3})  {:<11} x{:.2}  {detail}",
+            route.label(),
+            color[0], color[1], color[2],
+            bucket, intensity,
+        ));
+    }
+
+    rows.sort();
+    for r in &rows {
+        println!("{r}");
+    }
+    println!();
+    println!(
+        "=== summary ===  {scanned} models scanned, {authored} already author a casting point light (skipped), {hits} would SYNTHESISE one"
+    );
+    println!();
+    println!("=== by detection route ===");
+    for (r, n) in &routes {
+        println!("{r:<10} {n:>4}");
+    }
+    println!();
+    println!("=== by intensity bucket ===");
+    for (b, n) in &buckets {
+        println!("{b:<12} {n:>4}");
+    }
+    println!();
+    println!("=== by content family ===");
+    for (f, n) in &families {
+        println!("{f:<32} {n:>4}");
+    }
+    println!();
+    println!("=== derived colour tally (peak-normalised, rounded to 0.01) ===");
+    let mut ranked: Vec<_> = color_tally.iter().collect();
+    ranked.sort_by_key(|(_, (count, _))| std::cmp::Reverse(*count));
+    for (key, (count, example)) in ranked.iter().take(TALLY_ROWS) {
+        let (r, g, b) = (
+            key.0 as f32 / 100.0,
+            key.1 as f32 / 100.0,
+            key.2 as f32 / 100.0,
+        );
+        println!(
+            "{count:>4}x  ({r:.2}, {g:.2}, {b:.2})  {:<5}  e.g. {example}",
+            hue_tag(r, g, b)
+        );
+    }
+    if let Some(rest) = ranked.len().checked_sub(TALLY_ROWS).filter(|n| *n > 0) {
+        println!("      … and {rest} rarer colours (top {TALLY_ROWS} shown)");
+    }
+    Ok(())
+}
+
 /// The terrain MCSH shadow bit at a world position + an ASCII texel neighborhood (`#` shadowed,
 /// `.` lit, `?` off-tile/no-chunk). One MCSH texel is `TILE_SIZE/1024` ≈ 0.52 yd; the grid spans
 /// ±8 texels so a doodad base sitting one texel from a shadow edge — the 2.5-vs-0.5 intensity
@@ -354,3 +517,804 @@ pub fn shadeat(chain: &mut Chain, map: &str, x: f32, y: f32) -> Result<()> {
     }
     Ok(())
 }
+
+/// MONKEY (interior attenuation): dump ONE WMO root's **MOLT fixture table** — the authored
+/// numbers the interior lane is calibrated against, which nothing could read before this.
+///
+/// Per fixture: type, the `useAtten` byte, the raw colour, the intensity, the product the packer
+/// commits (`colour × intensity`, [`benilla_world::lighting::commit_raw`]'s input), the authored
+/// attenuation **start/end** in yards (`+0x28`/`+0x2c` — see `read_wmo_light`), model-space
+/// position, and the groups whose MOLR names it (its ROOMS: a fixture no group names keeps none
+/// and stays ungated). The closing block is the number the flatness question actually needs: for
+/// each omni fixture, the value of our fixed falloff `1/(0.7d + 0.03d²)` at its own authored end
+/// — i.e. how much reach the curve still has where the artist said the light stops.
+/// MONKEY (portal claims): everything ONE WMO root's room-claim rule needs, read off the chain in a
+/// single group-file pass — the offline twin of what `benilla_world`'s spawner holds in the loaded
+/// `WmoModel`. Both feed [`benilla_formats::room_claims`], so the claim set this tool prints IS the
+/// claim set the shader will gate on.
+struct RootRooms {
+    infos: Vec<benilla_formats::WmoGroupInfo>,
+    /// Per absolute group: its MOGP flags and its `(portal_ref_start, portal_ref_count)` slice.
+    flags: Vec<u32>,
+    slices: Vec<(u16, u16)>,
+    portals: benilla_formats::WmoPortals,
+    /// Per absolute group: the MOLR light indices it names.
+    light_refs: Vec<Vec<u16>>,
+    /// MODD index -> the groups whose MODR names it (the prop's rooms).
+    doodad_groups: BTreeMap<u16, Vec<u16>>,
+}
+
+impl RootRooms {
+    fn graph(&self) -> benilla_formats::PortalGraph<'_> {
+        benilla_formats::PortalGraph {
+            vertices: &self.portals.vertices,
+            infos: &self.portals.infos,
+            refs: &self.portals.refs,
+            slices: &self.slices,
+        }
+    }
+
+    /// The groups whose MOLR names light `i` — the claim rule's MOLR input.
+    fn molr(&self, i: u16) -> Vec<u16> {
+        self.light_refs
+            .iter()
+            .enumerate()
+            .filter(|(_, refs)| refs.contains(&i))
+            .map(|(g, _)| g as u16)
+            .collect()
+    }
+}
+
+/// MONKEY (ext-class night law): the authored MOGN group names, indexed by absolute group index.
+/// Not on [`benilla_formats::WmoRoot`] — nothing in the renderer needs them — but an audit that has
+/// to say WHICH room seamed reads very differently with `kitchen`/`upstairs` beside the boxes than
+/// with `g3`/`g4`. A raw chunk walk: MOGI is 32-byte records whose last i32 is a byte offset into
+/// the MOGN string block (`-1` = unnamed, which vanilla uses freely).
+fn group_names(bytes: &[u8]) -> Vec<Option<String>> {
+    let (mut mogn, mut mogi) = (None, None);
+    let mut o = 0usize;
+    while o + 8 <= bytes.len() {
+        let tag = [bytes[o + 3], bytes[o + 2], bytes[o + 1], bytes[o]];
+        let n = u32::from_le_bytes(bytes[o + 4..o + 8].try_into().unwrap()) as usize;
+        let body = bytes.get(o + 8..o + 8 + n);
+        match (&tag, body) {
+            (b"MOGN", Some(b)) => mogn = Some(b),
+            (b"MOGI", Some(b)) => mogi = Some(b),
+            _ => {}
+        }
+        o += 8 + n;
+    }
+    let (Some(mogn), Some(mogi)) = (mogn, mogi) else {
+        return Vec::new();
+    };
+    mogi.chunks_exact(32)
+        .map(|r| {
+            let off = i32::from_le_bytes(r[28..32].try_into().unwrap());
+            let off = usize::try_from(off).ok()?;
+            let rest = mogn.get(off..)?;
+            let end = rest.iter().position(|&b| b == 0).unwrap_or(rest.len());
+            Some(String::from_utf8_lossy(&rest[..end]).into_owned()).filter(|s| !s.is_empty())
+        })
+        .collect()
+}
+
+/// MONKEY (trans night floor): the group file's MOGP payload — `benilla_formats`'s own chunk walker
+/// is `pub(crate)` and this instrument lives in a separate bin target, so the four lines are
+/// repeated rather than the visibility widened for an audit.
+fn mogp_payload(bytes: &[u8]) -> Option<&[u8]> {
+    let mut o = 0usize;
+    while o + 8 <= bytes.len() {
+        let tag = [bytes[o], bytes[o + 1], bytes[o + 2], bytes[o + 3]];
+        let n = u32::from_le_bytes(bytes[o + 4..o + 8].try_into().ok()?) as usize;
+        if &tag == b"PGOM" {
+            return bytes.get(o + 8..(o + 8 + n).min(bytes.len()));
+        }
+        o += 8 + n;
+    }
+    None
+}
+
+/// MONKEY (trans night floor): the per-group **MOBA batch-class** table — the instrument the
+/// interior seam actually asks for.
+///
+/// `wmolights`'s group table above answers "which LIGHTING LANE is this group on" (INT / ext* /
+/// ext). It cannot answer the next question down, which is the one a seam *inside* one interior
+/// room reduces to: an interior group's batches are split TRANS / INT / EXT by the MOGP batch
+/// section counts (`+0x28` / `+0x2a`), and the shader gives each class a DIFFERENT day weight
+/// (`static_gx.wgsl`'s `day_w` — TRANS takes the MOCV alpha, EXT takes 1, INT takes 0). So a hard
+/// line across a doorway inside one room is a BATCH-class line, invisible to every table we had.
+///
+/// The printed numbers are exactly the shader's inputs for that weight: the class, the batch's
+/// triangle count, its world-space (model-space) bbox so it can be matched to a screenshot, and the
+/// **MOCV alpha** range/mean — `trans_a` in the shader, straight off `wmo_group_fixed_colors` (the
+/// buffer as the renderer uploads it, doorway fade included), i.e. the number `day_w = trans_a *
+/// sun_w` is built from. `a=255` on a TRANS batch means the batch takes the exterior sky law at
+/// FULL weight whenever the sun is above the horizon.
+fn batch_class_table(
+    chain: &mut Chain,
+    root: &benilla_formats::WmoRoot,
+    root_path: &str,
+    names: &[Option<String>],
+    infos: &[benilla_formats::WmoGroupInfo],
+    // MONKEY (trans day law): dump this group's per-VERTEX rows as well (see the CLI doc).
+    verts: Option<usize>,
+) {
+    println!("=== MOBA batch classes (per group; a = MOCV alpha = the shader's `trans_a`) ===");
+    let stem = root_path
+        .to_ascii_lowercase()
+        .strip_suffix(".wmo")
+        .unwrap_or(root_path)
+        .to_string();
+    for gi in 0..root.group_count() as usize {
+        let Ok(gbytes) = chain.read_file(&format!("{stem}_{gi:03}.wmo")) else {
+            continue;
+        };
+        let Ok(benilla_wmo::ParsedWmo::Group(group)) =
+            benilla_wmo::parse_wmo(&mut std::io::Cursor::new(gbytes.as_slice()))
+        else {
+            continue;
+        };
+        // The MOGP batch-section counts — the SAME two reads `build_wmo_group_submeshes` makes.
+        let (trans_n, int_n) = mogp_payload(&gbytes)
+            .filter(|m| m.len() >= 0x2c)
+            .map_or((0usize, 0usize), |m| {
+                (
+                    u16::from_le_bytes([m[0x28], m[0x29]]) as usize,
+                    u16::from_le_bytes([m[0x2a], m[0x2b]]) as usize,
+                )
+            });
+        // The colours AS UPLOADED (doorway fade applied), so the alpha printed is the alpha the
+        // shader interpolates. BGRA — index 3 is alpha.
+        let colors = benilla_formats::wmo_group_fixed_colors(&gbytes, root);
+        let interior = (group.flags & 0x48) == 0;
+        println!(
+            "  g{gi:<3} {:<12} {:<4} batches {:<3} (trans {trans_n}, int {int_n}, ext {})",
+            names.get(gi).and_then(|n| n.as_deref()).unwrap_or("-"),
+            if interior { "INT" } else { "ext" },
+            group.render_batches.len(),
+            group.render_batches.len().saturating_sub(trans_n + int_n),
+        );
+        for (bi, batch) in group.render_batches.iter().enumerate() {
+            let class = if bi < trans_n {
+                "TRANS"
+            } else if bi < trans_n + int_n {
+                "INT"
+            } else {
+                "EXT"
+            };
+            let start = batch.start_index as usize;
+            let idx: Vec<usize> = group
+                .vertex_indices
+                .get(start..start + batch.count as usize)
+                .unwrap_or(&[])
+                .iter()
+                .map(|&i| i as usize)
+                .filter(|&g| g < group.vertex_positions.len())
+                .collect();
+            if idx.is_empty() {
+                continue;
+            }
+            let (mut lo, mut hi) = ([f32::MAX; 3], [f32::MIN; 3]);
+            let (mut a_lo, mut a_hi, mut a_sum, mut rgb_sum, mut n) =
+                (255u16, 0u16, 0u32, [0u32; 3], 0u32);
+            for &g in &idx {
+                let p = &group.vertex_positions[g];
+                for (k, v) in [p.x, p.y, p.z].into_iter().enumerate() {
+                    lo[k] = lo[k].min(v);
+                    hi[k] = hi[k].max(v);
+                }
+                if let Some(c) = colors.as_ref().and_then(|c| c.get(g)) {
+                    let a = u16::from(c[3]);
+                    a_lo = a_lo.min(a);
+                    a_hi = a_hi.max(a);
+                    a_sum += u32::from(c[3]);
+                    // BGRA on disk — print it as RGB.
+                    rgb_sum[0] += u32::from(c[2]);
+                    rgb_sum[1] += u32::from(c[1]);
+                    rgb_sum[2] += u32::from(c[0]);
+                    n += 1;
+                }
+            }
+            let mean = |s: u32| if n == 0 { 0 } else { s / n };
+            println!(
+                "     b{bi:<3} {class:<5} tris {:>5}  a[{:>3}..{:>3}] mean {:>3}  mocv rgb ({:>3},{:>3},{:>3})  box ({:>7.2},{:>7.2},{:>6.2})..({:>7.2},{:>7.2},{:>6.2})",
+                idx.len() / 3,
+                if n == 0 { 255 } else { a_lo },
+                if n == 0 { 255 } else { a_hi },
+                if n == 0 { 255 } else { mean(a_sum) as u16 },
+                mean(rgb_sum[0]), mean(rgb_sum[1]), mean(rgb_sum[2]),
+                lo[0], lo[1], lo[2], hi[0], hi[1], hi[2],
+            );
+            // MONKEY (trans day law): the per-VERTEX rows. `trans_a` is interpolated across the
+            // triangle from these alphas, so the BEFORE curve of the TRANS day blend is a function
+            // of exactly this list; the batch mean above cannot produce it.
+            if verts == Some(gi) {
+                let mut seen: Vec<usize> = Vec::new();
+                for &g in &idx {
+                    if seen.contains(&g) {
+                        continue;
+                    }
+                    seen.push(g);
+                    let p = &group.vertex_positions[g];
+                    let c = colors.as_ref().and_then(|c| c.get(g)).copied().unwrap_or([255; 4]);
+                    let a = c[3];
+                    println!(
+                        "          v{g:<5} ({:>7.2},{:>7.2},{:>6.2})  a {a:>3} ({:.3})  rgb ({:>3},{:>3},{:>3})",
+                        p.x, p.y, p.z, f32::from(a) / 255.0, c[2], c[1], c[0],
+                    );
+                }
+                print!("          tris");
+                for t in idx.chunks(3) {
+                    print!(" [{}]", t.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(","));
+                }
+                println!();
+            }
+        }
+    }
+    let _ = infos;
+    println!();
+}
+
+fn root_rooms(
+    chain: &mut Chain,
+    root: &benilla_formats::WmoRoot,
+    root_path: &str,
+    bytes: &[u8],
+) -> RootRooms {
+    let stem = root_path
+        .to_ascii_lowercase()
+        .strip_suffix(".wmo")
+        .unwrap_or(root_path)
+        .to_string();
+    let n = root.group_count();
+    let (mut flags, mut slices, mut light_refs) = (Vec::new(), Vec::new(), Vec::new());
+    let mut doodad_groups: BTreeMap<u16, Vec<u16>> = BTreeMap::new();
+    for gi in 0..n {
+        let gbytes = chain.read_file(&format!("{stem}_{gi:03}.wmo")).ok();
+        let h = gbytes
+            .as_deref()
+            .and_then(benilla_formats::wmo_group_header);
+        flags.push(h.as_ref().map_or(0, |h| h.flags));
+        slices.push(h.map_or((0, 0), |h| (h.portal_ref_start, h.portal_ref_count)));
+        light_refs.push(
+            gbytes
+                .as_deref()
+                .map(benilla_formats::wmo_group_light_refs)
+                .unwrap_or_default(),
+        );
+        for r in gbytes
+            .as_deref()
+            .map(benilla_formats::wmo_group_doodad_refs)
+            .unwrap_or_default()
+        {
+            let e = doodad_groups.entry(r).or_default();
+            if e.last() != Some(&(gi as u16)) {
+                e.push(gi as u16);
+            }
+        }
+    }
+    RootRooms {
+        infos: root.group_infos().to_vec(),
+        flags,
+        slices,
+        portals: benilla_formats::parse_wmo_portals(bytes),
+        light_refs,
+        doodad_groups,
+    }
+}
+
+/// One claim set as a compact cell: `g4e:in g7i:portal1 3.2/w5.0`. A trailing `*` marks a claim the
+/// EXTERIOR batch lane will NOT honour (a district-scale shell — `room_claim::CLAIM_EXT_SHELL_YD`);
+/// it still gates the fixture, it just cannot light a whole city block.
+///
+/// MONKEY (soft portal claims): a portal claim prints
+/// `portal<hops> <distance>/w<fade radius>+<doorway slack>x<entry weight>` — the four numbers the
+/// shader's weight is built from (`w = entry * (1 - smoothstep(0, radius, |P - door| - slack))`),
+/// so the instrument can be read against a screenshot of the seam. A base claim prints no numbers:
+/// it is HARD, weight 1 across the whole group.
+fn claim_cell(claims: &[benilla_formats::Claim]) -> String {
+    if claims.is_empty() {
+        return "-  (UNGATED: no room claims it)".to_string();
+    }
+    claims
+        .iter()
+        .map(|c| {
+            let (hop, d) = if c.how == benilla_formats::ClaimHow::Portal {
+                (
+                    c.hops.to_string(),
+                    format!(
+                        " {:.1}/w{:.1}+{:.1}x{:.2}",
+                        c.distance, c.fade_radius, c.fade_slack, c.fade_entry,
+                    ),
+                )
+            } else {
+                (String::new(), String::new())
+            };
+            format!(
+                "g{}{}:{}{hop}{d}{}",
+                c.group,
+                if c.interior { "i" } else { "e" },
+                c.how.tag(),
+                if c.ext_ok { "" } else { "*" },
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+pub fn wmolights(chain: &mut Chain, raw_path: &str, verts: Option<usize>) -> Result<()> {
+    let root_path = raw_path.replace('/', "\\").to_ascii_lowercase();
+    let bytes = chain
+        .read_file(&root_path)
+        .with_context(|| format!("reading WMO root '{root_path}'"))?;
+    let root = benilla_formats::parse_wmo_root(&bytes)
+        .with_context(|| format!("parsing WMO root '{root_path}'"))?;
+    let lights = benilla_formats::parse_wmo_lights(&bytes);
+    // MONKEY (portal claims): the group table + the portal graph, read once — the same inputs the
+    // spawner feeds `room_claims`, so what prints below is what the room gate will enforce.
+    let rr = root_rooms(chain, &root, &root_path, &bytes);
+    let infos = root.group_infos();
+
+    println!(
+        "{root_path}  —  {} MOLT light(s), {} group(s), {} portal(s)",
+        lights.len(),
+        root.group_count(),
+        rr.portals.infos.len(),
+    );
+    // The group table: the class the whole lighting split turns on. An `e` group INSIDE a building
+    // (an inn's basement stairwell, a covered porch) is drawn by the EXTERIOR law and takes the
+    // night sky unless an interior fixture claims it — that is bug B's second cause, and this is
+    // where you read which groups are in that population.
+    // MONKEY (ext-class night law): the class column now says WHICH of the three lanes the group
+    // is on, because that is the question a seam asks. `INT` = the room lane always; `ext*` = an
+    // exterior-class group at BUILDING scale, which takes the room lane after dark (and which
+    // `interiorDebug 4` paints BLUE); `ext` = a district-scale shell, sky-lit always (RED).
+    println!("=== groups (name, lane, MOGP flags, MOGI box, portals, MOLR fixtures) ===");
+    let names = group_names(&bytes);
+    for gi in 0..root.group_count() as usize {
+        let Some(g) = infos.get(gi) else { continue };
+        let (_, pc) = rr.slices.get(gi).copied().unwrap_or((0, 0));
+        println!(
+            "  g{gi:<3} {:<12} {:<4} flags {:#010x}  box ({:>8.2},{:>8.2},{:>7.2})..({:>8.2},{:>8.2},{:>7.2})  portals {pc:<3} molr {:?}",
+            names.get(gi).and_then(|n| n.as_deref()).unwrap_or("-"),
+            match (g.interior, benilla_formats::room_claim::ext_building_scale(g)) {
+                (true, _) => "INT",
+                (_, true) => "ext*",
+                _ => "ext",
+            },
+            rr.flags.get(gi).copied().unwrap_or(0),
+            g.bbox_min[0], g.bbox_min[1], g.bbox_min[2],
+            g.bbox_max[0], g.bbox_max[1], g.bbox_max[2],
+            rr.light_refs.get(gi).map(|v| v.len()).unwrap_or(0),
+        );
+    }
+    println!();
+    // MONKEY (split-floor claims): the portal table. AREA is the measurement the split rule turns
+    // on ([`benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA`]) — a doorway is small, a room the
+    // artist cut in half is not — so it prints beside the groups each portal joins and a `SPLIT`
+    // marker for the ones a containment claim now crosses at full weight instead of fading.
+    println!("=== portals (polygon area vs SPLIT_PORTAL_MIN_AREA = {:.0} yd^2) ===",
+        benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA);
+    let graph = rr.graph();
+    for pi in 0..rr.portals.infos.len() {
+        let area = benilla_formats::room_claim::portal_area(&graph, pi as u16).unwrap_or(0.0);
+        let plane = rr.portals.infos[pi].plane;
+        let joins: Vec<u16> = rr
+            .portals
+            .refs
+            .iter()
+            .filter(|r| usize::from(r.portal) == pi)
+            .map(|r| r.group)
+            .collect();
+        // MONKEY (portal bleed): ...and the POLYGON's own box - centre + diagonal. The bleed seed
+        // reaches for both (`daylight_reach(diag)` is its radius, the centre its position), and the
+        // `BLEED` tag marks the population it seeds from: a portal whose two sides are BOTH
+        // interior-class groups, i.e. a doorway between two rooms rather than one to the outside.
+        // `DAY` is the daylight-fixture portal seed's own population, printed beside it so one
+        // table answers "which rule, if any, stands a light in this opening".
+        let pbox = rr
+            .portals
+            .infos
+            .get(pi)
+            .and_then(|i| {
+                let s = usize::from(i.start_vertex);
+                rr.portals.vertices.get(s..s + usize::from(i.count))
+            })
+            .map(|v| {
+                let mut lo = [f32::MAX; 3];
+                let mut hi = [f32::MIN; 3];
+                for p in v {
+                    for a in 0..3 {
+                        lo[a] = lo[a].min(p[a]);
+                        hi[a] = hi[a].max(p[a]);
+                    }
+                }
+                (lo, hi)
+            });
+        let (diag, ctr) = pbox.map_or((0.0, [0.0; 3]), |(lo, hi)| {
+            (
+                ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2) + (hi[2] - lo[2]).powi(2)).sqrt(),
+                [
+                    0.5 * (lo[0] + hi[0]),
+                    0.5 * (lo[1] + hi[1]),
+                    0.5 * (lo[2] + hi[2]),
+                ],
+            )
+        });
+        let cls: Vec<bool> = joins
+            .iter()
+            .filter_map(|g| rr.infos.get(usize::from(*g)).map(|g| g.interior))
+            .collect();
+        let kind = if cls.len() == 2 && cls.iter().all(|i| *i) {
+            "  BLEED"
+        } else if cls.iter().any(|i| *i) {
+            "  DAY"
+        } else {
+            ""
+        };
+        println!(
+            "  p{pi:<3} area {area:>7.2} yd^2  diag {diag:>6.2}  ctr ({:>7.2},{:>7.2},{:>6.2})  |n.z| {:.2}  joins {joins:?}{}{kind}",
+            ctr[0], ctr[1], ctr[2],
+            plane[2].abs(),
+            if area >= benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA { "   SPLIT" } else { "" },
+        );
+        // MONKEY (trans day law): the portal's own vertex BOX under `--verts`. The daylight seed's
+        // calibration geometry is read off it and nothing else prints it: `seed_point` stands the
+        // fixture at the box centre but no higher than `SEED_MAX_HZ` above the box BOTTOM, and
+        // `hz = z - lo.z` is the calibration height. Without `lo[2]` neither number is recoverable
+        // from the centre+diagonal line above.
+        if verts.is_some() {
+            if let Some((lo, hi)) = pbox {
+                println!(
+                    "        box ({:>7.2},{:>7.2},{:>6.2})..({:>7.2},{:>7.2},{:>6.2})",
+                    lo[0], lo[1], lo[2], hi[0], hi[1], hi[2],
+                );
+            }
+        }
+    }
+    println!();
+    batch_class_table(chain, &root, &root_path, &names, &infos, verts);
+    for (i, l) in lights.iter().enumerate() {
+        let prod = [
+            l.color[0] * l.intensity,
+            l.color[1] * l.intensity,
+            l.color[2] * l.intensity,
+        ];
+        let molr = rr.molr(i as u16);
+        let reach = benilla_formats::room_claim::claim_reach(l.attenuation_end);
+        let claims = benilla_formats::room_claims(&rr.infos, rr.graph(), l.position, reach, &molr);
+        println!(
+            "  L{i:<3} type {}{}  colour ({:.3}, {:.3}, {:.3}) x {:.3} = ({:.3}, {:.3}, {:.3})  atten [{:.3}, {:.3}]  R {reach:.1}  pos ({:>8.2},{:>8.2},{:>8.2})",
+            l.light_type,
+            if l.use_atten { " atten" } else { "      " },
+            l.color[0], l.color[1], l.color[2],
+            l.intensity,
+            prod[0], prod[1], prod[2],
+            l.attenuation_start, l.attenuation_end,
+            l.position[0], l.position[1], l.position[2],
+        );
+        if l.is_omni() {
+            println!("        claims {}", claim_cell(&claims));
+        }
+    }
+
+    // What our FIXED curve is still worth at the artist's own cutoff — the flatness measurement.
+    println!();
+    println!("=== the fixed falloff 1/(0.7d + 0.03d²) at each omni fixture's authored end ===");
+    let omni: Vec<&benilla_formats::WmoLight> = lights.iter().filter(|l| l.is_omni()).collect();
+    for (i, l) in omni.iter().enumerate() {
+        let d = l.attenuation_end.max(1e-3);
+        println!(
+            "  omni {i:<3} end {:>7.3} yd  atten(end) {:.4}  atten(end)/atten(1yd) {:.4}",
+            l.attenuation_end,
+            1.0 / (0.7 * d + 0.03 * d * d),
+            (1.0 / (0.7 * d + 0.03 * d * d)) / (1.0 / 0.73),
+        );
+    }
+    let ends: Vec<f32> = omni.iter().map(|l| l.attenuation_end).collect();
+    if !ends.is_empty() {
+        let mut sorted = ends.clone();
+        sorted.sort_by(f32::total_cmp);
+        println!(
+            "  {} omni: end min {:.3} median {:.3} max {:.3}",
+            sorted.len(),
+            sorted[0],
+            sorted[sorted.len() / 2],
+            sorted[sorted.len() - 1],
+        );
+    }
+    Ok(())
+}
+
+/// MONKEY (interior prop lights): what ONE prop model contributes as a light source, resolved once
+/// per model path and memoised across the whole sweep (a city references the same lantern hundreds
+/// of times).
+#[derive(Clone)]
+enum PropLightKind {
+    /// The M2 authors a casting light block — every lane already spawns it, synthetic or not.
+    Authored,
+    /// No authored block, but `fire_light`'s flame or lamp route derives one: the model-space
+    /// position of the FLAME (or the lamp glass) and its intensity.
+    Synth { pos: [f32; 3], intensity: f32 },
+    /// Neither — a chair, a barrel, a rug.
+    None,
+}
+
+/// Rotate `v` by the MODD orientation quaternion `(x, y, z, w)` — `v + 2q×(q×v + wv)`. Written out
+/// rather than pulled from a math crate because `benilla-formats` deliberately carries none, and
+/// this is the only place the offline audit needs to place a prop.
+fn quat_rotate(q: [f32; 4], v: [f32; 3]) -> [f32; 3] {
+    let (x, y, z, w) = (q[0], q[1], q[2], q[3]);
+    let cross = |a: [f32; 3], b: [f32; 3]| {
+        [
+            a[1] * b[2] - a[2] * b[1],
+            a[2] * b[0] - a[0] * b[2],
+            a[0] * b[1] - a[1] * b[0],
+        ]
+    };
+    let u = [x, y, z];
+    let t = cross(u, v);
+    let t = [t[0] + w * v[0], t[1] + w * v[1], t[2] + w * v[2]];
+    let t = cross(u, t);
+    [v[0] + 2.0 * t[0], v[1] + 2.0 * t[1], v[2] + 2.0 * t[2]]
+}
+
+/// The prop-light rule resolved for one model path: the SAME chain `benilla_assets::m2` applies at
+/// asset load (an authored block wins; else the flame route; else the lamp route), so a prop this
+/// sweep counts as a light source is exactly one the runtime will spawn a light for.
+fn prop_light_kind(chain: &mut Chain, key: &str) -> PropLightKind {
+    let Ok(bytes) = chain.read_file(key) else {
+        return PropLightKind::None; // a prop the client doesn't ship
+    };
+    if benilla_formats::parse_m2_lights(&bytes)
+        .iter()
+        .any(|l| l.casts())
+    {
+        return PropLightKind::Authored;
+    }
+    let emitters = benilla_formats::parse_m2_particle_emitters(&bytes).unwrap_or_default();
+    if let Some(fire) = benilla_formats::synthesize_fire_light(key, &emitters) {
+        return PropLightKind::Synth {
+            pos: emitters[fire.emitter].position,
+            intensity: fire.intensity,
+        };
+    }
+    let Ok(subs) = benilla_formats::parse_m2_render_submeshes(&bytes, "", &[]) else {
+        return PropLightKind::None;
+    };
+    let batches: Vec<benilla_formats::EmissiveBatch<'_>> = subs
+        .iter()
+        .map(benilla_formats::EmissiveBatch::from)
+        .collect();
+    let bounds = benilla_formats::parse_m2_bounds(&bytes).ok();
+    let bbox = bounds.as_ref().map(|b| (b.bbox_min, b.bbox_max));
+    match benilla_formats::synthesize_lamp_light(key, &batches, bbox) {
+        Some(lamp) => PropLightKind::Synth {
+            pos: lamp.position,
+            intensity: lamp.intensity,
+        },
+        None => PropLightKind::None,
+    }
+}
+
+/// MONKEY (wmo exterior points): how close an authored MOLT fixture has to stand to a prop's flame
+/// (yd) for the synthesised light to be dropped as a duplicate. **Keep equal to
+/// `benilla_world::terrain_stream::spawn::fx`'s `MODD_SYNTH_DEDUPE`** — the point of this sweep is
+/// to predict what that dedupe does across the corpus.
+const MODD_SYNTH_DEDUPE: f32 = 2.5;
+
+/// One root's audit numbers.
+struct LampRow {
+    path: String,
+    groups: usize,
+    interior_groups: usize,
+    molt: usize,
+    props: usize,
+    authored: usize,
+    synth: usize,
+    deduped: usize,
+    /// Interior groups no MOLT fixture claims (the pre-fix darkness).
+    dark_molt: usize,
+    /// …and still none after the synthesised prop lights are admitted indoors.
+    dark_after: usize,
+}
+
+/// MONKEY (interior prop lights): the corpus audit behind "make sure all WMOs with built-in light
+/// sources have light working". For every WMO root in the chain: its MOLT omni fixtures, its MODD
+/// props that WOULD synthesise a light (`fire_light`'s flame/lamp routes, run on the prop's own M2
+/// exactly as the asset bake runs them), how many of those the 2.5 yd MOLT dedupe drops, and how
+/// many INTERIOR groups end up with no light source claiming them at all — before and after the
+/// prop lane is admitted indoors.
+///
+/// A group left in the `darkAFTER` column is either the artist's intent (a cellar, a closet, a
+/// sealed shaft) or a detection miss; `detail` names them per root so the two can be told apart.
+pub fn wmolamps(chain: &mut Chain, prefix: Option<&str>, detail: Option<&str>) -> Result<()> {
+    let roots = super::wmo_roots(chain, prefix)?;
+    // The buildings the owner actually walks through — always reported, wherever they rank.
+    const LANDMARKS: [&str; 16] = [
+        "buildings\\stormwind\\stormwind.wmo",
+        "buildings\\goldshireinn\\goldshireinn.wmo",
+        "buildings\\nsabbey\\nsabbey.wmo",
+        "cities\\ironforge\\ironforge.wmo",
+        "undercity\\undercity.wmo",
+        "ogrimmar.wmo",
+        "darnassis.wmo",
+        "az_deadmines_a.wmo",
+        "az_deadmines_b.wmo",
+        "stormwindjail.wmo",
+        "stormwindprison.wmo",
+        "westfall_inn.wmo",
+        "duskwood_inn.wmo",
+        "redridge_inn.wmo",
+        "human_farm",
+        "monestary_cathedral.wmo",
+    ];
+    let mut cache: BTreeMap<String, PropLightKind> = BTreeMap::new();
+    let mut rows: Vec<LampRow> = Vec::new();
+    let mut n_roots = 0u32;
+    for root_path in roots {
+        let Ok(bytes) = chain.read_file(&root_path) else {
+            continue;
+        };
+        // The listfile's own casing varies; every match below (landmarks, `detail`) is on the
+        // lowercased path, which is also the casing `root_rooms` builds its group-file names in.
+        let root_path = root_path.to_ascii_lowercase();
+        let Ok(root) = benilla_formats::parse_wmo_root(&bytes) else {
+            continue;
+        };
+        let lights = benilla_formats::parse_wmo_lights(&bytes);
+        let omni: Vec<benilla_formats::WmoLight> =
+            lights.iter().filter(|l| l.is_omni()).cloned().collect();
+        // Nothing to say about a root with no interior geometry and no fixtures (a bridge, a fence).
+        if root.group_infos().iter().all(|g| !g.interior) && omni.is_empty() {
+            continue;
+        }
+        n_roots += 1;
+        let rr = root_rooms(chain, &root, &root_path, &bytes);
+        let n_groups = rr.infos.len();
+        // Which groups anything claims — the MOLT fixtures first, then the props.
+        let mut lit_by_molt = vec![false; n_groups];
+        let mut lit_by_prop = vec![false; n_groups];
+        for (i, l) in lights.iter().enumerate() {
+            if !l.is_omni() {
+                continue;
+            }
+            let molr = rr.molr(i as u16);
+            let reach = benilla_formats::room_claim::claim_reach(l.attenuation_end);
+            for c in benilla_formats::room_claims(&rr.infos, rr.graph(), l.position, reach, &molr) {
+                if let Some(slot) = lit_by_molt.get_mut(usize::from(c.group)) {
+                    *slot = true;
+                }
+            }
+        }
+        let (mut props, mut authored, mut synth, mut deduped) = (0usize, 0usize, 0usize, 0usize);
+        for (di, d) in root.doodads().iter().enumerate() {
+            if d.model.is_empty() {
+                continue;
+            }
+            props += 1;
+            let key = model_key(&d.model);
+            if !cache.contains_key(&key) {
+                let k = prop_light_kind(chain, &key);
+                cache.insert(key.clone(), k);
+            }
+            let (pos, intensity) = match cache[&key] {
+                PropLightKind::Authored => {
+                    authored += 1;
+                    continue; // an authored prop light is not this fix's population
+                }
+                PropLightKind::None => continue,
+                PropLightKind::Synth { pos, intensity } => (pos, intensity),
+            };
+            // The flame in WMO model space: the prop's placement applied to the M2-local point.
+            let r = quat_rotate(
+                d.orientation,
+                [pos[0] * d.scale, pos[1] * d.scale, pos[2] * d.scale],
+            );
+            let world = [
+                d.position[0] + r[0],
+                d.position[1] + r[1],
+                d.position[2] + r[2],
+            ];
+            let dup = omni.iter().any(|l| {
+                let dv = [
+                    l.position[0] - world[0],
+                    l.position[1] - world[1],
+                    l.position[2] - world[2],
+                ];
+                dv[0] * dv[0] + dv[1] * dv[1] + dv[2] * dv[2]
+                    < MODD_SYNTH_DEDUPE * MODD_SYNTH_DEDUPE
+            });
+            if dup {
+                deduped += 1;
+                continue;
+            }
+            synth += 1;
+            let molr = rr
+                .doodad_groups
+                .get(&(di as u16))
+                .cloned()
+                .unwrap_or_default();
+            let reach = benilla_formats::room_claim::claim_reach(
+                benilla_formats::room_claim::m2_light_reach(intensity),
+            );
+            for c in benilla_formats::room_claims(&rr.infos, rr.graph(), world, reach, &molr) {
+                if let Some(slot) = lit_by_prop.get_mut(usize::from(c.group)) {
+                    *slot = true;
+                }
+            }
+        }
+        let interior: Vec<usize> = (0..n_groups).filter(|&g| rr.infos[g].interior).collect();
+        let dark_molt = interior.iter().filter(|&&g| !lit_by_molt[g]).count();
+        let dark: Vec<usize> = interior
+            .iter()
+            .copied()
+            .filter(|&g| !lit_by_molt[g] && !lit_by_prop[g])
+            .collect();
+        if detail.is_some_and(|d| root_path.contains(&d.to_ascii_lowercase())) && !dark.is_empty() {
+            let names: Vec<String> = dark.iter().map(|g| format!("g{g}")).collect();
+            println!("{root_path}: interior groups still unlit: {}", names.join(" "));
+        }
+        rows.push(LampRow {
+            path: root_path.clone(),
+            groups: n_groups,
+            interior_groups: interior.len(),
+            molt: omni.len(),
+            props,
+            authored,
+            synth,
+            deduped,
+            dark_molt,
+            dark_after: dark.len(),
+        });
+    }
+
+    let sum = |f: fn(&LampRow) -> usize| rows.iter().map(f).sum::<usize>();
+    println!();
+    println!("=== wmolamps: {n_roots} WMO root(s) with interior geometry or MOLT fixtures ===");
+    println!(
+        "  MOLT omni fixtures {}   MODD props {}   props with an AUTHORED light {}",
+        sum(|r| r.molt),
+        sum(|r| r.props),
+        sum(|r| r.authored),
+    );
+    println!(
+        "  props that SYNTHESISE a light {}   of which dropped by the {MODD_SYNTH_DEDUPE} yd MOLT dedupe {}   kept {}",
+        sum(|r| r.synth) + sum(|r| r.deduped),
+        sum(|r| r.deduped),
+        sum(|r| r.synth),
+    );
+    println!(
+        "  INTERIOR groups {}   claimed by no MOLT fixture {}   still unclaimed after the prop lights {}",
+        sum(|r| r.interior_groups),
+        sum(|r| r.dark_molt),
+        sum(|r| r.dark_after),
+    );
+    let header = "  root                                                        grp  int  MOLT  props  synth  dedup  darkMOLT  darkAFTER";
+    println!();
+    println!("=== landmarks ===");
+    println!("{header}");
+    for row in rows
+        .iter()
+        .filter(|r| LANDMARKS.iter().any(|l| r.path.contains(l)))
+    {
+        print_lamp_row(row);
+    }
+    let mut ranked: Vec<&LampRow> = rows.iter().filter(|r| r.dark_molt > 0).collect();
+    ranked.sort_by(|a, b| b.dark_molt.cmp(&a.dark_molt).then(b.molt.cmp(&a.molt)));
+    println!();
+    println!("=== the 25 roots with the most interior rooms no MOLT fixture reaches ===");
+    println!("{header}");
+    for row in ranked.into_iter().take(25) {
+        print_lamp_row(row);
+    }
+    Ok(())
+}
+
+fn print_lamp_row(r: &LampRow) {
+    let short = r.path.rsplit('\\').next().unwrap_or(&r.path);
+    println!(
+        "  {short:<58}  {:>3}  {:>3}  {:>4}  {:>5}  {:>5}  {:>5}  {:>8}  {:>9}",
+        r.groups, r.interior_groups, r.molt, r.props, r.synth, r.deduped, r.dark_molt, r.dark_after,
+    );
+}
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 9cf28ccb..8b284b47 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/mod.rs
@@ -32,7 +32,7 @@ mod skeleton;
 mod world;
 
 pub use geometry::{animboundscan, bbfacescan, bbscan, geosetscan, groundscan, normalscan};
-pub use lighting::{darkpropscan, m2lightscan, shadeat};
+pub use lighting::{darkpropscan, m2firescan, m2lightscan, shadeat, wmolamps, wmolights};
 pub use material::{
     alphascan, blendscan, entityuvscan, envmapscan, fxuvscan, texmodescan, uvslotscan, uvwrapscan,
 };
diff --git a/crates/benilla-formats/src/fire_light.rs b/crates/benilla-formats/src/fire_light.rs
new file mode 100644
index 00000000..b1f2cfb5
--- /dev/null
+++ b/crates/benilla-formats/src/fire_light.rs
@@ -0,0 +1,1853 @@
+//! MONKEY (fire GO lights): **synthesising** a point light for a fire prop that authors none.
+//!
+//! The mechanism the reference commits — an M2 `type == 1` light block becoming a hardware
+//! `GL_LIGHT` at the fixed `1/(0.7d + 0.03d²)` falloff (decision 0016) — is already parsed
+//! ([`crate::M2Light`]) and already spawned by every lane. The problem is the CONTENT: a
+//! client-wide sweep finds **17 of ~430** fire-ish GameObject display models authoring a light
+//! block at all. `ElwynnCampfire`, `DwarvenBrazier01`, `Large/SmallFirePit01` do; every Ogre wall
+//! torch, `HumanBrazierMagic`, `StormwindBrazier01`, `Forgebonfire`, every candle and every
+//! `OrcBonFire*` does **not**. So a torch-lined hall is drawn by its flames and lit by nothing.
+//!
+//! The flame is nevertheless fully described by the model — in its PARTICLE EMITTER. The emitter
+//! names a flame texture, blends additive, and carries the fire's own colour in its over-life ramp
+//! ([`OverLife::color`]). This module reads exactly that and derives the light the artist did not
+//! author: which emitter is the fire, what hue it burns, and how bright it should be.
+//!
+//! It lives in `benilla-formats` beside [`ParticleEmitterDef`] rather than in the asset layer that
+//! *calls* it (`benilla_assets::m2`, where the [`crate::M2Light`] is manufactured and pushed into
+//! the model's light list) for one reason: `benilla-extract`'s offline sweep — the only instrument
+//! that can audit a heuristic across 430 models — is a `benilla-formats` binary and cannot reach
+//! upward into the asset crate. One rule, one implementation, auditable offline and shipped live.
+//!
+//! **This is a synthesis, not a parse.** Nothing here is byte-verified against the reference,
+//! because the reference does not do it — a vanilla client leaves those props dark. Everything a
+//! synthesised light touches is therefore flagged (`ModelLight::synthetic`) so a consumer can
+//! refuse it: the WMO MODD prop lane does, because a building's own MOLT fixtures already light
+//! its wall torches and a second source would double them.
+
+use crate::{OverLife, ParticleBlend, ParticleEmitterDef};
+
+/// Texture-basename keys that mark an emitter as FIRE. Matched case-insensitively as substrings of
+/// the emitter texture's basename (`ITEM\…\FLAMELICKSMALL.BLP` → `FLAMELICKSMALL`).
+///
+/// The list is the shipped flame/ember/candle art vocabulary, and its exclusions matter as much as
+/// its entries: **`GLOW` is deliberately absent**. Half the runestone/crystal/portal corpus emits
+/// `GLOW*.BLP`, and admitting it would light Dalaran-blue everywhere a quest crystal sits — a glow
+/// card is a self-illuminated surface, not a fire. `SMOKE`, `SPARK` and `DUST` are absent for the
+/// same reason from the other side: they ride real fires as SECOND emitters, and letting one win
+/// would put the light at the smoke column's height in ash grey.
+pub const FIRE_TEXTURE_KEYS: [&str; 8] = [
+    "FLAMELICK", "BONFIRE", "BRAZIER", "CANDLE", "TORCH", "FLAME", "EMBER", "FIRE",
+];
+
+/// The fallback hue for a fire whose over-life ramp is all-but-white (an emitter that tints from
+/// its texture rather than its ramp): plain warm orange. Peak-normalised like every derived colour.
+pub const DEFAULT_WARM: [f32; 3] = [1.0, 0.55, 0.2];
+
+/// Below this saturation (`max−min` of the linear RGB) an over-life key is "near-white" and carries
+/// no hue worth taking. Every shipped flame's *characteristic* key clears it by a wide margin
+/// (`OgreWallTorchpurple`'s purple 0.79, `HumanBrazierMagic`'s green 0.99, the plain torch's orange
+/// 1.00), and the keys it rejects are exactly the white hot-cores and the white burn-outs that both
+/// ends of a flame ramp are usually authored as.
+const MIN_SATURATION: f32 = 0.15;
+
+/// The smallest authored particle (yards, the over-life size ramp's peak) that counts as a FLAME
+/// rather than a SPARK. Measured, not guessed: the corpus's real candles sit at 0.056–0.069
+/// (`GeneralCandelabra01`, `CandelabraTallWall01`), while the ember/exhaust trails that share their
+/// texture vocabulary — a zeppelin's `ember_grey`, a mount's `ember_offset`, the sparks on a
+/// flaming helm, a fire elemental's secondary cinders — sit at 0.019–0.028 and are the whole of the
+/// false-positive population. The floor is the one number separating the two, so it goes just under
+/// the smallest real candle.
+const MIN_FLAME_SIZE: f32 = 0.04;
+
+/// One synthesised fire light: which emitter it was derived from, plus the light itself. The caller
+/// turns this into an [`crate::M2Light`] at that emitter's model-local position/bone — **the
+/// flame**, never the model origin, or a brazier's light sits inside its own bowl and the prop
+/// self-shadows every surface it should be lighting.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct SyntheticFire {
+    /// Index into the emitter slice handed in — the winning (strongest) fire emitter.
+    pub emitter: usize,
+    /// Peak-normalised linear RGB (see [`flame_color`]).
+    pub color: [f32; 3],
+    /// The light's `diffuse_intensity` (see [`fire_intensity`]).
+    pub intensity: f32,
+    /// The size bucket the intensity came from — for the offline audit's readout only.
+    pub bucket: &'static str,
+}
+
+/// Is this model path a SPELL effect? Spell models emit flame for a second and vanish; giving them
+/// a light would strobe the world on every Fireball and blow the 256-entry point table in a raid.
+/// Matched on the path segment so `WORLD\…\SPELLSTONE.M2` can't trip it.
+pub fn is_spell_path(path: &str) -> bool {
+    let p = path.replace('/', "\\").to_ascii_uppercase();
+    p.starts_with("SPELLS\\") || p.contains("\\SPELLS\\")
+}
+
+/// `Medium/Small/TallBrazierNoOmni01` — emitter-identical twins of the lit `…Brazier01` models
+/// WITHOUT the authored M2 omni light. The first reading of the name ("the artist's dark twin,
+/// honour it as a veto") was WRONG: the May-2026 server dump places 123 of these in Orgrimmar as
+/// the city's PRIMARY street lighting (69 Medium / 32 Small / 22 Tall — `NoOmni` there means
+/// "the engine's fixed-function omni is not wanted, the flame IS the light"), and vetoing them
+/// left 106 of Orgrimmar's 129 rooms with no light source at all. So `NoOmni` is no longer a
+/// veto anywhere: the flame route still demands a real additive flame emitter, which is what
+/// separates a burning brazier from a cold one. Kept only as a name test for the offline scans
+/// (MONKEY, Orgrimmar finding 2026-09-09).
+pub fn is_no_omni(path: &str) -> bool {
+    path.rsplit(['\\', '/'])
+        .next()
+        .unwrap_or(path)
+        .to_ascii_uppercase()
+        .contains("NOOMNI")
+}
+
+/// Does this texture path name flame art? Basename, extension stripped, case-insensitive
+/// [`FIRE_TEXTURE_KEYS`] substring.
+pub fn fire_texture(texture: Option<&str>) -> bool {
+    let Some(t) = texture else { return false };
+    let base = t.rsplit(['\\', '/']).next().unwrap_or(t);
+    let stem = base.split('.').next().unwrap_or(base).to_ascii_uppercase();
+    FIRE_TEXTURE_KEYS.iter().any(|k| stem.contains(k))
+}
+
+/// The three-part emitter gate: flame ART, flame BLEND, flame SIZE.
+///
+/// The blend arm is what keeps the smoke out. Every shipped flame is additive (`3` NoAlphaAdd / `4`
+/// Add — the campfire is 4), and the same fire model's smoke column is `2` Alpha; a name gate alone
+/// admits `FIRESMOKE.BLP`-class art and puts the light up in the plume. (Additive implies
+/// `!def.lit` across nearly all of this corpus, so testing both would reject nothing while reading
+/// as if it did.)
+///
+/// The size arm ([`MIN_FLAME_SIZE`]) is what keeps the SPARKS out, and it is the one the corpus
+/// sweep added: every fire texture in the game is also used for ember trails, and a zeppelin's
+/// exhaust cinders would otherwise light Booty Bay.
+pub fn fire_emitter(def: &ParticleEmitterDef) -> bool {
+    fire_texture(def.texture.as_deref())
+        && def.blend == ParticleBlend::Add
+        && peak_size(def) >= MIN_FLAME_SIZE
+        && def.timing.peak_rate() > 0.0
+}
+
+/// The flame's colour from its over-life ramp: **the most saturated key**, peak-normalised to 1.0.
+///
+/// Not an average, and not key 0. A flame ramp is authored as *hue → hue → burnout*, and both the
+/// mean and the endpoints wash toward the white the burnout ends on: averaging
+/// `OgreWallTorchpurple`'s `(1,1,1) / (0.565,0.212,1.0) / (0.42,0,0.745)` gives a pale lilac, and
+/// key 0 gives literal white. The most-saturated key is the one an artist chose to say "this fire
+/// is purple", and taking it reproduces all three of the calibration models: purple stays purple,
+/// `HumanBrazierMagic` comes out green, the plain torch comes out orange.
+///
+/// Peak-normalising (divide by the largest channel) separates HUE from BRIGHTNESS, which is
+/// [`fire_intensity`]'s job — a dim ember and a roaring bonfire of the same hue must not differ in
+/// colour, or the intensity bucket would be applied twice.
+pub fn flame_color(over_life: &OverLife) -> [f32; 3] {
+    let sat = |k: &[f32; 4]| {
+        let (lo, hi) = k[..3]
+            .iter()
+            .fold((f32::MAX, f32::MIN), |(lo, hi), &v| (lo.min(v), hi.max(v)));
+        hi - lo
+    };
+    let best = over_life
+        .color
+        .iter()
+        .filter(|k| sat(k) >= MIN_SATURATION)
+        .max_by(|a, b| sat(a).total_cmp(&sat(b)));
+    let rgb = match best {
+        Some(k) => [k[0], k[1], k[2]],
+        None => return DEFAULT_WARM, // an all-white ramp tints from its texture; assume a fire
+    };
+    let peak = rgb[0].max(rgb[1]).max(rgb[2]);
+    if peak <= 1e-4 {
+        return DEFAULT_WARM; // a black ramp is not a colour; don't divide by it
+    }
+    [rgb[0] / peak, rgb[1] / peak, rgb[2] / peak]
+}
+
+/// The emitter's peak authored particle half-extent (the over-life size ramp's largest key, yards)
+/// — the size discriminator [`fire_intensity`] buckets on.
+pub fn peak_size(def: &ParticleEmitterDef) -> f32 {
+    def.over_life.scale.iter().copied().fold(0.0, f32::max)
+}
+
+/// The fire's "how big is this flame" score: `peak particle size × ⁴√(rate)`.
+///
+/// Size is the honest signal — a candle authors ~0.1 yd particles, a wall torch ~0.3, a brazier
+/// ~0.6, a bonfire ~1.5 — but size alone can't separate a fat, lazy two-particle-a-second ember bed
+/// from a real fire. The rate enters under a FOURTH root deliberately: emission rates range over
+/// two orders of magnitude across this corpus (2 → 200) and any stronger weighting lets a dense
+/// spark shower outrank the flame it belongs to. Used both to pick the winning emitter and to
+/// bucket its intensity.
+pub fn fire_strength(def: &ParticleEmitterDef) -> f32 {
+    peak_size(def) * def.timing.peak_rate().max(0.0).sqrt().sqrt()
+}
+
+/// Bucket a fire's [`fire_strength`] onto a light intensity, calibrated against the AUTHORED corpus
+/// so a synthesised torch sits in the same range as `MediumBrazier01`/`ElwynnCampfire` rather than
+/// out-blazing them (the authored fire family clusters at `diffuse_color (0.467,0.290,0.133)` with
+/// intensities 1–3). Returns the intensity and the bucket's name for the offline readout.
+///
+/// The cut points come off the `m2firescan` sweep, chosen so the named landmarks fall where their
+/// names say: `GeneralCandelabra01` 0.09 and `CandelabraTallWall01` 0.07 candle; `OgreWallTorch`
+/// 1.06, `StormwindBrazier01` 0.82 and `HumanBrazierMagic` 1.30 in the middle two;
+/// `Forgebonfire` 2.03 and `OrcBonFire` 3.25 at the top. Note that the middle pair is not cleanly
+/// separable by any function of the record — the ogre WALL TORCH authors a bigger flame than the
+/// Stormwind BRAZIER — which is exactly why the two buckets differ by 0.5 and not by more:
+/// misfiling between them has to be cosmetically invisible, because it will happen.
+pub fn fire_intensity(strength: f32) -> (f32, &'static str) {
+    match strength {
+        s if s < 0.25 => (0.6, "candle"),
+        s if s < 0.70 => (1.5, "torch"),
+        s if s < 1.60 => (2.0, "brazier"),
+        _ => (3.0, "bonfire"),
+    }
+}
+
+/// Derive **at most one** light for a model that authors no casting light block: pick the strongest
+/// fire emitter ([`fire_strength`]), take its hue ([`flame_color`]) and its bucket
+/// ([`fire_intensity`]). `None` when the model is a spell effect or has no fire emitter.
+///
+/// One light per model, never one per emitter. A campfire authors 3–5 emitters (core flame, licks,
+/// embers, smoke) and every one of them that passed the gate would stack a full-strength light on
+/// the same spot — five torches' worth of blaze from one campfire, and five of the 256 table slots.
+pub fn synthesize_fire_light<'a>(
+    path: &str,
+    emitters: impl IntoIterator<Item = &'a ParticleEmitterDef>,
+) -> Option<SyntheticFire> {
+    if is_spell_path(path) {
+        return None;
+    }
+    let (emitter, def, strength) = emitters
+        .into_iter()
+        .enumerate()
+        .filter(|(_, d)| fire_emitter(d))
+        .map(|(i, d)| (i, d, fire_strength(d)))
+        // A hand-rolled max rather than `max_by`, which keeps the LAST maximum on a tie: the
+        // FIRST-wins arm (`>=` on the incumbent) is what makes the pick stable when a model
+        // authors two identical flames, and the ties are real (mirrored torch pairs).
+        .fold(None, |best: Option<(usize, &ParticleEmitterDef, f32)>, cur| {
+            match best {
+                Some(b) if b.2 >= cur.2 => Some(b),
+                _ => Some(cur),
+            }
+        })?;
+    let (intensity, bucket) = fire_intensity(strength);
+    Some(SyntheticFire {
+        emitter,
+        color: flame_color(&def.over_life),
+        intensity,
+        bucket,
+    })
+}
+
+// ---------------------------------------------------------------------------------------------
+// MONKEY (lamp lights): the SECOND detection route — an emissive GEOSET, not a particle emitter.
+// ---------------------------------------------------------------------------------------------
+//
+// The flame route above reads a fire's PARTICLE EMITTER, and everything with a visible flame is
+// caught by it. A LAMPPOST is not: `StormwindStreetlamp01`, `DuskwoodLamppost`,
+// `GeneralHangingLantern01`, every `WestfallLampPost*` — none of them authors a single emitter.
+// Their glow is authored as GEOMETRY: a small glass geoset carrying the M2 material render-flag
+// `0x01` (UNLIT — "draw me at full texture brightness, ignore the sun"), usually with a second
+// additive billboard corona card over it. So the whole street-lighting corpus — the Valley of
+// Heroes, Stormwind Park, the Duskwood road — sailed straight past `fire_emitter` and lit nothing.
+//
+// The lamp route detects that shape. It is deliberately WEAKER evidence than a flame — an unlit
+// batch says "this surface is self-illuminated", not "this object emits light" — so it is fenced
+// three ways: by the model's NAME (a lamp/lantern/chandelier vocabulary), by the batch's TEXTURE
+// (glow/lamp art), and by a content-family gate that keeps it out of characters, creatures, items
+// and spell effects, where unlit additive geometry is the *norm* rather than a signal.
+//
+// The flame route always wins where both fire: it derives a real colour from the artist's own ramp,
+// whereas this route can only pick a plausible one from a name (see [`lamp_color`]).
+
+/// Model-basename keys that name a luminous prop, most specific first — the order is load-bearing,
+/// because [`lamp_kind`] classifies on the FIRST match (`DuskwoodLamppost` must read as LAMPPOST,
+/// not as the `LAMP` substring inside it; `CHANDELIER` before `CANDLE` so a chandelier is never
+/// filed on the candle rung; and `CANDELABRA` before `CANDLE` — which costs nothing here because
+/// `CANDELABRA` does not contain `CANDLE`, but the Scholomance corpus spells it both ways).
+pub const LAMP_NAME_KEYS: [&str; 13] = [
+    "CHANDELIER",
+    "CANDELABRA",
+    "LAMPPOST",
+    "LAMP POST",
+    "LIGHTPOST",
+    "STREETLAMP",
+    "STREETLIGHT",
+    "LANTERN",
+    "SCONCE",
+    "LAMP",
+    "CANDLE",
+    "BRAZIER",
+    "TORCH",
+];
+
+/// DIRECTORY words that mark a folder as a light-fixture folder. This is route (b)'s real gate.
+///
+/// The first cut of route (b) — "an unlit, transparent, glow-textured batch on any world model" —
+/// fired on 149 models, and reading the list is what wrote this constant: blood-elf BANNERS,
+/// Ghostlands TREES, PvP RUNES, Uldaman TELEPORT PADS, Booty Bay HOLOGRAMS, silithid EGGS, a
+/// Karazhan owl STATUE. Self-illuminated geometry is simply how vanilla draws "this thing is
+/// magic", and it says nothing at all about whether the thing casts light.
+///
+/// What *does* say so is where the artist filed the model. A prop under `…\Lamps\`, `…\Lanterns\`,
+/// `…\Candles\`, `…\Sconces\` or `…\Lights\` was authored as a light FIXTURE, whatever it is named
+/// (`Scholme_Candelabra`, `TS_LightPole`, `BFD_Wisp01`, `GnomeHazardLight01`). Route (b) is
+/// therefore "a fixture folder, corroborated by unlit glow geometry" — which is what it always
+/// meant, stated in the one place the corpus actually records it.
+const LAMP_DIR_KEYS: [&str; 7] = [
+    "LAMP",
+    "LANTERN",
+    "CANDLE",
+    "SCONCE",
+    "CHANDELIER",
+    "LIGHTS",
+    "TORCH",
+];
+
+/// Names that describe LIT AIR rather than a light source — god-rays, sun shafts, spotlight cones.
+/// `World\NoDXT\…\VolumetricLights\LightShaftA` sits in a `…Lights\` folder and draws exactly the
+/// unlit additive glow card route (b) looks for, but it is the *beam*, and its geoset centroid is
+/// halfway down the shaft: a point light there lights the floor from mid-air, in a spot the artist
+/// already painted bright. Eleven of them ship. Vetoed by name, on both routes.
+const BEAM_KEYS: [&str; 3] = ["SHAFT", "BEAM", "SKYLIGHT"];
+
+/// Texture-basename keys that mark a render batch's art as GLOW art. Wider than
+/// [`FIRE_TEXTURE_KEYS`] by exactly the entries that list deliberately excludes — `GLOW`, `LIGHT`,
+/// `FLARE` — because here they are read in a much narrower context: an UNLIT batch on a model that
+/// already cleared the family gate. `Glow32.blp` is the shipped corona card on half the lampposts
+/// in the game and the single most diagnostic texture in this route; on a runestone it would be a
+/// false positive, which is what [`lamp_family_ok`] is for.
+pub const GLOW_TEXTURE_KEYS: [&str; 9] = [
+    "GLOW", "LIGHT", "LAMP", "LANTERN", "FLARE", "FIRE", "FLAME", "CANDLE", "TORCH",
+];
+
+/// The BROKEN veto. The corpus ships a dark twin of nearly every lamp — `DuskwoodLamppostBroken`,
+/// `UldamanLampAndPostBusted01`, `DarnassusWreckedStreetLamp01`, `BE_lantern_busted_001`,
+/// `UldamanLampFallen`, `WesternPlaguelandsLampostStraightOff` — and a level designer places one
+/// exactly where a lit lamp is wrong (a ruined road, a sacked village). Several still carry the
+/// unlit glass geoset they inherited from the whole model, so nothing but the name tells them
+/// apart. Same logic as [`is_no_omni`]: it is the artist's own opt-out, and it is honoured.
+const BROKEN_KEYS: [&str; 7] = [
+    "BROKEN", "BUSTED", "WRECKED", "SMASHED", "DESTROY", "FALLEN", "UNLIT",
+];
+
+/// The warm-lamp default hue: an oil/candle lamp behind amber glass. Deliberately paler and less
+/// orange than [`DEFAULT_WARM`] (the open-flame default) — a lamp's light has passed through a
+/// glass shade, and a street lit at the flame's own `(1, 0.55, 0.2)` reads as a fire alarm.
+pub const DEFAULT_LAMP: [f32; 3] = [1.0, 0.72, 0.40];
+
+/// Which luminous-prop family a name lands in — the classification both [`lamp_color`] and
+/// [`lamp_intensity`] read. `None` when no [`LAMP_NAME_KEYS`] entry matches (the model then reaches
+/// the route only through its geometry, and is treated as a generic lamp).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LampKind {
+    /// A hanging multi-candle fixture: a hall's whole light source.
+    Chandelier,
+    /// A single small candle / candelabra — the dimmest rung.
+    Candle,
+    /// A lamppost, street lamp, hanging lantern or wall sconce — the population this exists for.
+    Lamp,
+    /// An open-fire BRAZIER — the authored fire family's own rung.
+    Brazier,
+    /// An open-fire TORCH — the torch rung, the same one a lamp takes.
+    Torch,
+}
+
+impl LampKind {
+    /// Is this an OPEN-FIRE container (a brazier or a torch) rather than a fixture?
+    ///
+    /// The distinction exists for exactly one rule: [`lamp_position`]'s bounding-box fallback is
+    /// refused to the fire kinds. A lamp whose glass isn't flagged unlit is still a lamp
+    /// (`UldamanLamp`, `IronForgeHangingLantern01`, `AhnQirajSconce01` — all real fixtures the
+    /// fallback rescues), but a brazier with neither a flame emitter nor one glowing polygon is a
+    /// brazier with nothing burning in it: `SummerFest_Brazier_02`, `LordaeronBrazier01`,
+    /// `UldamanBrazier01` and `IT_Brazier22` are cold props, and lighting them was the first cut of
+    /// this rule's most visible error.
+    pub fn is_fire(self) -> bool {
+        matches!(self, LampKind::Brazier | LampKind::Torch)
+    }
+}
+
+/// Which of the two synthesis routes produced a light — reported by the offline sweep, and the
+/// first thing to read when a model glows that shouldn't.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LightRoute {
+    /// The model authors a flame PARTICLE EMITTER ([`synthesize_fire_light`]).
+    Flame,
+    /// The model's NAME says lamp/lantern/chandelier ([`synthesize_lamp_light`], route a).
+    Name,
+    /// No name hit — an UNLIT render batch carrying glow art gave it away (route b).
+    Emissive,
+}
+
+impl LightRoute {
+    /// Short label for the offline readout.
+    pub fn label(self) -> &'static str {
+        match self {
+            LightRoute::Flame => "flame",
+            LightRoute::Name => "name",
+            LightRoute::Emissive => "emissive",
+        }
+    }
+}
+
+/// The model basename, extension stripped, uppercased — the string every name rule below matches.
+fn basename_stem(path: &str) -> String {
+    let base = path.rsplit(['\\', '/']).next().unwrap_or(path);
+    base.split('.').next().unwrap_or(base).to_ascii_uppercase()
+}
+
+/// Classify a model path by [`LAMP_NAME_KEYS`] (first match wins — the list is ordered).
+pub fn lamp_kind(path: &str) -> Option<LampKind> {
+    let stem = basename_stem(path);
+    let key = LAMP_NAME_KEYS.iter().find(|k| stem.contains(**k))?;
+    Some(match *key {
+        "CHANDELIER" => LampKind::Chandelier,
+        "CANDLE" | "CANDELABRA" => LampKind::Candle,
+        "BRAZIER" => LampKind::Brazier,
+        "TORCH" => LampKind::Torch,
+        _ => LampKind::Lamp,
+    })
+}
+
+/// The artist's dark twin ([`BROKEN_KEYS`]), plus the `…Off` suffix that means the same thing.
+///
+/// The suffix is tested as a SUFFIX **after the trailing serial number is stripped**, never as a
+/// substring: `Offset`, `Office` and `_offhand` would take half the corpus with them, while
+/// `CandleOff01`/`02`/`03` — which Stormwind's WMO places **65 times**, more than any other candle —
+/// only reads as extinguished once `01` comes off the end. `WesternPlaguelandsLampostStraightOff`
+/// has no serial and is caught either way. Getting this wrong put 65 lights inside one city.
+pub fn is_broken_or_off(path: &str) -> bool {
+    let stem = basename_stem(path);
+    if BROKEN_KEYS.iter().any(|k| stem.contains(k)) {
+        return true;
+    }
+    stem.trim_end_matches(|c: char| c.is_ascii_digit())
+        .trim_end_matches(['_', '-'])
+        .ends_with("OFF")
+}
+
+/// A model that draws a LIGHT BEAM rather than a light source ([`BEAM_KEYS`]).
+pub fn is_light_beam(path: &str) -> bool {
+    let stem = basename_stem(path);
+    BEAM_KEYS.iter().any(|k| stem.contains(k))
+}
+
+/// Does any DIRECTORY segment of this path name a light-fixture folder ([`LAMP_DIR_KEYS`])? The
+/// basename is excluded deliberately — that is route (a)'s job, and reading it here would make the
+/// two routes indistinguishable in the audit.
+pub fn in_lamp_dir(path: &str) -> bool {
+    let p = path.replace('/', "\\").to_ascii_uppercase();
+    let Some(dir) = p.rfind('\\').map(|i| &p[..i]) else {
+        return false;
+    };
+    LAMP_DIR_KEYS.iter().any(|k| dir.contains(k))
+}
+
+/// The content-family gate for the LAMP route: which trees may synthesise from mere unlit geometry.
+///
+/// Unlit + additive is the ordinary way to draw a highlight on a sword, a ghost's shroud, an
+/// elemental's core, a spell's flash — thousands of batches whose models emit no light in any
+/// client. Admitting them would turn every equipped weapon and every caster into a lamp. So the
+/// route is confined to placed WORLD scenery, which is the entire population it exists for:
+/// lampposts, lanterns, chandelier and sconce props. `ITEM\ObjectComponents\` is named explicitly
+/// in the exclusion because that is where the two hand-held lanterns live
+/// (`Misc_1H_Lantern_A_01`) — a carried lamp is a real light, but the FLAME route already handles
+/// the ones whose artist authored a flame, and lighting a lantern *in a bank slot* is not worth it.
+pub fn lamp_family_ok(path: &str) -> bool {
+    let p = path.replace('/', "\\").to_ascii_uppercase();
+    let world = p.starts_with("WORLD\\") || p.starts_with("DUNGEONS\\");
+    world && !p.contains("\\SPELLS\\") && !p.starts_with("ITEM\\OBJECTCOMPONENTS\\")
+}
+
+/// Does this texture path name glow art? Basename, extension stripped, case-insensitive
+/// [`GLOW_TEXTURE_KEYS`] substring — **minus** the [`BEAM_KEYS`] art, for the same reason
+/// [`is_light_beam`] exists one level up: `HazardLightBeam.blp` and `TJ_LightShaft.blp` paint the
+/// CONE a lamp throws, not the lamp. Their geometry is a long card whose centroid sits a yard or
+/// two out along the beam, so taking it as the lamp head puts the point light in mid-air beside the
+/// fixture, in the exact spot the artist already painted bright. The lamp-route twin of
+/// [`fire_texture`].
+pub fn glow_texture(texture: Option<&str>) -> bool {
+    let Some(t) = texture else { return false };
+    let base = t.rsplit(['\\', '/']).next().unwrap_or(t);
+    let stem = base.split('.').next().unwrap_or(base).to_ascii_uppercase();
+    !BEAM_KEYS.iter().any(|k| stem.contains(k))
+        && GLOW_TEXTURE_KEYS.iter().any(|k| stem.contains(k))
+}
+
+/// One render batch as the lamp route reads it — the minimum a caller must expose. Built from a
+/// [`crate::RenderSubmesh`] by the [`From`] impl below; hand-built in the tests, which is why it is
+/// a borrowed view of five fields rather than the 30-field submesh itself.
+#[derive(Debug, Clone, Copy)]
+pub struct EmissiveBatch<'a> {
+    /// The batch's resolved `.blp` path, if it carries one.
+    pub texture: Option<&'a str>,
+    /// M2 material render-flag `0x01` — **UNLIT**. The signal this route is built on.
+    pub unlit: bool,
+    /// M2 blend mode `2` (alpha) / `3` (NoAlphaAdd) / `4` (Add) — the transparent family a glow
+    /// card is drawn in. NOT required by route (a): the most common lamp shape in the corpus
+    /// (`StormwindStreetlamp01`, `DuskwoodLamppost`) authors its glass as **blend 0, unlit** —
+    /// opaque coloured glass — and gating the name route on the blend would have missed exactly the
+    /// models this was written for. Route (b) does require it, as corroboration for a nameless hit.
+    pub blended: bool,
+    /// Model-space vertices (WoW axes, Z up) — the centroid is where the light goes.
+    pub positions: &'a [[f32; 3]],
+    /// The batch's dominant bone (the mode of its per-vertex primary joint), or 0 for a boneless
+    /// batch — so an animating lamp's light can ride the joint its glass rides.
+    pub bone: u16,
+}
+
+impl<'a> From<&'a crate::RenderSubmesh> for EmissiveBatch<'a> {
+    fn from(s: &'a crate::RenderSubmesh) -> Self {
+        // The dominant bone: the most frequent PRIMARY joint across the batch's vertices. Lamp
+        // glass is a rigid 16-vertex box skinned 100 % to one bone, so this is normally unanimous;
+        // the histogram is there for the swinging hanging-lantern shapes, whose glass and chain sit
+        // on different bones and whose batches can straddle both.
+        //
+        // Skipped entirely for a LIT batch, and that is not an optimisation detail: this conversion
+        // runs at asset-load time over EVERY batch of every model that authors no light and no
+        // flame — the whole character/creature corpus included — and only an unlit batch's bone is
+        // ever read back ([`lamp_position`] returns a bone from the batch it picked, and it only
+        // picks unlit ones). A per-vertex map insert across a 5000-vertex creature, for a field
+        // nothing will look at, is load-time cost for nothing.
+        let mut best = (0u16, 0usize);
+        if s.emissive {
+            let mut counts: std::collections::BTreeMap<u16, usize> =
+                std::collections::BTreeMap::new();
+            for j in &s.joints {
+                let c = counts.entry(j[0]).or_default();
+                *c += 1;
+                if *c > best.1 {
+                    best = (j[0], *c);
+                }
+            }
+        }
+        EmissiveBatch {
+            texture: s.texture.as_deref(),
+            unlit: s.emissive,
+            blended: s.additive || matches!(s.blend, crate::ModelBlend::Blend),
+            positions: &s.positions,
+            bone: best.0,
+        }
+    }
+}
+
+/// One synthesised lamp light. The caller turns this into an [`crate::M2Light`] exactly as it does
+/// a [`SyntheticFire`] — same `position`/`bone` convention, same `synthetic: true` flag.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct SyntheticLamp {
+    /// Which route fired ([`LightRoute::Name`] / [`LightRoute::Emissive`]) — audit only.
+    pub route: LightRoute,
+    /// The batch the position came from, or `None` when it fell back to the bounding box.
+    pub batch: Option<usize>,
+    /// Model-space position of the light (WoW axes, Z up) — see [`lamp_position`].
+    pub position: [f32; 3],
+    /// The position batch's dominant bone (`0` on the bbox fallback).
+    pub bone: u16,
+    /// Peak-normalised linear RGB (see [`lamp_color`]).
+    pub color: [f32; 3],
+    /// The light's `diffuse_intensity` (see [`lamp_intensity`]).
+    pub intensity: f32,
+    /// The intensity bucket's name — for the offline readout, and so the two routes' readouts stay
+    /// directly comparable.
+    pub bucket: &'static str,
+}
+
+/// The lamp's colour. **No texture is sampled** — deliberately.
+///
+/// Decoding the glass BLP would mean IO inside a rule that has to run both in the offline sweep and
+/// in the asset loader's bake, and the answer would nearly always be the same anyway: shipped lamp
+/// glass is authored amber. So the rule is a documented table, in priority order:
+///
+/// 1. **A magic hue in the model name wins** — `NightElfLanternBlue`, `BE_lantern_red_001`,
+///    `NE_LanternBlue01`. These are the models where the default would be visibly, obviously wrong
+///    (a moonwell-blue night-elf lantern glowing orange), and the artist wrote the colour into the
+///    filename precisely because it is the point of the model.
+/// 2. **A lamp/lantern/post/sconce/chandelier/candle name** ⇒ [`DEFAULT_LAMP`] `(1.0, 0.72, 0.40)`:
+///    warm amber, softened by the glass shade it shines through.
+/// 3. **Anything else** (the nameless emissive route (b), and the brazier/torch end of the
+///    vocabulary) ⇒ [`DEFAULT_WARM`] `(1.0, 0.55, 0.2)`: open flame — the same default the particle
+///    route falls back to, so the two routes agree wherever they describe the same thing.
+pub fn lamp_color(path: &str) -> [f32; 3] {
+    let stem = basename_stem(path);
+    for (key, rgb) in [
+        ("BLUE", [0.45, 0.65, 1.0]),
+        ("GREEN", [0.40, 1.0, 0.45]),
+        ("PURPLE", [0.70, 0.40, 1.0]),
+        ("ARCANE", [0.70, 0.40, 1.0]),
+        ("RED", [1.0, 0.35, 0.25]),
+    ] {
+        if stem.contains(key) {
+            return rgb;
+        }
+    }
+    // The lamp family gets the shaded amber; a brazier/torch name gets the open-flame default.
+    if ["LAMP", "LANTERN", "POST", "SCONCE", "CANDLE", "CHANDELIER"]
+        .iter()
+        .any(|k| stem.contains(k))
+    {
+        DEFAULT_LAMP
+    } else {
+        DEFAULT_WARM
+    }
+}
+
+/// Bucket a lamp onto the SAME intensity rungs the flame route uses (0.6 / 1.5 / 2.0 / 3.0), so the
+/// downstream reach table (`benilla_world::lighting::m2_light_reach`, which buckets 0.6 → 6 yd,
+/// 1.5 → 12, 2.0 → 16, 3.0 → 24) needs no new rung and a synthesised lamp sits in the same range as
+/// an authored `MediumBrazier01`.
+///
+/// - A **chandelier** is a hall's whole light source (a dozen candles on one fixture) and a
+///   **brazier** is the authored corpus's own 2.0: the brazier rung, 2.0 / 16 yd.
+/// - A **candle** is one flame in a glass: the candle rung, 0.6 / 6 yd.
+/// - Everything else — lamppost, street lamp, hanging lantern, sconce, torch — is the torch rung,
+///   1.5 / 12 yd. That is the number the whole feature turns on: a Valley of Heroes lamppost throws
+///   12 yd, which reaches the road under it and the wall beside it without crossing the canal.
+///
+/// Nothing here reaches the 3.0 bonfire rung. A lamp is not a bonfire, and a synthesised light that
+/// out-blazes `Forgebonfire` would be visibly wrong in exactly the place it is most looked at.
+pub fn lamp_intensity(kind: Option<LampKind>) -> (f32, &'static str) {
+    match kind {
+        Some(LampKind::Chandelier) => (2.0, "chandelier"),
+        Some(LampKind::Candle) => (0.6, "candle"),
+        // A brazier lands on the authored fire family's own rung; a torch on the torch rung. Both
+        // reach here only WITH glowing geometry (see [`LampKind::is_fire`]), so this one is lit.
+        Some(LampKind::Brazier) => (2.0, "brazier"),
+        Some(LampKind::Torch) => (1.5, "torch"),
+        _ => (1.5, "lamp"),
+    }
+}
+
+/// Pick the batch whose centroid is the light's position, and the position itself.
+///
+/// **Not the model origin.** A lamppost's origin is at its BASE, on the ground: a light there is
+/// buried inside the post, lights the cobbles in a ring around the foot of the pole, and (on the
+/// torch-shadow lane, which includes the prop's own caster mesh) shadows everything the lamp is
+/// supposed to be illuminating. The glass is 4–5 yd up. That vertical offset is the whole feature.
+///
+/// The pick, in order:
+/// 1. The UNLIT batch carrying GLOW art with the most vertices — the glass box (16 verts) rather
+///    than the additive corona card (4 verts, a billboard whose two triangles say much less about
+///    where the lamp head actually is).
+/// 2. Failing that, any unlit batch — a name-route hit whose glass carries unrecognised art.
+/// 3. Failing that, the model's bounding-box TOP CENTRE `(cx, cy, zmax)` — but ONLY when `bbox_ok`
+///    (see [`LampKind::Fire`]: a cold brazier is refused it). A name-route hit with no unlit
+///    geometry is a lamp whose head cannot be located from the geometry; the top of its box is the
+///    least-wrong guess for a pole-shaped prop, and the sweep reports it as a fallback. It is the
+///    right answer more often than it looks — `StormwindCanalLamp01` is one 21 yd batch whose lamp
+///    head is its own bbox top — and merely *high* on a hanging lantern, whose box top is the
+///    ceiling hook a yard above the glass.
+pub fn lamp_position(
+    batches: &[EmissiveBatch<'_>],
+    bounds: Option<([f32; 3], [f32; 3])>,
+    bbox_ok: bool,
+) -> Option<(Option<usize>, [f32; 3], u16)> {
+    let centroid = |b: &EmissiveBatch| {
+        let n = b.positions.len() as f32;
+        let s = b
+            .positions
+            .iter()
+            .fold([0.0f32; 3], |a, p| [a[0] + p[0], a[1] + p[1], a[2] + p[2]]);
+        [s[0] / n, s[1] / n, s[2] / n]
+    };
+    let pick = |glow_only: bool| {
+        batches
+            .iter()
+            .enumerate()
+            .filter(|(_, b)| {
+                b.unlit && !b.positions.is_empty() && (!glow_only || glow_texture(b.texture))
+            })
+            .max_by_key(|(_, b)| b.positions.len())
+    };
+    if let Some((i, b)) = pick(true).or_else(|| pick(false)) {
+        return Some((Some(i), centroid(b), b.bone));
+    }
+    if !bbox_ok {
+        return None;
+    }
+    let (lo, hi) = bounds?;
+    Some((None, [(lo[0] + hi[0]) * 0.5, (lo[1] + hi[1]) * 0.5, hi[2]], 0))
+}
+
+/// Derive **at most one** light for a model that authors neither a casting light block nor a flame
+/// emitter, from its NAME and/or its emissive geometry. `None` for everything else.
+///
+/// Two routes, evaluated in that order:
+///
+/// - **(a) NAME.** The basename matches [`LAMP_NAME_KEYS`]. This is the route the whole street-lamp
+///   corpus takes, and it does not require the geometry to prove anything — `StormwindStreetlamp01`
+///   authors its glass as an *opaque* unlit batch, which no blend-mode test would admit.
+/// - **(b) EMISSIVE.** No name hit, but the model sits in a light-FIXTURE FOLDER ([`in_lamp_dir`])
+///   AND carries an UNLIT batch that is also in the transparent family (blend 2/3/4) AND whose
+///   texture is glow art ([`GLOW_TEXTURE_KEYS`]). This is the "lamp glass without a lamp name"
+///   catcher — `Scholme_Candelabra`, `TS_LightPole`, `GnomeHazardLight01`, `BFD_Wisp01`: fixtures
+///   named after their building or their species rather than after the thing. It is much the
+///   STRICTER of the two, because unlit glow geometry on its own means nothing at all (the sweep's
+///   first cut lit blood-elf banners, Ghostlands trees, PvP runes and a Karazhan owl statue).
+///
+/// Vetoed throughout: spell effects ([`is_spell_path`]), light BEAMS ([`is_light_beam`]), the
+/// artist's dark twins ([`is_broken_or_off`]; `NoOmni` is NOT one — see [`is_no_omni`]) and everything outside placed world
+/// scenery ([`lamp_family_ok`]).
+pub fn synthesize_lamp_light(
+    path: &str,
+    batches: &[EmissiveBatch<'_>],
+    bounds: Option<([f32; 3], [f32; 3])>,
+) -> Option<SyntheticLamp> {
+    if is_spell_path(path)
+        || is_broken_or_off(path)
+        || is_light_beam(path)
+        || !lamp_family_ok(path)
+    {
+        return None;
+    }
+    let kind = lamp_kind(path);
+    let route = if kind.is_some() {
+        LightRoute::Name
+    } else if in_lamp_dir(path)
+        && batches
+            .iter()
+            .any(|b| b.unlit && b.blended && glow_texture(b.texture))
+    {
+        LightRoute::Emissive
+    } else {
+        return None;
+    };
+    // The bounding-box fallback is for FIXTURES, not fire containers — see [`LampKind::is_fire`].
+    let bbox_ok = !kind.is_some_and(LampKind::is_fire);
+    let (batch, position, bone) = lamp_position(batches, bounds, bbox_ok)?;
+    let (intensity, bucket) = lamp_intensity(kind);
+    Some(SyntheticLamp {
+        route,
+        batch,
+        position,
+        bone,
+        color: lamp_color(path),
+        intensity,
+        bucket,
+    })
+}
+
+// ---------------------------------------------------------------------------------------------
+// MONKEY (spell light): the THIRD route — a SPELL EFFECT's emitter, which the two above veto.
+// ---------------------------------------------------------------------------------------------
+//
+// `is_spell_path` turns every `SPELLS\` model away from both routes above, and the reason it gives
+// is sound for the WORLD lane it was written for: a spell model burns for a second and vanishes,
+// and a placed-scenery light table that churned at cast rate would blow its budget on nothing. But
+// the *content* is exactly the same shape — an additive emitter with a colour ramp — and a
+// Fireball that flies over a night road lighting nothing is the reference's own hole, not a
+// decision. So the spell corpus gets its own route, with the constraints the world route lacks:
+// the light is ENTITY-scoped (it lives and dies with the effect instance, never enters the placed
+// lane — see `ModelLight::spell`), it is BUDGETED (the app's `SPELL_LIGHTS_MAX`), and it is
+// CLASSIFIED — because only some schools of magic are LUMINOUS.
+//
+// That last part is the user's rule and it is a physical one: fire burns, holy light shines, fel
+// fire burns green. Frost, nature, arcane and shadow do not emit — a Frostbolt is cold, Entangling
+// Roots is a plant, a Shadow Bolt is the ABSENCE of light and lighting the road with it would be
+// absurd. [`SpellLightKind`] is that judgement, and it is made from the model's NAME first (the
+// artists named the whole corpus by school) and from the winning emitter's HUE second (the
+// unnamed remainder — `Spells\Clouds8x8.blp` is the whole game's smoke and flame both).
+//
+// The emitter gate is deliberately WIDER than the world route's [`fire_emitter`]: a spell's flame
+// art is not the `FLAMELICK`/`TORCH` vocabulary at all (a Fireball's core is `Clouds8x8`, a
+// firework is `STAR5A`, Holy Light is `Clouds8x8Fade` — none of them a [`FIRE_TEXTURE_KEYS`] hit).
+// The texture therefore cannot be the gate here; ADDITIVE + a real particle size is, and the
+// school decides the rest.
+
+/// The flat gain on every synthesised SPELL light, folded into the intensity at synthesis. `1.0`
+/// = "a spell light sits on the same rungs a torch does", which is the calibration the reach
+/// buckets downstream ([`crate::room_claim::m2_light_reach`]) are built on. It is a `const` and
+/// not a cvar on purpose (this pass adds none); a live `spellLightGain` belongs beside
+/// `fireLightGain` in the packer, not here.
+pub const SPELL_LIGHT_GAIN: f32 = 1.0;
+
+/// The HOLY fallback hue: a warm white with a gold cast. Used when a holy effect's ramp yields no
+/// usable key, which is the common case rather than the exception — Holy Light's strongest emitter
+/// ramps `warm-gold (a 0) -> white (a 0.13) -> acid yellow (a 0)`, so the only key anyone ever SEES
+/// is the white one and the only SATURATED one is invisible. Taking the ramp literally there gives
+/// a yellow-green flash for the paladin's signature heal; this is the colour the effect reads as.
+pub const DEFAULT_HOLY: [f32; 3] = [1.0, 0.95, 0.78];
+
+/// The FEL fallback hue: warlock green. Same role as [`DEFAULT_HOLY`] for the demonic family,
+/// whose art is green fire — the imp's Firebolt, Fel Fire Nova, a Felhunter's sacrifice.
+pub const DEFAULT_FEL: [f32; 3] = [0.45, 1.0, 0.30];
+
+/// Which luminous school a spell effect belongs to — the whole yes/no of this route, and the
+/// user's stated rule: **fire, holy light and fel burn; frost, nature, arcane and shadow do not.**
+///
+/// The kind decides only WHETHER a light is derived and what its FALLBACK hue is; the light's
+/// actual colour still comes from the artist's own over-life ramp wherever the ramp has one
+/// ([`spell_color`]), so a blue firework lights blue even though its kind is `Fire`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SpellLightKind {
+    /// Burning: fireball, immolate, fire nova, a firework's powder, a rocket's exhaust.
+    Fire,
+    /// Radiant: Holy Light, Smite, a blessing, a resurrection — white-gold.
+    Holy,
+    /// Demonic green fire: the imp's flame, Fel Fire Nova, Hellfire's ring.
+    Fel,
+    /// Emits nothing. Frost, nature, arcane, shadow — and everything unrecognised, because the
+    /// safe answer for an effect we cannot name is the reference's own behaviour (no light).
+    None,
+}
+
+impl SpellLightKind {
+    /// Does this school light the world at all?
+    pub fn lights(self) -> bool {
+        !matches!(self, SpellLightKind::None)
+    }
+
+    /// The hue to use when the emitter's ramp yields none ([`spell_color`] returned `None`).
+    pub fn default_color(self) -> [f32; 3] {
+        match self {
+            SpellLightKind::Holy => DEFAULT_HOLY,
+            SpellLightKind::Fel => DEFAULT_FEL,
+            _ => DEFAULT_WARM,
+        }
+    }
+
+    /// Short label for the offline readout / trace.
+    pub fn label(self) -> &'static str {
+        match self {
+            SpellLightKind::Fire => "fire",
+            SpellLightKind::Holy => "holy",
+            SpellLightKind::Fel => "fel",
+            SpellLightKind::None => "none",
+        }
+    }
+}
+
+/// The NAME rules, **in evaluation order — first match wins, and the order is the whole design**.
+///
+/// The dark schools come FIRST because their names collide with the luminous ones and the collision
+/// is always resolved the same way: `LightningBoltIvus` contains `LIGHT` (holy) and must not be
+/// one — `LIGHTNING` ahead of it takes it; `Starfire` and `FaerieFire` contain `FIRE` and are
+/// druid/nature effects whose art is a green-white glow, not a flame; `ShadowFlame` contains
+/// `FLAME` and is shadow. Putting the vetoes first means a new luminous key can never accidentally
+/// re-admit one of them.
+///
+/// After the vetoes the luminous keys run. Note `FIRE` catches `FIREWORK`, `FIRECRACKER`,
+/// `SOULFIRE`, `HELLFIRE`, `RAINOFFIRE`, `FIREBALL`, `FIREBOLT` and `FIREBLAST` in one entry,
+/// which is why the list is this short: the artists named the corpus by school already.
+const SPELL_NAME_RULES: [(&str, SpellLightKind); 32] = [
+    // --- the dark schools, and the name collisions they must win ---
+    ("LIGHTNING", SpellLightKind::None),
+    ("STARFIRE", SpellLightKind::None),
+    ("FAERIE", SpellLightKind::None),
+    ("SHADOW", SpellLightKind::None),
+    ("FROST", SpellLightKind::None),
+    ("ICE", SpellLightKind::None),
+    ("FREEZE", SpellLightKind::None),
+    ("CHILL", SpellLightKind::None),
+    ("BLIZZ", SpellLightKind::None),
+    ("SNOW", SpellLightKind::None),
+    ("WINTER", SpellLightKind::None),
+    ("NATURE", SpellLightKind::None),
+    ("THUNDER", SpellLightKind::None),
+    ("WRATH", SpellLightKind::None),
+    ("ENTANGL", SpellLightKind::None),
+    ("POISON", SpellLightKind::None),
+    ("ARCANE", SpellLightKind::None),
+    ("POLYMORPH", SpellLightKind::None),
+    ("CURSE", SpellLightKind::None),
+    ("FEAR", SpellLightKind::None),
+    ("DRAIN", SpellLightKind::None),
+    ("DEATHCOIL", SpellLightKind::None),
+    // --- the luminous schools ---
+    ("FIRE", SpellLightKind::Fire),
+    ("FLAME", SpellLightKind::Fire),
+    ("IMMOLAT", SpellLightKind::Fire),
+    ("PYRO", SpellLightKind::Fire),
+    ("INCINER", SpellLightKind::Fire),
+    ("LAVA", SpellLightKind::Fire),
+    ("HOLY", SpellLightKind::Holy),
+    ("DIVINE", SpellLightKind::Holy),
+    ("SMITE", SpellLightKind::Holy),
+    ("FEL", SpellLightKind::Fel),
+];
+
+/// The school named by the model's **full path**, uppercased — `None` when no rule matches (the
+/// hue then decides, [`spell_hue_kind`]).
+///
+/// Matched on the whole path and not just the basename, because the corpus nests by family
+/// (`SPELLS\Enchantments\Shaman_Fire.m2`) and a directory naming the school is exactly as
+/// authoritative as a file naming it.
+pub fn spell_name_kind(path: &str) -> Option<SpellLightKind> {
+    let p = path.replace('/', "\\").to_ascii_uppercase();
+    SPELL_NAME_RULES
+        .iter()
+        .find(|(k, _)| p.contains(k))
+        .map(|&(_, kind)| kind)
+}
+
+/// The school of an **unnamed** effect, from the colour its winning emitter burns.
+///
+/// Deliberately conservative — an unrecognised effect defaults to dark, so every arm here has to
+/// EARN its light:
+/// - **Fel** — green-dominant and saturated. The imp's flame is green fire.
+/// - **Holy** — bright and near-white with at most a warm cast (`r` close to `g`, both high, blue
+///   not above green). A white-gold flash is holy; a white-BLUE one is frost's burnout, refused by
+///   keeping blue under green.
+/// - **Fire** — warm and descending (`r >= g >= b`) with a real red-to-blue spread. That is a
+///   flame ramp and nothing else here: frost is blue-dominant, nature green-dominant, shadow
+///   desaturated-dark, arcane violet (`r` close to `b` above `g`, which the `b <= g` clause
+///   rejects).
+pub fn spell_hue_kind(c: [f32; 3]) -> SpellLightKind {
+    let (r, g, b) = (c[0], c[1], c[2]);
+    if g > r && g > b && g - r.max(b) > 0.25 {
+        return SpellLightKind::Fel; // green fire
+    }
+    if r >= 0.75 && g >= 0.75 && b <= g && (r - g).abs() <= 0.25 {
+        return SpellLightKind::Holy; // white / white-gold
+    }
+    if r >= 0.5 && g <= r && b <= g && r - b >= 0.35 {
+        return SpellLightKind::Fire; // orange-red
+    }
+    SpellLightKind::None
+}
+
+/// The spell route's emitter gate: ADDITIVE, a real particle size, and a rate that ever rises.
+///
+/// No texture test — see the module note: the spell corpus's flame art is `Clouds8x8`, `STAR5A`,
+/// `FLARE` and `lensflare1`, none of which is in the world route's flame vocabulary, and a
+/// texture gate here would light nothing at all. [`MIN_FLAME_SIZE`] is shared with the world route
+/// and does the same job it does there: it keeps SPARK emitters (0.02–0.03 yd) from being mistaken
+/// for the flame they trail.
+pub fn spell_emitter(def: &ParticleEmitterDef) -> bool {
+    def.blend == ParticleBlend::Add
+        && peak_size(def) >= MIN_FLAME_SIZE
+        && def.timing.peak_rate() > 0.0
+}
+
+/// An over-life ramp's peak additive weight — the `A` channel's largest key. A spell emitter whose
+/// every key is transparent is drawn as nothing and must not decide the light.
+pub fn peak_alpha(def: &ParticleEmitterDef) -> f32 {
+    def.over_life.color.iter().map(|k| k[3]).fold(0.0, f32::max)
+}
+
+/// Which emitter of a spell model IS the effect: `peak size × sqrt(rate) × peak alpha`.
+///
+/// Three factors, each answering a way a naive pick took the WRONG emitter on a real model:
+/// - **size** — the honest one, as in [`fire_strength`].
+/// - **sqrt(rate)** — a burst of 300 is a bigger event than a trickle of 10, but under a square
+///   root so a dense spark shower can't outrank the flame. (The world route's FOURTH root is tuned
+///   for steady props; a spell's whole vocabulary is bursts, and the fourth root flattens them.)
+/// - **peak alpha** — the one this route adds, and the one that gets fireworks right. Every
+///   firework model authors a pale muzzle FLASH at `a 0.39` beside its coloured BURST at `a 1.0`;
+///   size and rate alone crown the flash, and `Fireworks_Blue` then lights the sky pale yellow.
+pub fn spell_strength(def: &ParticleEmitterDef) -> f32 {
+    peak_size(def) * def.timing.peak_rate().max(0.0).sqrt() * peak_alpha(def)
+}
+
+/// The effect's colour: the ramp key with the largest **saturation × additive weight**,
+/// peak-normalised. `None` when no key is both saturated and visible.
+///
+/// The `× alpha` is the difference from [`flame_color`], and it is not a refinement — it is the
+/// rule. A spell ramp is authored `invisible hue -> VISIBLE colour -> invisible burnout`, i.e. its
+/// most saturated key is routinely one drawn at `a 0`: Fireball's tail ramps to pure red at
+/// `a 0.16` while it BURNS gold at `a 1.0`, and Holy Light's acid-yellow burnout is authored at
+/// `a 0` throughout. Weighting by the additive weight asks "what colour is actually on screen",
+/// which is the only question a light derived from it can be answering.
+///
+/// The floor is a QUARTER of [`MIN_SATURATION`], not the whole of it: the world route's floor is
+/// applied to a ramp key at full opacity, and applying the same number to a product that already
+/// carries the alpha would reject every faint-but-coloured spell key (Holy Light's tinted cloud
+/// sits at `a 0.09`).
+pub fn spell_color(over_life: &OverLife) -> Option<[f32; 3]> {
+    let score = |k: &[f32; 4]| {
+        let (lo, hi) = k[..3]
+            .iter()
+            .fold((f32::MAX, f32::MIN), |(lo, hi), &v| (lo.min(v), hi.max(v)));
+        (hi - lo) * k[3]
+    };
+    let best = over_life
+        .color
+        .iter()
+        .filter(|k| score(k) >= MIN_SATURATION * 0.25)
+        .max_by(|a, b| score(a).total_cmp(&score(b)))?;
+    let peak = best[0].max(best[1]).max(best[2]);
+    (peak > 1e-4).then(|| [best[0] / peak, best[1] / peak, best[2] / peak])
+}
+
+/// Bucket a spell light onto the shared intensity rungs (`m2_light_reach`: 0.6 -> 6 yd, 1.5 -> 12,
+/// 2.0 -> 16) from the winning emitter's **particle size**, promoted one rung by a BURST.
+///
+/// Size and not [`spell_strength`], because the strength score exists to RANK emitters within one
+/// model and its rate term saturates across models: every spell emitter runs 50–500/s, so a
+/// strength bucket would file Holy Light, Fireball and a firework on the same top rung. Size
+/// separates them as authored — a missile's core is 0.4–0.8 yd, a nova's cloud 1.1, a spark 0.05.
+///
+/// The burst promotion is what gets a firework to the brazier rung its 16 yd shell deserves: a
+/// `>= 100/s` rate is a detonation, not a flame, and its light should reach further than its
+/// (small) particles suggest. Nothing here reaches the 3.0 bonfire rung — a spell must not
+/// out-blaze a forge.
+pub fn spell_intensity(size: f32, rate: f32) -> (f32, &'static str) {
+    let (intensity, bucket) = match size {
+        s if s < 0.25 => (0.6, "candle"),
+        s if s < 0.75 => (1.5, "torch"),
+        _ => (2.0, "brazier"),
+    };
+    match (rate >= 100.0, bucket) {
+        (true, "candle") => (1.5, "torch"),
+        (true, "torch") => (2.0, "brazier"),
+        _ => (intensity, bucket),
+    }
+}
+
+/// When the emitter's rate track first reaches half its peak, in seconds from the sequence start —
+/// the light's **onset**, i.e. how long after the effect spawns the flame it stands for exists.
+///
+/// A firework is the whole reason this is read. `G_Firework03Red` is a ~0.7 s model whose shell
+/// only detonates at `t = 0.567` (`rate 0 -> 200` there); `SPELLS\Fireworks_Blue` bursts at 1.5 s.
+/// A light lit at spawn flashes the rocket's flight, which is exactly backwards. Everything with a
+/// constant rate — every missile, every kit glow — answers `0.0` and is unaffected.
+pub fn emit_onset(def: &ParticleEmitterDef) -> f32 {
+    let peak = def.timing.peak_rate();
+    if peak <= 0.0 {
+        return 0.0;
+    }
+    def.timing
+        .slot_views()
+        .first()
+        .and_then(|(_, rate, _)| *rate)
+        .and_then(|keys| {
+            keys.iter()
+                .find(|&&(_, v)| v >= peak * 0.5)
+                .map(|&(t, _)| t.max(0.0))
+        })
+        .unwrap_or(0.0)
+}
+
+/// One synthesised spell light — the same shape as [`SyntheticFire`], plus the school it was
+/// judged to be and the onset its emitter's rate track names.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct SyntheticSpell {
+    /// Index into the emitter slice handed in — the winning ([`spell_strength`]) emitter. The
+    /// caller takes that emitter's model-space position and bone, exactly as the flame route does.
+    pub emitter: usize,
+    /// The school ([`SpellLightKind`]) — never [`SpellLightKind::None`] here (that is a `None`).
+    pub kind: SpellLightKind,
+    /// Peak-normalised linear RGB ([`spell_color`], else the kind's default).
+    pub color: [f32; 3],
+    /// The light's `diffuse_intensity` ([`spell_intensity`] × [`SPELL_LIGHT_GAIN`]).
+    pub intensity: f32,
+    /// The intensity bucket's name — readout only, comparable with the other two routes'.
+    pub bucket: &'static str,
+    /// Seconds from the instance's birth before the light comes up ([`emit_onset`]).
+    pub onset: f32,
+}
+
+/// Is this model a FIREWORK — one of the `World\Goober\G_Firework0*` GameObject shells, or the
+/// `SPELLS\Firework*` / `Firecracker` family?
+///
+/// They are the one luminous population that is NOT under `SPELLS\` (the GameObject shells live in
+/// `World\Goober\`), so without this the user's "fireworks" case would be exactly half done: the
+/// spell-cast rockets would light and the Darkmoon show would not.
+///
+/// The LAUNCHER is excluded deliberately. `G_FireworkLauncher01` is permanent scenery that plays
+/// its muzzle flash on trigger; every lane here keys its light to the INSTANCE's birth, so a
+/// launcher would flash once when it streamed in and then stand dark forever — a light that is
+/// wrong in both directions. Its rockets do the lighting.
+pub fn is_firework_path(path: &str) -> bool {
+    let p = path.replace('/', "\\").to_ascii_uppercase();
+    !p.contains("LAUNCHER")
+        && (p.contains("FIREWORK") || p.contains("FIRECRACKER") || p.contains("ROMANCANDLE"))
+}
+
+/// Should this model take the SPELL route rather than the two world ones? `SPELLS\` content and
+/// the firework family, and nothing else — see [`is_spell_path`] / [`is_firework_path`].
+pub fn is_spell_light_path(path: &str) -> bool {
+    is_spell_path(path) || is_firework_path(path)
+}
+
+/// Derive **at most one** light for a spell effect / firework model: pick the strongest emitter
+/// ([`spell_strength`]), judge its school (NAME first, then HUE — a name rule always wins, so a
+/// frost effect with one red spark stays dark), and take its colour, bucket and onset.
+///
+/// `None` when the model is not spell content, authors no additive emitter, or belongs to a school
+/// that does not emit light — which is the great majority of the corpus, and is the point.
+///
+/// One light per model, for the reason the flame route gives: a Fireball authors four emitters and
+/// every one of them that passed would stack a full light on the same spot.
+///
+/// (No bounding box is read, unlike [`synthesize_lamp_light`]: an effect model has no "where is
+/// the lamp head" problem — its emitter IS the flame, and its position is authored.)
+pub fn synthesize_spell_light<'a>(
+    path: &str,
+    emitters: impl IntoIterator<Item = &'a ParticleEmitterDef>,
+) -> Option<SyntheticSpell> {
+    if !is_spell_light_path(path) {
+        return None;
+    }
+    let (emitter, def, _) = emitters
+        .into_iter()
+        .enumerate()
+        .filter(|(_, d)| spell_emitter(d))
+        .map(|(i, d)| (i, d, spell_strength(d)))
+        // First-wins on a tie, as in [`synthesize_fire_light`] — mirrored emitter pairs are real
+        // here too (a firework shell authors three identical bursts on three bones).
+        .fold(None, |best: Option<(usize, &ParticleEmitterDef, f32)>, cur| {
+            match best {
+                Some(b) if b.2 >= cur.2 => Some(b),
+                _ => Some(cur),
+            }
+        })?;
+    let ramp = spell_color(&def.over_life);
+    // The NAME wins over the HUE wherever both speak: an artist naming a model `Frostbolt` has
+    // said more about it than one warm key in its ramp has. The hue decides for the unnamed
+    // remainder only, and it defaults to dark.
+    let kind =
+        spell_name_kind(path).unwrap_or_else(|| ramp.map_or(SpellLightKind::None, spell_hue_kind));
+    if !kind.lights() {
+        return None;
+    }
+    let (intensity, bucket) = spell_intensity(peak_size(def), def.timing.peak_rate());
+    Some(SyntheticSpell {
+        emitter,
+        kind,
+        color: ramp.unwrap_or_else(|| kind.default_color()),
+        intensity: intensity * SPELL_LIGHT_GAIN,
+        bucket,
+        onset: emit_onset(def),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{CellRamp, EmitParams, EmitTiming, ParamsNow, ParticleShape};
+
+    /// A minimal emitter def — only the fields the fire rule reads carry meaning.
+    fn def(
+        texture: Option<&str>,
+        blend: ParticleBlend,
+        keys: [[f32; 4]; 3],
+        size: f32,
+        rate: f32,
+    ) -> ParticleEmitterDef {
+        ParticleEmitterDef {
+            flags: 0,
+            position: [0.0, 0.0, 1.0],
+            bone: 0,
+            shape: ParticleShape::Plane,
+            blend,
+            lit: false,
+            texture: texture.map(str::to_string),
+            tile_rows: 1,
+            tile_cols: 1,
+            head_tail: 0,
+            timing: EmitTiming::constant(rate),
+            params: EmitParams::constant(ParamsNow::default()),
+            drag: 0.0,
+            tail_time: 0.0,
+            spline: None,
+            geometry_model: None,
+            recursion_model: None,
+            angular_velocity_min: [0.0; 3],
+            angular_velocity_max: [0.0; 3],
+            inherit_scale: 0.0,
+            follow_speed1: 0.0,
+            follow_scale1: 0.0,
+            follow_speed2: 0.0,
+            follow_scale2: 0.0,
+            twinkle_speed: 0.0,
+            twinkle_percent: 1.0,
+            twinkle_min: 0.0,
+            twinkle_max: 0.0,
+            spin: 0.0,
+            over_life: OverLife {
+                mid: 0.5,
+                color: keys,
+                scale: [size; 3],
+                head_cells: [CellRamp::new(0, 0); 2],
+                tail_cells: [CellRamp::new(0, 0); 2],
+                repeat: [1.0; 2],
+            },
+        }
+    }
+
+    fn close(a: [f32; 3], b: [f32; 3]) -> bool {
+        a.iter().zip(b).all(|(x, y)| (x - y).abs() < 2e-3)
+    }
+
+    /// GOLDEN — the colour rule on the three REAL ramps the heuristic was calibrated against
+    /// (dumped with `benilla-extract m2part`). Each is authored white-cored, so key 0 or a mean
+    /// would wash all three to the same pale nothing; the most-saturated key recovers the hue the
+    /// artist painted, and peak-normalising strips the brightness out of it.
+    #[test]
+    fn flame_color_takes_the_most_saturated_key() {
+        // OgreWallTorchpurple — FLAMELICKSMALLMAGICBLUE: white → violet → deep violet.
+        let purple = def(
+            Some("WORLD\\GENERIC\\OGRE\\TORCHES\\FLAMELICKSMALLMAGICBLUE.BLP"),
+            ParticleBlend::Add,
+            [
+                [1.0, 1.0, 1.0, 1.0],
+                [0.565, 0.212, 1.0, 1.0],
+                [0.42, 0.0, 0.745, 1.0],
+            ],
+            0.3,
+            20.0,
+        );
+        assert!(close(flame_color(&purple.over_life), [0.565, 0.212, 1.0]));
+
+        // OgreWallTorch — FLAMELICKSMALL: orange → tan → white burnout.
+        let warm = def(
+            Some("ITEM\\OBJECTCOMPONENTS\\FLAMELICKSMALL.BLP"),
+            ParticleBlend::Add,
+            [
+                [1.0, 0.282, 0.0, 1.0],
+                [0.875, 0.541, 0.184, 1.0],
+                [1.0, 1.0, 1.0, 1.0],
+            ],
+            0.3,
+            20.0,
+        );
+        assert!(close(flame_color(&warm.over_life), [1.0, 0.282, 0.0]));
+
+        // HumanBrazierMagic — FLAMELICK: green → pale green → near white.
+        let green = def(
+            Some("INTERFACE\\GLUES\\FLAMELICK.BLP"),
+            ParticleBlend::Add,
+            [
+                [0.0, 0.988, 0.0, 1.0],
+                [0.486, 0.976, 0.51, 1.0],
+                [0.851, 1.0, 0.843, 1.0],
+            ],
+            0.6,
+            30.0,
+        );
+        assert!(close(flame_color(&green.over_life), [0.0, 1.0, 0.0]));
+
+        // An all-white ramp carries no hue at all — the warm default, not white light.
+        let white = def(
+            Some("FIRE.BLP"),
+            ParticleBlend::Add,
+            [[1.0, 1.0, 1.0, 1.0]; 3],
+            0.3,
+            20.0,
+        );
+        assert_eq!(flame_color(&white.over_life), DEFAULT_WARM);
+    }
+
+    /// GOLDEN — the DETECTOR: flame art plus additive blend, and every near-miss that must stay
+    /// out. `GLOW` is the load-bearing exclusion (crystals/runestones), smoke is caught by blend.
+    #[test]
+    fn detector_admits_flames_and_refuses_the_near_misses() {
+        let keys = [[1.0, 0.3, 0.0, 1.0]; 3];
+        let fire = |t: Option<&str>, b| def(t, b, keys, 0.3, 20.0);
+
+        assert!(fire_emitter(&fire(Some("X\\FLAMELICKSMALL.BLP"), ParticleBlend::Add)));
+        assert!(fire_emitter(&fire(Some("X\\CANDLEFLAME.BLP"), ParticleBlend::Add)));
+        assert!(fire_emitter(&fire(Some("X\\TORCHFIRE.BLP"), ParticleBlend::Add)));
+        // Art that is not fire.
+        assert!(!fire_emitter(&fire(Some("X\\GLOW.BLP"), ParticleBlend::Add)));
+        assert!(!fire_emitter(&fire(Some("X\\SPELLGLOW32.BLP"), ParticleBlend::Add)));
+        assert!(!fire_emitter(&fire(Some("X\\SMOKE01.BLP"), ParticleBlend::Add)));
+        assert!(!fire_emitter(&fire(None, ParticleBlend::Add)));
+        // Fire art on a NON-additive emitter is the same model's smoke plume, not its flame.
+        assert!(!fire_emitter(&fire(
+            Some("X\\FIRESMOKE.BLP"),
+            ParticleBlend::Alpha
+        )));
+        // A dead emitter (zero rate) is not a light source.
+        assert!(!fire_emitter(&def(
+            Some("X\\FLAMELICK.BLP"),
+            ParticleBlend::Add,
+            keys,
+            0.3,
+            0.0
+        )));
+        // A SPARK — fire art, additive, but a 0.025 yd particle: a zeppelin's exhaust cinders, a
+        // flaming helm's glitter, a fire elemental's secondary embers. Below the flame floor.
+        assert!(!fire_emitter(&def(
+            Some("X\\EMBER_OFFSET.BLP"),
+            ParticleBlend::Add,
+            keys,
+            0.025,
+            200.0
+        )));
+        // A real candle clears it by a hair — the floor's whole calibration.
+        assert!(fire_emitter(&def(
+            Some("X\\FLAMELICKSMALL.BLP"),
+            ParticleBlend::Add,
+            keys,
+            0.056,
+            6.0
+        )));
+    }
+
+    /// GOLDEN — one light per model, from the STRONGEST fire emitter, and never for a spell.
+    #[test]
+    fn one_light_from_the_strongest_emitter() {
+        let embers = def(
+            Some("X\\EMBER.BLP"),
+            ParticleBlend::Add,
+            [[1.0, 0.2, 0.0, 1.0]; 3],
+            0.08,
+            40.0,
+        );
+        let flame = def(
+            Some("X\\FLAMELICKLARGE.BLP"),
+            ParticleBlend::Add,
+            [[0.2, 0.4, 1.0, 1.0]; 3],
+            1.4,
+            60.0,
+        );
+        let smoke = def(
+            Some("X\\FIRESMOKE.BLP"),
+            ParticleBlend::Alpha,
+            [[0.5, 0.5, 0.5, 1.0]; 3],
+            2.0,
+            10.0,
+        );
+        let got = synthesize_fire_light("WORLD\\GOBER\\BONFIRE.M2", [&embers, &flame, &smoke])
+            .expect("a fire");
+        assert_eq!(got.emitter, 1, "the big flame wins, not the ember shower");
+        assert!(close(got.color, [0.2, 0.4, 1.0]));
+        assert_eq!(got.bucket, "bonfire");
+        assert_eq!(got.intensity, 3.0);
+
+        // The candle end of the scale lands in its own bucket.
+        let candle = def(
+            Some("X\\CANDLEFLAME.BLP"),
+            ParticleBlend::Add,
+            [[1.0, 0.5, 0.1, 1.0]; 3],
+            0.06,
+            8.0,
+        );
+        let got = synthesize_fire_light("WORLD\\GOBER\\CANDLE.M2", [&candle]).expect("a fire");
+        assert_eq!(got.bucket, "candle");
+
+        // A spell effect never synthesises, however fiery — it would strobe the point table.
+        assert_eq!(
+            synthesize_fire_light("SPELLS\\FIREBALL_MISSILE.M2", [&flame]),
+            None
+        );
+        // The `NoOmni` twin DOES synthesise — it is Orgrimmar's street lighting (123 placed);
+        // only the absence of a flame emitter keeps a brazier cold.
+        assert!(
+            synthesize_fire_light("World\\Generic\\Orc\\Braziers\\TallBrazierNoOmni01.m2", [&flame])
+                .is_some()
+        );
+        assert_eq!(synthesize_fire_light("WORLD\\X.M2", [&smoke]), None);
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // MONKEY (lamp lights): the emissive-geoset route.
+    // -----------------------------------------------------------------------------------------
+
+    /// A minimal render-batch view. `positions` is handed in by the caller because
+    /// [`EmissiveBatch`] borrows it — a lamp's glass is a 16-vertex box, and only its centroid and
+    /// its vertex count are ever read.
+    fn batch<'a>(
+        texture: Option<&'a str>,
+        unlit: bool,
+        blended: bool,
+        positions: &'a [[f32; 3]],
+    ) -> EmissiveBatch<'a> {
+        EmissiveBatch {
+            texture,
+            unlit,
+            blended,
+            positions,
+            bone: 0,
+        }
+    }
+
+    /// GOLDEN — route (a), the NAME hit, on the model the whole feature was written for.
+    /// `StormwindStreetlamp01` (40 placements inside the Stormwind WMO) authors NO particle
+    /// emitter at all and draws its glass **opaque + unlit** — blend 0 — so neither the flame rule
+    /// nor any blend-mode test sees it. The light must land on the glass at z ≈ 4.35, four yards
+    /// above the post's own origin at the base: that vertical offset IS the fix.
+    #[test]
+    fn name_route_lights_a_lamppost_at_its_glass() {
+        let post: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.0], [0.5, 0.0, 4.0], [-0.5, 0.0, 2.0]];
+        let glass: Vec<[f32; 3]> = vec![
+            [0.5, 0.5, 4.1],
+            [-0.5, 0.5, 4.1],
+            [0.5, -0.5, 4.6],
+            [-0.5, -0.5, 4.6],
+        ];
+        let batches = [
+            batch(Some("X\\STREETLAMP.BLP"), false, false, &post),
+            batch(Some("DUNGEONS\\STORMWINDLAMPGLASS.BLP"), true, false, &glass),
+        ];
+        let got = synthesize_lamp_light(
+            "World\\Generic\\Human\\Passive Doodads\\Lamps\\StormwindStreetlamp01.m2",
+            &batches,
+            Some(([-0.6, -0.6, 0.0], [0.6, 0.6, 4.9])),
+        )
+        .expect("a lamppost");
+        assert_eq!(got.route, LightRoute::Name);
+        assert_eq!(got.batch, Some(1), "the glass, not the post");
+        assert!(
+            (got.position[2] - 4.35).abs() < 1e-3,
+            "the light rides the glass, not the origin: {:?}",
+            got.position
+        );
+        assert_eq!(got.color, DEFAULT_LAMP);
+        assert_eq!((got.intensity, got.bucket), (1.5, "lamp"));
+    }
+
+    /// GOLDEN — route (b), the NAMELESS hit: a fixture-folder model whose name says nothing
+    /// (`Scholme_Candelabra`-shaped), carried entirely by its unlit + transparent + glow-textured
+    /// batch. All three signals are required, and the folder is the load-bearing one.
+    #[test]
+    fn emissive_route_needs_a_fixture_folder_and_all_three_signals() {
+        let body: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.0]];
+        let flame: Vec<[f32; 3]> = vec![[0.0, 0.0, 1.0], [0.2, 0.0, 1.4]];
+        let path = "World\\Lordaeron\\Scholomance\\PassiveDoodads\\Candles\\Scholme_Wax03.m2";
+
+        let hit = [
+            batch(Some("X\\WAX.BLP"), false, false, &body),
+            batch(Some("X\\GENERICGLOW64.BLP"), true, true, &flame),
+        ];
+        let got = synthesize_lamp_light(path, &hit, None).expect("a fixture");
+        assert_eq!(got.route, LightRoute::Emissive);
+        assert_eq!(got.batch, Some(1));
+        assert!((got.position[2] - 1.2).abs() < 1e-3, "{:?}", got.position);
+        // No name to classify on ⇒ the generic lamp rung and the open-flame default hue.
+        assert_eq!((got.intensity, got.bucket), (1.5, "lamp"));
+        assert_eq!(got.color, DEFAULT_WARM);
+
+        // The same geometry filed OUTSIDE a fixture folder is a blood-elf banner / a Ghostlands
+        // tree / a PvP rune — the 149-model false-positive population the folder gate removed.
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\Expansion01\\Doodads\\Generic\\BloodElf\\Banners\\BE_Banner02.m2",
+                &hit,
+                None
+            ),
+            None
+        );
+        // In the folder, but the batch is LIT (no 0x01) — ordinary painted geometry.
+        let lit = [batch(Some("X\\GENERICGLOW64.BLP"), false, true, &flame)];
+        assert_eq!(synthesize_lamp_light(path, &lit, None), None);
+        // In the folder and unlit, but OPAQUE (blend 0): no corroboration for a nameless hit.
+        let opaque = [batch(Some("X\\GENERICGLOW64.BLP"), true, false, &flame)];
+        assert_eq!(synthesize_lamp_light(path, &opaque, None), None);
+        // In the folder, unlit and transparent, but the art is not glow art.
+        let plain = [batch(Some("X\\WOOD01.BLP"), true, true, &flame)];
+        assert_eq!(synthesize_lamp_light(path, &plain, None), None);
+    }
+
+    /// GOLDEN — the NEAR-MISSES that must stay dark. Each one shipped, each one reached the first
+    /// cut of the rule, and each one would have been visible as a wrongly glowing object.
+    #[test]
+    fn lamp_route_refuses_the_near_misses() {
+        let verts: Vec<[f32; 3]> = vec![[0.0, 0.0, 1.0], [0.0, 0.0, 2.0]];
+        let glow = [batch(Some("X\\GLOW32.BLP"), true, true, &verts)];
+        let bbox = Some(([-1.0, -1.0, 0.0], [1.0, 1.0, 3.0]));
+
+        // A GLOW card on a model that is not a fixture and not in a fixture folder: the whole
+        // magic-prop corpus (runestones, jewels, holograms, teleport pads, banners, trees).
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\Expansion01\\Doodads\\Generic\\BloodElf\\RuneStone\\BE_Runestone01.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        // A light BEAM in a `…Lights\` folder — lit air, not a source. Its centroid is mid-shaft.
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\NoDXT\\Generic\\PassiveDoodads\\VolumetricLights\\LightShaftA.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        // The artist's extinguished twin — `CandleOff01`, which Stormwind's WMO places 65 times.
+        // The serial number has to come off before the `OFF` suffix is read.
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\Generic\\PassiveDoodads\\Lights\\CandleOff01.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\Generic\\Human\\Passive Doodads\\LampPosts\\DuskwoodLamppostBroken.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        assert_eq!(
+            synthesize_lamp_light(
+                "world\\expansion07\\doodads\\dungeon\\doodads\\8du_waycrest_candlestand01_unlit.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        // A COLD brazier: a fire container with no flame emitter and not one glowing polygon. The
+        // bounding-box fallback is refused to it, so it stays dark.
+        let cold: Vec<[f32; 3]> = vec![[0.0, 0.0, 0.5]];
+        let plain = [batch(Some("X\\METAL01.BLP"), false, false, &cold)];
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\KhazModan\\Uldaman\\PassiveDoodads\\Braziers\\UldamanBrazier01.m2",
+                &plain,
+                bbox
+            ),
+            None
+        );
+        // …while a LAMP with the same unflagged geometry keeps the fallback: `UldamanLamp`,
+        // `IronForgeHangingLantern01`, `AhnQirajSconce01` are real fixtures whose glass simply
+        // isn't flagged, and the box top is the least-wrong guess for a pole-shaped prop.
+        let lamp = synthesize_lamp_light(
+            "World\\KhazModan\\Uldaman\\PassiveDoodads\\Lamps\\UldamanLamp.m2",
+            &plain,
+            bbox,
+        )
+        .expect("a lamp");
+        assert_eq!(lamp.batch, None, "the bbox fallback");
+        assert_eq!(lamp.position, [0.0, 0.0, 3.0], "box top centre");
+        // A fixture folder whose only unlit card is the BEAM it throws (`HazardLightBeam.blp`):
+        // the cone, not the source, and its centroid is a yard out along the beam.
+        let beam = [batch(Some("X\\HAZARDLIGHTBEAM.BLP"), true, true, &verts)];
+        assert!(!glow_texture(Some("X\\HAZARDLIGHTBEAM.BLP")));
+        assert_eq!(
+            synthesize_lamp_light(
+                "World\\Generic\\Gnome\\Passive Doodads\\HazardLights\\GnomeHazardLight01.m2",
+                &beam,
+                bbox
+            ),
+            None
+        );
+        // Outside placed world scenery entirely — a carried lantern, a spell, an item.
+        assert_eq!(
+            synthesize_lamp_light(
+                "Item\\ObjectComponents\\Weapon\\Misc_1H_Lantern_A_01.m2",
+                &glow,
+                bbox
+            ),
+            None
+        );
+        assert_eq!(
+            synthesize_lamp_light("SPELLS\\Lantern_Impact.m2", &glow, bbox),
+            None
+        );
+    }
+
+    /// GOLDEN — the kind/colour/intensity table: the three rungs, and the magic-hue override that
+    /// the artist wrote into the filename precisely because the warm default would be wrong there.
+    #[test]
+    fn lamp_kind_colour_and_intensity() {
+        assert_eq!(lamp_kind("x\\KarazanChandelier_01.m2"), Some(LampKind::Chandelier));
+        assert_eq!(lamp_kind("x\\Scholme_Candelabra.m2"), Some(LampKind::Candle));
+        assert_eq!(lamp_kind("x\\SkullCandle01.m2"), Some(LampKind::Candle));
+        assert_eq!(lamp_kind("x\\DuskwoodLamppost.m2"), Some(LampKind::Lamp));
+        assert_eq!(lamp_kind("x\\GeneralHangingLantern01.m2"), Some(LampKind::Lamp));
+        assert_eq!(lamp_kind("x\\UldamanBrazier01.m2"), Some(LampKind::Brazier));
+        assert_eq!(lamp_kind("x\\NA_Torch01.m2"), Some(LampKind::Torch));
+        assert_eq!(lamp_kind("x\\BE_Banner02.m2"), None);
+
+        assert_eq!(lamp_intensity(Some(LampKind::Chandelier)), (2.0, "chandelier"));
+        assert_eq!(lamp_intensity(Some(LampKind::Candle)), (0.6, "candle"));
+        assert_eq!(lamp_intensity(Some(LampKind::Lamp)), (1.5, "lamp"));
+        assert_eq!(lamp_intensity(None), (1.5, "lamp"));
+
+        // Every rung must be one the reach table already knows (6 / 12 / 16 / 24 yd).
+        for k in [
+            None,
+            Some(LampKind::Chandelier),
+            Some(LampKind::Candle),
+            Some(LampKind::Brazier),
+            Some(LampKind::Torch),
+        ] {
+            let i = lamp_intensity(k).0;
+            assert!([0.6f32, 1.5, 2.0, 3.0].contains(&i), "off-rung intensity {i}");
+        }
+
+        assert_eq!(lamp_color("x\\StormwindStreetlamp01.m2"), DEFAULT_LAMP);
+        assert_eq!(lamp_color("x\\NE_LanternBlue01.m2"), [0.45, 0.65, 1.0]);
+        assert_eq!(lamp_color("x\\BE_lantern_red_001.m2"), [1.0, 0.35, 0.25]);
+        assert_eq!(lamp_color("x\\Scholme_GreenCandelabra.m2"), [0.40, 1.0, 0.45]);
+        // No lamp word at all ⇒ the open-flame default, shared with the particle route.
+        assert_eq!(lamp_color("x\\Scholme_Wax03.m2"), DEFAULT_WARM);
+    }
+
+    // -----------------------------------------------------------------------------------------
+    // MONKEY (spell light): the THIRD route's tests. Every ramp below is a REAL one, dumped with
+    // `benilla-extract m2part` off the shipped model named in the comment — the rules were
+    // calibrated against these and nothing else.
+    // -----------------------------------------------------------------------------------------
+
+    /// GOLDEN — the classification table, school by school, on the models the user named. The
+    /// LUMINOUS half must light and the DARK half must not; nothing else about the feature matters
+    /// if this table is wrong.
+    #[test]
+    fn spell_school_decides_who_lights() {
+        // Fireball's winning emitter (the shockwave tail): gold -> red -> red, all additive.
+        let fireball = def(
+            Some("Creature\\Spells\\Shockwave4white.blp"),
+            ParticleBlend::Add,
+            [
+                [1.0, 0.847, 0.0, 1.0],
+                [0.98, 0.02, 0.0, 1.0],
+                [1.0, 0.0, 0.0, 0.161],
+            ],
+            0.833,
+            36.0,
+        );
+        let fire = synthesize_spell_light("Spells\\Fireball_Missile_High.m2", [&fireball])
+            .expect("a fireball burns");
+        assert_eq!(fire.kind, SpellLightKind::Fire);
+        // The colour is the key that is actually ON SCREEN (gold at full alpha), not the pure red
+        // burnout the world route's most-saturated rule would have taken.
+        assert!(close(fire.color, [1.0, 0.847, 0.0]));
+        assert_eq!(fire.bucket, "brazier"); // a 0.83 yd core
+
+        // Frostbolt — blue/cyan, and NAMED frost: dark twice over.
+        let frostbolt = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [
+                [0.384, 0.106, 0.957, 0.671],
+                [0.106, 0.435, 0.929, 0.502],
+                [0.71, 0.871, 0.984, 0.0],
+            ],
+            0.3167,
+            60.0,
+        );
+        assert_eq!(synthesize_spell_light("Spells\\Frostbolt.m2", [&frostbolt]), None);
+
+        // Holy Light's strongest emitter: every saturated key is authored INVISIBLE, so the ramp
+        // yields nothing and the holy default (warm white) stands in. A most-saturated-key rule
+        // would flash the paladin acid yellow.
+        let holy = def(
+            Some("Spells\\Clouds8x8Fade.blp"),
+            ParticleBlend::Add,
+            [
+                [1.0, 0.729, 0.302, 0.0],
+                [1.0, 1.0, 1.0, 0.133],
+                [0.965, 1.0, 0.0, 0.0],
+            ],
+            1.111,
+            10.0,
+        );
+        let light = synthesize_spell_light("Spells\\HolyLight_Impact_Head.m2", [&holy])
+            .expect("holy light shines");
+        assert_eq!(light.kind, SpellLightKind::Holy);
+        assert_eq!(light.color, DEFAULT_HOLY);
+
+        // Shadow Bolt — shadow is the ABSENCE of light, whatever its ramp says. This ramp is the
+        // violet one; the NAME is what settles it either way.
+        let shadow = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [[0.4, 0.0, 0.6, 1.0], [0.2, 0.0, 0.4, 1.0], [0.1, 0.0, 0.2, 0.0]],
+            0.5,
+            60.0,
+        );
+        assert_eq!(
+            synthesize_spell_light("Spells\\ShadowBolt_Missile.m2", [&shadow]),
+            None
+        );
+
+        // Entangling Roots / Wrath — nature. Named, so no hue can rescue them.
+        let green = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [[0.2, 1.0, 0.2, 1.0]; 3],
+            0.5,
+            40.0,
+        );
+        assert_eq!(
+            synthesize_spell_light("Spells\\EntanglingRoots_State.m2", [&green]),
+            None
+        );
+        assert_eq!(synthesize_spell_light("Spells\\Wrath_Missile.m2", [&green]), None);
+
+        // The imp's Firebolt: NAMED fire (the `FIRE` key), and its green ramp still supplies the
+        // colour — a green flame is a flame with odd chemistry, exactly as the world route holds.
+        let imp = synthesize_spell_light("Spells\\FireBolt_Missile_Low.m2", [&green])
+            .expect("the imp's flame burns");
+        assert_eq!(imp.kind, SpellLightKind::Fire);
+        assert!(close(imp.color, [0.2, 1.0, 0.2]));
+
+        // …and the demonic family reached by NAME rather than by flame: `Fel_FireNova`.
+        assert_eq!(
+            synthesize_spell_light("Spells\\Fel_FireNova_Area.m2", [&green])
+                .expect("fel fire burns")
+                .kind,
+            // `FIRE` precedes `FEL` in the table and both light — the kind is a label here, and
+            // the light is identical either way.
+            SpellLightKind::Fire
+        );
+    }
+
+    /// GOLDEN — FIREWORKS, both families, and the emitter pick that gets their colour right.
+    ///
+    /// `Fireworks_Blue_01` authors a pale yellow muzzle FLASH beside its blue SHELL. The flash is
+    /// smaller but faster; only the alpha term in [`spell_strength`] puts the shell on top, and
+    /// without it the user's "coloured burst" is a yellow one.
+    #[test]
+    fn a_firework_lights_in_its_own_colour() {
+        // SPELLS\Fireworks_Blue_01 #1 — the blue shell (0.667 yd, 50/s, opaque).
+        let shell = def(
+            Some("ITEM\\OBJECTCOMPONENTS\\WEAPON\\FLARE.BLP"),
+            ParticleBlend::Add,
+            [
+                [0.753, 0.949, 1.0, 1.0],
+                [0.078, 0.337, 1.0, 1.0],
+                [0.157, 0.631, 1.0, 0.0],
+            ],
+            0.667,
+            50.0,
+        );
+        // …and #0, the pale flash: smaller, twice the rate.
+        let flash = def(
+            Some("ITEM\\OBJECTCOMPONENTS\\WEAPON\\FLARE.BLP"),
+            ParticleBlend::Add,
+            [
+                [0.941, 0.98, 0.678, 0.392],
+                [0.953, 0.918, 0.525, 0.392],
+                [0.973, 0.965, 0.796, 0.0],
+            ],
+            0.444,
+            100.0,
+        );
+        let fw = synthesize_spell_light("SPELLS\\Fireworks_Blue_01.m2", [&flash, &shell])
+            .expect("a firework burns");
+        assert_eq!(fw.kind, SpellLightKind::Fire);
+        assert_eq!(fw.emitter, 1, "the SHELL wins, not the flash");
+        assert!(close(fw.color, [0.078, 0.337, 1.0]));
+
+        // The GameObject family is NOT under `SPELLS\` and reaches the route by name alone.
+        let red = def(
+            Some("SPELLS\\STAR5A.BLP"),
+            ParticleBlend::Add,
+            [
+                [0.698, 0.0, 0.0, 1.0],
+                [0.922, 0.0, 0.0, 1.0],
+                [0.875, 0.176, 0.176, 0.0],
+            ],
+            0.611,
+            200.0,
+        );
+        let go = synthesize_spell_light("World\\Goober\\G_Firework03Red.m2", [&red])
+            .expect("the Darkmoon show burns");
+        assert!(close(go.color, [1.0, 0.0, 0.0]));
+        // 0.61 yd is the torch rung; the 200/s detonation promotes it to the brazier's 16 yd.
+        assert_eq!(go.bucket, "brazier");
+
+        // The LAUNCHER is scenery, not a firework: it must stay dark (it would otherwise flash
+        // once on stream-in and never again).
+        assert!(!is_firework_path("World\\Goober\\G_FireworkLauncher01.m2"));
+        assert!(is_firework_path("World/Goober/G_Firework01Blue.m2"));
+    }
+
+    /// GOLDEN — the NAME rules beat the HUE rules, which is the asymmetry the whole table rests
+    /// on: an artist's filename is evidence about the SCHOOL, a ramp key is evidence about one
+    /// particle. The three collisions below are all real shipped names.
+    #[test]
+    fn a_name_beats_a_hue() {
+        assert_eq!(
+            spell_name_kind("SPELLS\\LightningBoltIvus_Missile.m2"),
+            Some(SpellLightKind::None),
+            "LIGHTNING must not read as LIGHT"
+        );
+        assert_eq!(
+            spell_name_kind("SPELLS\\Starfire_Area.m2"),
+            Some(SpellLightKind::None),
+            "a druid's Starfire is not a fire"
+        );
+        assert_eq!(
+            spell_name_kind("Spells\\FaerieFire_Impact.m2"),
+            Some(SpellLightKind::None)
+        );
+        assert_eq!(
+            spell_name_kind("Spells\\HolyLight_Impact_Head.m2"),
+            Some(SpellLightKind::Holy)
+        );
+        assert_eq!(spell_name_kind("Spells\\Immolate_State.m2"), Some(SpellLightKind::Fire));
+        assert_eq!(spell_name_kind("Spells\\ArcaneExplosion_Base.m2"), Some(SpellLightKind::None));
+        assert_eq!(spell_name_kind("Spells\\Doomguard_Summon.m2"), None); // hue decides
+
+        // A FROST effect carrying one warm spark stays dark — the name arm is unconditional.
+        let spark = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [[1.0, 0.4, 0.0, 1.0]; 3],
+            0.5,
+            60.0,
+        );
+        assert_eq!(synthesize_spell_light("Spells\\FrostNova_Base.m2", [&spark]), None);
+        // …the same emitter under an unnamed model lights, by hue alone.
+        assert_eq!(
+            synthesize_spell_light("Spells\\Doomguard_Summon.m2", [&spark])
+                .expect("a warm unnamed effect burns")
+                .kind,
+            SpellLightKind::Fire
+        );
+    }
+
+    /// The hue classifier's own table — the arms that must NOT fire are the point of it.
+    #[test]
+    fn the_hue_classifier_defaults_to_dark() {
+        assert_eq!(spell_hue_kind([1.0, 0.55, 0.2]), SpellLightKind::Fire);
+        assert_eq!(spell_hue_kind([1.0, 0.95, 0.78]), SpellLightKind::Holy);
+        assert_eq!(spell_hue_kind([0.2, 1.0, 0.2]), SpellLightKind::Fel);
+        assert_eq!(spell_hue_kind([0.1, 0.44, 0.93]), SpellLightKind::None, "frost");
+        assert_eq!(spell_hue_kind([0.71, 0.87, 0.98]), SpellLightKind::None, "ice white-blue");
+        assert_eq!(spell_hue_kind([0.7, 0.4, 1.0]), SpellLightKind::None, "arcane violet");
+        assert_eq!(spell_hue_kind([0.3, 0.3, 0.3]), SpellLightKind::None, "grey");
+    }
+
+    /// The gates: a non-spell path never reaches the route (the world routes own it), a
+    /// non-additive or spark-sized emitter never wins it, and an emitter-less model yields
+    /// nothing.
+    #[test]
+    fn the_spell_gate_refuses_everything_else() {
+        let flame = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [[1.0, 0.4, 0.0, 1.0]; 3],
+            0.5,
+            60.0,
+        );
+        assert_eq!(
+            synthesize_spell_light("World\\Goober\\ElwynnCampfire.m2", [&flame]),
+            None,
+            "a placed campfire is the FLAME route's, not this one's"
+        );
+        let smoke = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Alpha,
+            [[1.0, 0.4, 0.0, 1.0]; 3],
+            0.5,
+            60.0,
+        );
+        assert_eq!(synthesize_spell_light("Spells\\Fire_Nova.m2", [&smoke]), None);
+        let sparks = def(
+            Some("Spells\\Clouds8x8.blp"),
+            ParticleBlend::Add,
+            [[1.0, 0.4, 0.0, 1.0]; 3],
+            0.02,
+            60.0,
+        );
+        assert_eq!(synthesize_spell_light("Spells\\Fire_Nova.m2", [&sparks]), None);
+        assert_eq!(synthesize_spell_light("Spells\\Fire_Nova.m2", []), None);
+        // A constant-rate emitter has no fuse: the light is up at t=0.
+        assert_eq!(emit_onset(&flame), 0.0);
+    }
+
+    /// The reach ladder, and the burst promotion that puts a firework shell on the brazier rung.
+    #[test]
+    fn spell_reach_buckets_on_size_and_burst() {
+        assert_eq!(spell_intensity(0.08, 20.0), (0.6, "candle"));
+        assert_eq!(spell_intensity(0.5, 50.0), (1.5, "torch"));
+        assert_eq!(spell_intensity(1.1, 10.0), (2.0, "brazier"));
+        // A detonation is promoted exactly one rung, and the top rung stays the brazier's:
+        // nothing a spell does may out-blaze a forge.
+        assert_eq!(spell_intensity(0.08, 300.0), (1.5, "torch"));
+        assert_eq!(spell_intensity(0.5, 200.0), (2.0, "brazier"));
+        assert_eq!(spell_intensity(1.1, 500.0), (2.0, "brazier"));
+    }
+}
diff --git a/crates/benilla-formats/src/lib.rs b/crates/benilla-formats/src/lib.rs
index 875cce89..153c527f 100644
--- a/crates/benilla-formats/src/lib.rs
+++ b/crates/benilla-formats/src/lib.rs
@@ -229,6 +229,22 @@ pub use particles::{
     parse_m2_particle_emitters, CellRamp, OverLife, OverLifeSample, ParticleBlend,
     ParticleEmitterDef, ParticleShape, SplineData,
 };
+// MONKEY (fire GO lights): the SYNTHESISED-light rule for fire props that author no light block —
+// derived from the model's own flame emitter. Beside `particles` because that is its whole input.
+pub mod fire_light;
+pub use fire_light::{synthesize_fire_light, SyntheticFire};
+// MONKEY (lamp lights): the SECOND route in that same module — an emissive lamp/lantern
+// GEOSET rather than a flame emitter (a lamppost authors no particles at all).
+pub use fire_light::{synthesize_lamp_light, EmissiveBatch, LightRoute, SyntheticLamp};
+// MONKEY (spell light): the THIRD route in that same module — a SPELL EFFECT's / FIREWORK's
+// emitter, which the two above veto outright. Fire, holy and fel burn; frost, nature, arcane and
+// shadow emit nothing at all.
+pub use fire_light::{is_spell_light_path, synthesize_spell_light, SpellLightKind, SyntheticSpell};
+// MONKEY (portal claims): which ROOMS one fixture may light -- containment, MOLR, and one portal
+// hop. Shared by the runtime spawner and the `wmolights`/`wmolamps` audits so the gate the shader
+// enforces and the gate the instrument prints can never be two different rules.
+pub mod room_claim;
+pub use room_claim::{claim_groups, room_claims, Claim, ClaimHow, PortalGraph};
 mod ribbons;
 pub use ribbons::{parse_m2_ribbon_emitters, RibbonEmitterDef, RibbonVisibility};
 mod value_track;
diff --git a/crates/benilla-formats/src/room_claim.rs b/crates/benilla-formats/src/room_claim.rs
new file mode 100644
index 00000000..e2a2d825
--- /dev/null
+++ b/crates/benilla-formats/src/room_claim.rs
@@ -0,0 +1,948 @@
+//! MONKEY (portal claims): **which rooms one light fixture may light** — the single rule, shared by
+//! the runtime spawner (`benilla_world::terrain_stream::spawn`'s MOLT and MODD-prop lanes, which
+//! turn it into the per-light claim list the room gate packs) and the offline audit
+//! (`benilla-extract wmolights` / `wmolamps`, which is the only instrument that can measure it
+//! across the shipped corpus). One rule, one implementation — the `fire_light` precedent.
+//!
+//! The gate itself lives in `static_gx.wgsl`: a WMO surface of group `G` takes an interior fixture
+//! only if that fixture's claim set contains `G`. The set has three sources, in this priority:
+//!
+//! 1. **CONTAINMENT** — the interior groups whose authored MOGI bounding box holds the fixture.
+//!    The dense supplement to the sparse MOLR relation (the Goldshire inn authors a MOLR on 2 of
+//!    its 12 groups; Northshire abbey leaves 7 of 14 unnamed), ordered TIGHTEST BOX FIRST so the
+//!    room a fixture actually stands in outranks the building-spanning shell that also contains it.
+//! 2. **MOLR** — the groups whose authored light-ref list names the fixture. Authored for the
+//!    reference's own purpose (register a GL light while drawing a visible group's doodads), which
+//!    is why it cannot carry the gate alone, but it is the artist speaking and it is never wrong.
+//! 2b. **SPLIT-FLOOR SIBLINGS** (MONKEY (split-floor claims)) — the group across a portal too
+//!    LARGE to be a doorway ([`SPLIT_PORTAL_MIN_AREA`]): one room the artist cut in two for
+//!    rendering. It joins the base at weight 1, because there is no threshold between the halves
+//!    to fade across — see [`ClaimHow::Split`].
+//! 3. **PORTAL-ADJACENT** — the groups up to [`ROOM_CLAIM_HOPS`] portal hops from a claimed group,
+//!    when the doorways lie within the fixture's effective radius. This is the "light crosses an
+//!    open doorway" rule: without it a fixture stops dead at its room's edge and a continuous floor
+//!    changes brightness in a straight line at the group boundary, which is exactly the seam the
+//!    owner reported. Nearest portal first, so a doorway three rooms away never takes the slot a
+//!    doorway in this wall wants.
+//!
+//! MONKEY (soft portal claims): a portal claim is **not binary**. It carries the doorway it came
+//! through ([`Claim::fade_center`]/[`Claim::fade_slack`]) and the reach left over on the far side
+//! ([`Claim::fade_radius`]), and the shader turns those into a WEIGHT in `[0, 1]` — 1 in the
+//! doorway, 0 where the reach runs out. That is what actually closes the seam: a binary claim
+//! merely moved the step from "this room" to "the last room the hop reached", and admitting a
+//! fixture on one side of a group plane while refusing it on the other is a step wherever the
+//! FLOOR crosses that plane, which is precisely what a doorway is. Containment and MOLR claims
+//! stay hard (weight 1) — a fixture standing in a room lights all of it.
+//!
+//! Sources 1+2 are the **base**: they must never be truncated (a dropped containment claim is a
+//! black room, and the packer's overflow arm deliberately fails OPEN for that reason). Source 3 only
+//! ever fills slots the base left free — a dropped portal claim is one doorway that does not carry
+//! light, which is the behaviour we already had.
+
+use crate::{WmoGroupInfo, WmoPortalInfo, WmoPortalRef};
+
+/// Claims one fixture can carry. **Must equal `benilla_world::lighting::ROOM_CLAIM_MAX` and
+/// `ROOM_CLAIM_MAX` in `static_gx.wgsl`** — past it the packer gives up and packs the fixture
+/// UNGATED, so a claim list built here longer than this is not a wider gate, it is no gate at all.
+pub const ROOM_CLAIM_MAX: usize = 6;
+
+/// The portal graph of ONE WMO root, as the claim rule reads it: the MOPV vertex pool, the MOPT
+/// portal records (each a slice of that pool plus its plane), the MOPR edges, and the per-group
+/// slice of those edges (`MOGP +0x24/+0x26`, i.e. [`crate::WmoGroupHeader::portal_ref_start`] /
+/// `portal_ref_count`) indexed by ABSOLUTE group index. All in WMO model space, WoW axes — the same
+/// space [`WmoGroupInfo`]'s boxes and a MOLT record's position are in, which is why the whole rule
+/// can run before anything is placed in the world.
+#[derive(Clone, Copy, Default)]
+pub struct PortalGraph<'a> {
+    pub vertices: &'a [[f32; 3]],
+    pub infos: &'a [WmoPortalInfo],
+    pub refs: &'a [WmoPortalRef],
+    pub slices: &'a [(u16, u16)],
+}
+
+/// How a group came to be claimed — the audit's readout, and the reason the list is ordered.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum ClaimHow {
+    /// The group's MOGI box contains the fixture.
+    Contains,
+    /// The group's MOLR names the fixture.
+    Molr,
+    /// One portal hop from a claimed group, the portal within the fixture's reach.
+    Portal,
+    /// MONKEY (split-floor claims): the group on the far side of a portal too LARGE to be a
+    /// doorway ([`SPLIT_PORTAL_MIN_AREA`]) — one half of a room the artist SPLIT for rendering.
+    /// Ranks and behaves as a BASE claim: hard (weight 1 everywhere), hop 0, and part of the
+    /// wavefront the portal walk seeds from.
+    Split,
+}
+
+impl ClaimHow {
+    pub fn tag(self) -> &'static str {
+        match self {
+            ClaimHow::Contains => "in",
+            ClaimHow::Molr => "molr",
+            ClaimHow::Portal => "portal",
+            ClaimHow::Split => "split",
+        }
+    }
+}
+
+/// One claimed group.
+#[derive(Clone, Copy, Debug)]
+pub struct Claim {
+    pub group: u16,
+    pub how: ClaimHow,
+    /// Yards from the fixture to the portal it came through ([`ClaimHow::Portal`] only; 0 else).
+    pub distance: f32,
+    /// The claimed group's own class — `false` for an EXTERIOR-flagged group (MOGP `& 0x48`).
+    /// Carried because an exterior-class group inside a building (an inn's basement stairwell, a
+    /// covered porch) is drawn by the exterior law and needs a claim to be lit at all.
+    pub interior: bool,
+    /// May the EXTERIOR batch lane honour this claim? See [`CLAIM_EXT_SHELL_YD`]: a district-scale
+    /// shell is kept in the set (dropping it would leave the fixture with NO claims, and the
+    /// packer's no-claims arm fails OPEN — a far worse leak than the one being avoided) but is
+    /// barred from the exterior lane, where it would put a tavern candle on the street outside.
+    /// The interior lane is unaffected either way: it never runs on an exterior-class group's
+    /// surfaces, so an exterior claim exists for the exterior lane and for nothing else.
+    pub ext_ok: bool,
+    /// MONKEY (soft portal claims): how many doorways the light had to cross to reach this group —
+    /// `0` for the base (containment/MOLR), `1`/`2` for a portal hop. Ordering and audit readout
+    /// only; the shader never sees it (the fade radius below already encodes "how much reach is
+    /// left", which is the same fact measured in yards instead of doors).
+    pub hops: u8,
+    /// MONKEY (soft portal claims): the centre of the portal this claim came through, in the SAME
+    /// space `pos` is in (WMO model space, WoW axes) — the point the shader's weight fades away
+    /// from. Meaningless when `fade_radius == 0`.
+    pub fade_center: [f32; 3],
+    /// MONKEY (soft portal claims): the portal polygon's own bounding-SPHERE radius (yd). Distance
+    /// measured from `fade_center` is reduced by this before the fade, so every fragment standing
+    /// IN the doorway reads weight 1 — which is what makes the far side of the threshold
+    /// continuous with the near side (see [`Claim::fade_radius`]).
+    pub fade_slack: f32,
+    /// MONKEY (soft portal claims): the yards of the fixture's reach still unspent when it arrived
+    /// at `fade_center` — the distance over which the shader smoothsteps this claim's weight from
+    /// 1 (at the doorway) to 0. **`0` means a HARD claim: weight 1 everywhere**, which is what
+    /// every containment/MOLR claim carries, because a fixture standing in a room lights all of it.
+    ///
+    /// This is what turns the binary gate soft. The gate used to answer yes/no per group, so a
+    /// fixture admitted on one side of a group boundary and refused on the other put a straight
+    /// brightness STEP across any floor that crossed it — the scar on the Lion's Pride Inn's
+    /// upstairs landing, where two groups meet mid-plank. With a weight the near side is 1 by
+    /// containment, the far side is ~1 at the threshold (distance to the doorway ~ 0) and decays
+    /// to 0 where the fixture's reach runs out anyway, so nothing steps at the plane.
+    pub fade_radius: f32,
+    /// MONKEY (soft portal claims): the weight this claim ALREADY carries at its own doorway — 1
+    /// for a base claim and for a first hop, and for a second hop the weight the FIRST hop's fade
+    /// had already fallen to by the time it reached this door. The shader multiplies its
+    /// smoothstep by it.
+    ///
+    /// Without it the fade is continuous at the first threshold and discontinuous at the second,
+    /// which is the same bug one room further in: the near room reads (say) 0.4 at its far door
+    /// because the first fade has been decaying across it, while the room beyond restarts its own
+    /// fade at 1.0 — a step, and a step the WRONG WAY (the further room brighter than the nearer
+    /// one). Seeding each hop with its predecessor's value at that point makes the whole chain
+    /// continuous by construction, and monotone: light never gets stronger further from its source.
+    pub fade_entry: f32,
+}
+
+/// The `interiorAttenScale` DEFAULT. A claim set is built ONCE, at spawn, and never rebuilt — but
+/// the reach the shader windows a fixture with is live (the cvar). So the portal hop is measured
+/// against the DEFAULT reach rather than the live one: turning the cvar up widens every pool but
+/// cannot open a doorway that was gated at spawn, and turning it down cannot slam one shut
+/// mid-frame. That is the stable half of the trade, and it keeps the claim table free of per-frame
+/// work; the alternative (re-claiming every fixture whenever the cvar moves) buys a doorway's worth
+/// of light for a rebuild of the whole table. **Mirrors `DynamicInteriors::atten_scale`'s default.**
+pub const CLAIM_ATTEN_SCALE: f32 = 1.6;
+
+/// The cap on any claim reach — `benilla_world::lighting`'s `INTERIOR_LEGACY_REACH` /
+/// `POINT_LIGHT_RANGE`, i.e. the widest a fixture's window is ever packed.
+pub const CLAIM_REACH_MAX: f32 = 48.0;
+
+/// The effective radius (yd) a fixture's portal hop is measured against: its AUTHORED MOLT
+/// attenuation end scaled by [`CLAIM_ATTEN_SCALE`], clamped exactly as the packer's
+/// `interior_reach` clamps it.
+pub fn claim_reach(authored_end: f32) -> f32 {
+    (authored_end * CLAIM_ATTEN_SCALE).clamp(1.0, CLAIM_REACH_MAX)
+}
+
+/// The interior reach (yd) of an **M2** point light of committed intensity `i` — the bucket ladder
+/// [`crate::fire_light::fire_intensity`] buckets a synthesised flame onto (candle 0.6 / torch 1.5 /
+/// brazier 2.0 / bonfire 3.0), because the authored M2 attenuation pair is demonstrably not a reach
+/// in this corpus (a Karazhan BONFIRE authors `end = 0.97` yd). Lives here rather than in the
+/// packer that reads it so the offline audit buckets a prop's synthesised light onto the very same
+/// rung the runtime will; `benilla_world::lighting::m2_light_reach` delegates to it.
+pub fn m2_light_reach(intensity: f32) -> f32 {
+    match intensity {
+        i if i < 1.0 => 6.0,   // candle
+        i if i < 1.75 => 12.0, // torch / campfire
+        i if i < 2.5 => 16.0,  // brazier
+        _ => 24.0,             // bonfire / forge
+    }
+}
+
+/// The AABB of one portal's polygon, or `None` when the record names no usable vertices.
+fn portal_box(portals: &PortalGraph, portal: u16) -> Option<([f32; 3], [f32; 3])> {
+    let info = portals.infos.get(usize::from(portal))?;
+    let start = usize::from(info.start_vertex);
+    let end = start.checked_add(usize::from(info.count))?;
+    let verts = portals.vertices.get(start..end)?;
+    let (first, rest) = verts.split_first()?;
+    let mut lo = *first;
+    let mut hi = *first;
+    for v in rest {
+        for a in 0..3 {
+            lo[a] = lo[a].min(v[a]);
+            hi[a] = hi[a].max(v[a]);
+        }
+    }
+    Some((lo, hi))
+}
+
+/// MONKEY (split-floor claims): the AREA of one portal's polygon (yd²), fan-triangulated over the
+/// MOPV vertices in authored order. The measure that separates a DOORWAY from a room the artist cut
+/// in half: see [`SPLIT_PORTAL_MIN_AREA`] for the two populations it sits between.
+pub fn portal_area(portals: &PortalGraph, portal: u16) -> Option<f32> {
+    let info = portals.infos.get(usize::from(portal))?;
+    let start = usize::from(info.start_vertex);
+    let end = start.checked_add(usize::from(info.count))?;
+    let verts = portals.vertices.get(start..end)?;
+    let (first, rest) = verts.split_first()?;
+    let sub = |a: &[f32; 3], b: &[f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+    let mut area = 0.0f32;
+    for pair in rest.windows(2) {
+        let (u, v) = (sub(&pair[0], first), sub(&pair[1], first));
+        let c = [
+            u[1] * v[2] - u[2] * v[1],
+            u[2] * v[0] - u[0] * v[2],
+            u[0] * v[1] - u[1] * v[0],
+        ];
+        area += 0.5 * (c[0] * c[0] + c[1] * c[1] + c[2] * c[2]).sqrt();
+    }
+    Some(area)
+}
+
+/// A portal as the claim rule measures it, from `pos`: `(distance, centre, slack)`.
+///
+/// **distance** — yards from `pos` to the portal's polygon, approximated by its AABB (the closest
+/// point on the box), which is exact for the axis-aligned doorways most portals are and never
+/// over-states the distance for the rest (erring toward admitting a doorway, which is the safe
+/// direction: an extra claim is a room lit one doorway too far, a missing one is the seam we are
+/// fixing).
+///
+/// MONKEY (soft portal claims): **centre** and **slack** (the box's half-diagonal) are the fade
+/// geometry the shader gets. Fading from the centre alone would put a step back across the WIDTH
+/// of the door — a fragment at the edge of a 1.2 x 2.5 yd doorway is ~1.4 yd from its centre, so
+/// with a short remaining reach it would read half-lit one plank away from a fully lit fragment on
+/// the other side of the plane. Subtracting the slack collapses the whole doorway to distance 0, so
+/// the threshold is weight 1 on BOTH sides by construction and the fade starts where the door frame
+/// ends. A sphere rather than the box because it is one number: slightly generous just outside the
+/// frame, which is the direction that cannot re-introduce an edge.
+fn portal_reach(portals: &PortalGraph, portal: u16, pos: [f32; 3]) -> Option<(f32, [f32; 3], f32)> {
+    let (lo, hi) = portal_box(portals, portal)?;
+    let mut d2 = 0.0f32;
+    let mut center = [0.0f32; 3];
+    let mut diag2 = 0.0f32;
+    for a in 0..3 {
+        let over = (lo[a] - pos[a]).max(pos[a] - hi[a]).max(0.0);
+        d2 += over * over;
+        center[a] = 0.5 * (lo[a] + hi[a]);
+        let half = 0.5 * (hi[a] - lo[a]).max(0.0);
+        diag2 += half * half;
+    }
+    Some((d2.sqrt(), center, diag2.sqrt()))
+}
+
+/// MONKEY (soft portal claims): how many portal hops a claim may travel. **1 is not enough**: a
+/// fixture two rooms from a fragment is claimed on the near side of a group boundary (one hop) and
+/// not at all on the far side, which is a hard step again — the very seam the fade exists to
+/// remove, moved one room outward. Two hops means the far side also carries the fixture, at the
+/// small weight its remaining reach affords. Three would buy nothing measurable: by the second
+/// doorway the unspent reach is already at [`CLAIM_FADE_MIN_YD`] in most vanilla interiors, and
+/// each extra hop multiplies the frontier while competing for the same six slots.
+pub const ROOM_CLAIM_HOPS: u8 = 2;
+
+/// MONKEY (soft portal claims): the floor on a portal claim's fade radius (yd). A fixture that only
+/// just reaches a doorway has ~0 reach left, and a 0-yard smoothstep is a step function — i.e. the
+/// hard edge again, at the doorway instead of at the group plane. Two yards is the shortest fade
+/// that reads as a fade at walking speed, and a fixture that far gone contributes almost nothing
+/// anyway (its own `interior_window` is at the end of its curve), so the floor cannot leak light.
+pub const CLAIM_FADE_MIN_YD: f32 = 2.0;
+
+/// MONKEY (soft portal claims): a hop whose [`Claim::fade_entry`] is already below this is not
+/// worth one of the six slots — it can contribute at most this fraction of one fixture's already
+/// attenuated pool, and the slot is better left to a doorway that can be seen. Dropping it cannot
+/// re-open the seam it exists to close: the room on the NEAR side of that door is, by definition,
+/// this dim there too, so both sides read ~0 and the boundary stays continuous.
+pub const CLAIM_FADE_MIN_ENTRY: f32 = 0.02;
+
+/// MONKEY (split-floor claims): the polygon area (yd²) at or above which a portal is read as a
+/// ROOM SPLIT rather than a doorway, so containment claims cross it at FULL weight instead of
+/// fading (see [`ClaimHow::Split`]).
+///
+/// The soft portal fade is continuous only at the door it came THROUGH — `fade_center` is that
+/// doorway, and the weight decays away from it. A room the artist cut in two (the Lion's Pride
+/// Inn's gallery, split from the common room below it by a 10.5 x 9.1 yd opening; its cellar,
+/// reached through a 10.2 x 3.4 yd hole in the kitchen floor) therefore reads the SAME fixture at
+/// weight 1 on the near half (containment) and at whatever the fade has decayed to on the far half
+/// — a straight brightness line across one continuous floor, at a plane that is not a wall. Worse,
+/// the far half then re-seeds its own portal hops at that decayed weight, so every real doorway off
+/// it inherits the step (the inn's upstairs rooms took the gallery's fixtures at 0.2–0.5 while the
+/// gallery took them at 1.0, and the boundary between them is DIAGONAL — the reported scar).
+///
+/// **28 yd², from the corpus's own bimodal split.** Measured over the two buildings the seam was
+/// reported in, sorted: the Goldshire inn's ten portals run 9.9, 10.8, 11.9, 11.9, 15.6, 17.3,
+/// 17.3, 20.5 (every one of them a door or an arch) and then 35.1 (the cellar floor hole) and 95.9
+/// (the gallery opening); Northshire abbey's fourteen run 14.3 … 16.5 for nine doorways and then
+/// 40.3, 47.1, 50.7, 50.9, 252.6 for its nave splits. The union gap is 20.5 → 35.1 and 28 sits in
+/// the middle of it, so no doorway in either building is merged and every split is.
+///
+/// AREA alone, deliberately — not "horizontal-ish", which is the shape a floor split usually has:
+/// the abbey authors a HORIZONTAL portal of 14.3 yd² (g10↔g5, a hatch), and merging a real hatch
+/// would light a closed room from the one below it. The two horizontal portals that ARE splits (the
+/// inn's 35.1, the abbey's 252.6) both clear the area bar on their own, so the extra criterion buys
+/// nothing and costs a false positive.
+pub const SPLIT_PORTAL_MIN_AREA: f32 = 28.0;
+
+/// `smoothstep(0, edge, x)` — the shader's own curve, so the entry weight this rule bakes and the
+/// weight `static_gx.wgsl` evaluates are the same function sampled at the same point. (Rust has no
+/// `smoothstep`; WGSL's is the Hermite `t*t*(3 - 2t)` on the clamped ratio.)
+fn smoothstep0(edge: f32, x: f32) -> f32 {
+    let t = (x / edge.max(1e-4)).clamp(0.0, 1.0);
+    t * t * (3.0 - 2.0 * t)
+}
+
+/// The largest HORIZONTAL extent (yd) an EXTERIOR-class group may have and still be honoured by the
+/// EXTERIOR batch lane — "a building, not a district".
+///
+/// An exterior-class group is drawn by the exterior law and takes no interior fixture, so a claim on
+/// one is consumed by exactly one thing: the exterior batch's claim-gated room term (bug B's second
+/// cause — the inn's basement stairwell is an EXTERIOR group inside a building and reads night-sky
+/// green next to its candle-lit neighbours). That term must reach an annex like the inn's shell
+/// (`57.7 x 32.2 yd`) and must NOT reach a city's district shell, whose MOGI box swallows the
+/// interiors inside it: measured on `Stormwind.wmo`, 494 of its 606 fixtures stand inside one of
+/// ~8 exterior shells spanning 122-660 yd (g107 alone contains 90 of them), and admitting those
+/// would put a tavern candle's pool on the cobbles outside the tavern wall. The shipped corpus
+/// leaves a wide gap between the two populations — no Stormwind shell is under 122 yd — so the cut
+/// sits in the middle of it rather than on either edge.
+///
+/// A PORTAL claim is exempt: a portal is the artist saying these two groups share a doorway, and
+/// light through a door onto the street is right (it is how a lit doorway reads at night).
+pub const CLAIM_EXT_SHELL_YD: f32 = 96.0;
+
+/// Is a BOX claim (containment or MOLR) on this group eligible for the exterior lane? Interior
+/// groups trivially are (the exterior lane never draws them); an exterior group only at building
+/// scale (see [`CLAIM_EXT_SHELL_YD`]).
+pub fn claimable_by_box(g: &WmoGroupInfo) -> bool {
+    g.interior
+        || (0..2).all(|a| (g.bbox_max[a] - g.bbox_min[a]) <= CLAIM_EXT_SHELL_YD)
+}
+
+/// MONKEY (ext-class night law): is this group EXTERIOR-class but at BUILDING scale — an inn's
+/// shell, a basement stairwell, a covered porch, as opposed to a city district's shell?
+///
+/// The same cut [`claimable_by_box`] makes, read from the other side, and deliberately the SAME
+/// one: a group the exterior lane will honour a candle's claim on is a group that ought to render
+/// by candle-light at night, and a group whose claims that lane refuses (a district shell) must
+/// keep the sky. Two thresholds here would put a group in the gap between them — lit by fixtures
+/// but still sky-based, or sky-less with no fixtures allowed to reach it.
+pub fn ext_building_scale(g: &WmoGroupInfo) -> bool {
+    !g.interior && claimable_by_box(g)
+}
+
+/// MONKEY (enclosed day floor): the slack (yd) an exterior shell's authored MOGI box is grown by
+/// before it is asked whether it CONTAINS a room. An authored box is not always tight around its
+/// own geometry (NSabbey g3's bottom floats 1.5 yd above its own floor), and a room whose centre
+/// sits a hand's breadth outside its own building's shell is a measurement artefact, not a cave.
+pub const SHELL_CONTAIN_SLACK: f32 = 0.5;
+
+/// MONKEY (enclosed day floor): is this INTERIOR-class group a room INSIDE A BUILDING — i.e. is its
+/// box centre contained in some EXTERIOR-class group of the same root at building scale
+/// ([`ext_building_scale`])?
+///
+/// The question the daylight floor turns on, and the one thing that separates "a room whose door
+/// this renderer cannot find" from "a cave that has no door". A building authors a shell: the
+/// Goldshire inn's `g4 upstairs` (57.7 x 32.2 yd, exterior-class) swallows all ten of its rooms,
+/// and Northshire abbey's `g5 mainlobby2` its nave. A dungeon authors none — `az_deadmines_*`,
+/// Stratholme and the rest are interior groups end to end — so nothing there is ever flagged and
+/// the sunless look of a cave is preserved by the DATA rather than by a special case.
+///
+/// A city's district shell is deliberately refused by [`ext_building_scale`]'s
+/// [`CLAIM_EXT_SHELL_YD`] cut, for the same reason the claim lane refuses it: a 660 yd box is not a
+/// building, and flagging every interior group in Stormwind because one shell spans the district
+/// would daylight its sealed cellars.
+pub fn enclosed_by_building_shell(groups: &[WmoGroupInfo], group: u16) -> bool {
+    let Some(g) = groups.get(usize::from(group)) else {
+        return false;
+    };
+    if !g.interior {
+        return false; // an exterior-class group is lit by the sky already
+    }
+    let c = [
+        0.5 * (g.bbox_min[0] + g.bbox_max[0]),
+        0.5 * (g.bbox_min[1] + g.bbox_max[1]),
+        0.5 * (g.bbox_min[2] + g.bbox_max[2]),
+    ];
+    groups.iter().enumerate().any(|(i, e)| {
+        i != usize::from(group)
+            && ext_building_scale(e)
+            && (0..3).all(|a| {
+                c[a] >= e.bbox_min[a] - SHELL_CONTAIN_SLACK
+                    && c[a] <= e.bbox_max[a] + SHELL_CONTAIN_SLACK
+            })
+    })
+}
+
+/// `pos` inside a group's authored MOGI box.
+fn contains(g: &WmoGroupInfo, pos: [f32; 3]) -> bool {
+    (0..3).all(|a| pos[a] >= g.bbox_min[a] && pos[a] <= g.bbox_max[a])
+}
+
+/// The box's volume — the containment ORDER key. A room is small, the shell that spans the whole
+/// building is not, and when six slots have to be spent the room the fixture stands in must get one.
+fn volume(g: &WmoGroupInfo) -> f32 {
+    (0..3)
+        .map(|a| (g.bbox_max[a] - g.bbox_min[a]).max(0.0))
+        .product()
+}
+
+/// The claim set of ONE fixture at `pos` (WMO model space, WoW axes) with effective radius `reach`
+/// yards, whose MOLR referrers are `molr`. Ordered by the priority in the module doc and capped at
+/// [`ROOM_CLAIM_MAX`] — **except** that the base (containment ∪ MOLR) is returned whole even when it
+/// is longer: the packer's own overflow arm decides that case (MONKEY (GO room claims): it keeps
+/// the first [`ROOM_CLAIM_MAX`] in this priority order — it used to fail open, which lit the whole
+/// building through its walls), so this function keeps the full ordered set for the audits.
+///
+/// `reach` of 0 or less disables the portal hop entirely (a fixture with no usable window).
+pub fn room_claims(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    pos: [f32; 3],
+    reach: f32,
+    molr: &[u16],
+) -> Vec<Claim> {
+    let mut out: Vec<Claim> = Vec::new();
+    // MONKEY (soft portal claims): `fade` is `None` for a HARD claim (containment/MOLR — weight 1
+    // everywhere) and `Some((centre, slack, radius))` for a portal hop.
+    let push = |out: &mut Vec<Claim>,
+                group: u16,
+                how: ClaimHow,
+                distance: f32,
+                hops: u8,
+                fade: Option<([f32; 3], f32, f32, f32)>| {
+        if out.iter().any(|c| c.group == group) {
+            return;
+        }
+        let g = groups.get(usize::from(group));
+        let (fade_center, fade_slack, fade_radius, fade_entry) =
+            fade.unwrap_or(([0.0; 3], 0.0, 0.0, 1.0));
+        out.push(Claim {
+            group,
+            how,
+            distance,
+            interior: g.is_some_and(|g| g.interior),
+            // A portal is the artist saying these two groups share a doorway, so it is always
+            // exterior-lane eligible; a box claim has to be building-scale to be.
+            ext_ok: how == ClaimHow::Portal || g.is_none_or(claimable_by_box),
+            hops,
+            fade_center,
+            fade_slack,
+            fade_radius,
+            fade_entry,
+        });
+    };
+    // 1. CONTAINMENT, tightest box first.
+    let mut inside: Vec<(usize, bool, f32)> = groups
+        .iter()
+        .enumerate()
+        .filter(|(_, g)| contains(g, pos))
+        .map(|(i, g)| (i, !claimable_by_box(g), volume(g)))
+        .collect();
+    // Tightest box first, and a district-scale shell (which no lane will light from) after every
+    // real room, so it can never take the slot a portal hop into the next room wanted.
+    inside.sort_by(|a, b| a.1.cmp(&b.1).then(a.2.total_cmp(&b.2)));
+    for (i, _, _) in inside {
+        push(&mut out, i as u16, ClaimHow::Contains, 0.0, 0, None);
+    }
+    // 2. MOLR.
+    for &g in molr {
+        push(&mut out, g, ClaimHow::Molr, 0.0, 0, None);
+    }
+    // 2b. SPLIT-FLOOR SIBLINGS — MONKEY (split-floor claims). A portal too big to be a doorway
+    //     ([`SPLIT_PORTAL_MIN_AREA`]) is the artist cutting ONE room in two for rendering, and the
+    //     two halves must light as one: the far half takes this fixture at weight 1, exactly as the
+    //     half it physically stands in does. Pushed HERE — after the base, before the hop — because
+    //     it is base-equivalent in every way that matters downstream:
+    //
+    //     * HARD (`fade = None`): the fade exists to make a THRESHOLD continuous, and a split has
+    //       no threshold. Fading across it is what put the step on the continuous floor.
+    //     * hop 0, and therefore in the wavefront the portal walk seeds from below at spend 0. That
+    //       is the half of this rule that closes the *second-order* seam: the inn's upstairs rooms
+    //       used to reach their gallery fixtures as hop-TWO claims (through the gallery opening
+    //       first), entering at the 0.2–0.5 the first fade had already decayed to, while the
+    //       gallery itself held them at 1.0 — a step at every one of those doorways, the wrong way
+    //       round. Re-seeded from the merged half they are hop-ONE claims entering at 1.0, which is
+    //       exactly the weight the gallery side reads there.
+    //     * ranked above portal claims when the six slots are contested, for the same reason
+    //       containment is: this is the room the fixture is in, spelt with two group ids.
+    //
+    //     Transitive (the queue below re-walks each merged group), so a room cut into three merges
+    //     whole. Both ends must be [`claimable_by_box`] — a district-scale shell is never one half
+    //     of a room — and the opening must be within the fixture's own reach, so a split it cannot
+    //     light is not merged into its set at the cost of a slot.
+    if reach > 0.0 && !portals.infos.is_empty() && out.len() < ROOM_CLAIM_MAX {
+        let mut queue: Vec<u16> = out.iter().map(|c| c.group).collect();
+        let mut head = 0usize;
+        while head < queue.len() && out.len() < ROOM_CLAIM_MAX {
+            let g = queue[head];
+            head += 1;
+            if groups
+                .get(usize::from(g))
+                .is_none_or(|gi| !claimable_by_box(gi))
+            {
+                continue;
+            }
+            let Some(&(start, count)) = portals.slices.get(usize::from(g)) else {
+                continue;
+            };
+            let from = usize::from(start);
+            let to = from.saturating_add(usize::from(count));
+            for r in portals.refs.get(from..to).unwrap_or(&[]) {
+                if out.len() >= ROOM_CLAIM_MAX {
+                    break;
+                }
+                if out.iter().any(|c| c.group == r.group)
+                    || groups
+                        .get(usize::from(r.group))
+                        .is_none_or(|gi| !claimable_by_box(gi))
+                    || portal_area(&portals, r.portal).unwrap_or(0.0) < SPLIT_PORTAL_MIN_AREA
+                {
+                    continue;
+                }
+                let Some((d, ..)) = portal_reach(&portals, r.portal, pos) else {
+                    continue;
+                };
+                if d > reach {
+                    continue;
+                }
+                push(&mut out, r.group, ClaimHow::Split, d, 0, None);
+                queue.push(r.group);
+            }
+        }
+    }
+    // 3. PORTAL-ADJACENT — up to [`ROOM_CLAIM_HOPS`] doorways off the base, nearest portal first
+    //    within each hop, and every hop's claim carries the fade that makes it SOFT.
+    //
+    //    MONKEY (soft portal claims): this used to stop at ONE hop, and stopping there was itself a
+    //    hard edge. A fixture two rooms from a group boundary is claimed on the near side (one hop)
+    //    and refused on the far side, so the binary gate's step simply moved one room outward —
+    //    the same scar, a doorway further along. The wavefront below SPENDS the fixture's reach as
+    //    it walks: each hop's remaining reach becomes the fade radius past that doorway, so by the
+    //    second door the weight is already small and a third door would not be worth a slot.
+    if out.len() >= ROOM_CLAIM_MAX || reach <= 0.0 || portals.infos.is_empty() {
+        return out;
+    }
+    // The wavefront: `(group, yards ALREADY SPENT getting there)`. The base is at zero — the
+    // fixture physically stands in those groups.
+    // `(group, yards spent, index of the claim in `out`)` — the index is what lets the next hop
+    // sample its predecessor's fade at the door it is about to cross (see [`Claim::fade_entry`]).
+    let mut frontier: Vec<(u16, f32, usize)> = out
+        .iter()
+        .enumerate()
+        .map(|(i, c)| (c.group, 0.0, i))
+        .collect();
+    for hop in 1..=ROOM_CLAIM_HOPS {
+        if out.len() >= ROOM_CLAIM_MAX {
+            break;
+        }
+        // `(group, spent, portal centre, portal slack, seed claim)`, deduped to the CHEAPEST
+        // way in.
+        let mut next: Vec<(u16, f32, [f32; 3], f32, usize)> = Vec::new();
+        for &(g, spent, seed) in &frontier {
+            let Some(&(start, count)) = portals.slices.get(usize::from(g)) else {
+                continue;
+            };
+            let from = usize::from(start);
+            let to = from.saturating_add(usize::from(count));
+            for r in portals.refs.get(from..to).unwrap_or(&[]) {
+                if out.iter().any(|c| c.group == r.group) {
+                    continue; // already claimed, by a tighter source or a cheaper hop
+                }
+                let Some((d, center, slack)) = portal_reach(&portals, r.portal, pos) else {
+                    continue;
+                };
+                // The straight line to the SECOND door can be shorter than to the first (an
+                // L-shaped pair of rooms folds back toward the fixture), but the light still had
+                // to cross the first one. `max` keeps the spend monotone along the path, so a
+                // second-hop room can never be claimed more cheaply than the room it hides behind.
+                let d = d.max(spent);
+                if d > reach {
+                    continue;
+                }
+                match next.iter_mut().find(|(n, ..)| *n == r.group) {
+                    Some(slot) if slot.1 <= d => {}
+                    Some(slot) => *slot = (r.group, d, center, slack, seed),
+                    None => next.push((r.group, d, center, slack, seed)),
+                }
+            }
+        }
+        next.sort_by(|a, b| a.1.total_cmp(&b.1));
+        frontier.clear();
+        for (g, d, center, slack, seed) in next {
+            if out.len() >= ROOM_CLAIM_MAX {
+                break;
+            }
+            // The weight the SEEDING claim still has at this doorway — 1 off a base claim (which
+            // is hard), and the first hop's decayed value off a first hop. This is the whole of
+            // the multi-hop continuity argument: hop N+1 starts at exactly the value hop N ends
+            // at, so the chain has no step at any threshold and never brightens with distance.
+            let seed = &out[seed];
+            let entry = if seed.fade_radius <= 0.0 {
+                1.0
+            } else {
+                let gap = (0..3)
+                    .map(|a| (center[a] - seed.fade_center[a]).powi(2))
+                    .sum::<f32>()
+                    .sqrt();
+                seed.fade_entry
+                    * (1.0 - smoothstep0(seed.fade_radius, (gap - seed.fade_slack).max(0.0)))
+            };
+            if entry < CLAIM_FADE_MIN_ENTRY {
+                continue; // too dim to be worth a slot (see the constant)
+            }
+            // The fade radius is what is LEFT of the reach past this doorway, floored (see
+            // [`CLAIM_FADE_MIN_YD`]: a zero-length smoothstep is a step function again).
+            let radius = (reach - d).max(CLAIM_FADE_MIN_YD);
+            push(
+                &mut out,
+                g,
+                ClaimHow::Portal,
+                d,
+                hop,
+                Some((center, slack, radius, entry)),
+            );
+            frontier.push((g, d, out.len() - 1));
+        }
+    }
+    out
+}
+
+/// [`room_claims`] reduced to the group ids the packer wants.
+pub fn claim_groups(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    pos: [f32; 3],
+    reach: f32,
+    molr: &[u16],
+) -> Vec<u16> {
+    room_claims(groups, portals, pos, reach, molr)
+        .into_iter()
+        .map(|c| c.group)
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn g(interior: bool, lo: [f32; 3], hi: [f32; 3]) -> WmoGroupInfo {
+        WmoGroupInfo {
+            interior,
+            show_skybox: false,
+            bbox_min: lo,
+            bbox_max: hi,
+        }
+    }
+
+    /// MONKEY (enclosed day floor): a room inside a building's shell is flagged; a cave, a room
+    /// under a CITY-scale shell, and the shell itself are not.
+    #[test]
+    fn enclosed_is_a_room_in_a_building_and_nothing_else() {
+        // 0 the room, 1 the inn's own shell (57 x 32 yd, building scale), 2 a second room just
+        // OUTSIDE that shell, 3 a district-scale shell (200 yd) containing everything.
+        let groups = [
+            g(true, [0.0, 0.0, 0.0], [10.0, 10.0, 5.0]),
+            g(false, [-5.0, -5.0, -1.0], [52.0, 27.0, 10.0]),
+            g(true, [90.0, 90.0, 0.0], [95.0, 95.0, 5.0]),
+            g(false, [-100.0, -100.0, -10.0], [100.0, 100.0, 40.0]),
+        ];
+        assert!(enclosed_by_building_shell(&groups, 0));
+        assert!(!enclosed_by_building_shell(&groups, 1), "a shell is not a room");
+        assert!(
+            !enclosed_by_building_shell(&groups, 2),
+            "only the DISTRICT shell holds it, and that is not a building"
+        );
+        assert!(!enclosed_by_building_shell(&groups, 3));
+        assert!(!enclosed_by_building_shell(&groups, 9), "out of range");
+        // A dungeon: interior groups end to end, no shell anywhere -> nothing is ever flagged.
+        let cave = [
+            g(true, [0.0, 0.0, 0.0], [10.0, 10.0, 5.0]),
+            g(true, [10.0, 0.0, 0.0], [20.0, 10.0, 5.0]),
+        ];
+        assert!(!enclosed_by_building_shell(&cave, 0));
+        assert!(!enclosed_by_building_shell(&cave, 1));
+        // The slack really is applied: a room whose centre sits a hand's breadth outside its own
+        // shell is still in the building.
+        let tight = [
+            g(true, [0.0, 0.0, 0.0], [10.0, 10.0, 5.0]),
+            g(false, [-5.0, -5.0, -1.0], [52.0, 27.0, 2.3]),
+        ];
+        assert!(enclosed_by_building_shell(&tight, 0), "centre z 2.5 vs shell top 2.3 + 0.5");
+    }
+
+    /// A quad portal in the x = 5 plane, spanning y 0..2, z 0..3.
+    fn one_portal() -> (Vec<[f32; 3]>, Vec<WmoPortalInfo>) {
+        (
+            vec![
+                [5.0, 0.0, 0.0],
+                [5.0, 2.0, 0.0],
+                [5.0, 2.0, 3.0],
+                [5.0, 0.0, 3.0],
+            ],
+            vec![WmoPortalInfo {
+                start_vertex: 0,
+                count: 4,
+                plane: [1.0, 0.0, 0.0, -5.0],
+            }],
+        )
+    }
+
+    #[test]
+    fn containment_is_tightest_first_and_molr_follows() {
+        let groups = [
+            g(true, [-50.0, -50.0, -10.0], [50.0, 50.0, 30.0]), // g0 the building shell
+            g(true, [-2.0, -2.0, 0.0], [4.0, 4.0, 5.0]),        // g1 the room it stands in
+        ];
+        let c = room_claims(&groups, PortalGraph::default(), [0.0, 0.0, 1.0], 8.0, &[7]);
+        assert_eq!(
+            c.iter().map(|c| c.group).collect::<Vec<_>>(),
+            vec![1, 0, 7],
+            "the tight room outranks the shell, and MOLR follows both"
+        );
+        assert_eq!(c[0].how, ClaimHow::Contains);
+        assert_eq!(c[2].how, ClaimHow::Molr);
+    }
+
+    #[test]
+    fn a_portal_within_reach_claims_the_next_room() {
+        let groups = [
+            g(true, [-5.0, -5.0, 0.0], [5.0, 5.0, 6.0]), // g0, holds the fixture
+            g(true, [5.0, -5.0, 0.0], [15.0, 5.0, 6.0]), // g1, through the doorway
+        ];
+        let (verts, infos) = one_portal();
+        let refs = [
+            WmoPortalRef {
+                portal: 0,
+                group: 1,
+                side: 1,
+            },
+            WmoPortalRef {
+                portal: 0,
+                group: 0,
+                side: -1,
+            },
+        ];
+        let slices = [(0u16, 1u16), (1u16, 1u16)];
+        let portals = PortalGraph {
+            vertices: &verts,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        // 3 yd from the doorway, reach 8 ⇒ the next room is claimed…
+        let c = room_claims(&groups, portals, [2.0, 1.0, 1.0], 8.0, &[]);
+        assert_eq!(c.iter().map(|c| c.group).collect::<Vec<_>>(), vec![0, 1]);
+        assert_eq!(c[1].how, ClaimHow::Portal);
+        // …and out of reach it is not: the far room stays gated, which is the whole point.
+        let c = room_claims(&groups, portals, [-4.0, 1.0, 1.0], 5.0, &[]);
+        assert_eq!(c.iter().map(|c| c.group).collect::<Vec<_>>(), vec![0]);
+    }
+
+    #[test]
+    fn portal_claims_never_displace_the_base() {
+        // Six containing groups fill every slot; the doorway beyond gets nothing.
+        let mut groups: Vec<WmoGroupInfo> = (0..6)
+            .map(|i| g(true, [-5.0, -5.0, 0.0], [5.0 + i as f32, 5.0, 6.0]))
+            .collect();
+        groups.push(g(true, [5.0, -5.0, 0.0], [15.0, 5.0, 6.0]));
+        let (verts, infos) = one_portal();
+        let refs = [WmoPortalRef {
+            portal: 0,
+            group: 6,
+            side: 1,
+        }];
+        let mut slices = vec![(0u16, 1u16)];
+        slices.resize(7, (0, 0));
+        let portals = PortalGraph {
+            vertices: &verts,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        let c = room_claims(&groups, portals, [0.0, 0.0, 1.0], 20.0, &[]);
+        assert_eq!(c.len(), ROOM_CLAIM_MAX);
+        assert!(c.iter().all(|c| c.how == ClaimHow::Contains));
+    }
+
+    /// MONKEY (soft portal claims): a portal claim carries the DOORWAY it came through and the
+    /// reach left past it — the two numbers the shader's weight is built from. A base claim
+    /// carries neither, which is how the shader tells "hard" from "faded".
+    #[test]
+    fn a_portal_claim_carries_its_doorway_and_the_reach_left_past_it() {
+        let groups = [
+            g(true, [-5.0, -5.0, 0.0], [5.0, 5.0, 6.0]),
+            g(true, [5.0, -5.0, 0.0], [15.0, 5.0, 6.0]),
+        ];
+        let (verts, infos) = one_portal();
+        let refs = [
+            WmoPortalRef { portal: 0, group: 1, side: 1 },
+            WmoPortalRef { portal: 0, group: 0, side: -1 },
+        ];
+        let slices = [(0u16, 1u16), (1u16, 1u16)];
+        let portals = PortalGraph {
+            vertices: &verts,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        // 3 yd short of the doorway (x = 5), reach 8 ⇒ 5 yd of reach left on the far side.
+        let c = room_claims(&groups, portals, [2.0, 1.0, 1.0], 8.0, &[]);
+        assert_eq!(c[0].fade_radius, 0.0, "a containment claim is HARD: weight 1 everywhere");
+        assert_eq!(c[0].hops, 0);
+        let door = c[1];
+        assert_eq!(door.how, ClaimHow::Portal);
+        assert_eq!(door.hops, 1);
+        // The quad spans y 0..2, z 0..3 in the x = 5 plane: centre (5, 1, 1.5), half-diagonal
+        // sqrt(0 + 1 + 1.5^2) = 1.803.
+        assert_eq!(door.fade_center, [5.0, 1.0, 1.5]);
+        assert!((door.fade_slack - 1.802_775).abs() < 1e-4, "{door:?}");
+        assert!((door.distance - 3.0).abs() < 1e-5, "closest point on the quad, not its centre");
+        assert!((door.fade_radius - 5.0).abs() < 1e-5, "reach 8 minus the 3 yd spent");
+        assert_eq!(door.fade_entry, 1.0, "a first hop is at full weight in its own doorway");
+
+        // The floor on the fade: a fixture that only just reaches the doorway must still FADE
+        // there, not step. Reach 3.0 leaves 0 yd, and a 0-yard smoothstep is the hard edge again.
+        let c = room_claims(&groups, portals, [2.0, 1.0, 1.0], 3.0, &[]);
+        assert_eq!(c[1].fade_radius, CLAIM_FADE_MIN_YD, "clamped, never zero");
+    }
+
+    /// MONKEY (split-floor claims): a portal too LARGE to be a doorway merges the two halves of the
+    /// room it cuts — the far half takes the fixture HARD (weight 1), and the walk re-seeds from it
+    /// so a real doorway off that half is a FIRST hop at full entry, not a decayed second one.
+    #[test]
+    fn a_split_portal_merges_both_halves_and_reseeds_the_walk() {
+        // g0 holds the fixture, g1 is the other half of the same room (a 5 x 6 = 30 yd² opening,
+        // over SPLIT_PORTAL_MIN_AREA), g2 is a real room off g1 through a 2 x 3 = 6 yd² door.
+        let groups = [
+            g(true, [-5.0, -5.0, 0.0], [5.0, 5.0, 6.0]),
+            g(true, [5.0, -5.0, 0.0], [15.0, 5.0, 6.0]),
+            g(true, [15.0, -5.0, 0.0], [25.0, 5.0, 6.0]),
+        ];
+        let verts = vec![
+            [5.0, -2.5, 0.0], [5.0, 2.5, 0.0], [5.0, 2.5, 6.0], [5.0, -2.5, 6.0],
+            [15.0, 0.0, 0.0], [15.0, 2.0, 0.0], [15.0, 2.0, 3.0], [15.0, 0.0, 3.0],
+        ];
+        let infos = vec![
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, -5.0] },
+            WmoPortalInfo { start_vertex: 4, count: 4, plane: [1.0, 0.0, 0.0, -15.0] },
+        ];
+        let refs = [
+            WmoPortalRef { portal: 0, group: 1, side: 1 },
+            WmoPortalRef { portal: 0, group: 0, side: -1 },
+            WmoPortalRef { portal: 1, group: 2, side: 1 },
+            WmoPortalRef { portal: 1, group: 1, side: -1 },
+        ];
+        let slices = [(0u16, 1u16), (1u16, 2u16), (3u16, 1u16)];
+        let portals = PortalGraph { vertices: &verts, infos: &infos, refs: &refs, slices: &slices };
+        assert!((portal_area(&portals, 0).unwrap() - 30.0).abs() < 1e-3);
+        assert!((portal_area(&portals, 1).unwrap() - 6.0).abs() < 1e-3);
+        let c = room_claims(&groups, portals, [2.0, 0.0, 1.0], 20.0, &[]);
+        assert_eq!(
+            c.iter().map(|c| (c.group, c.how, c.hops)).collect::<Vec<_>>(),
+            vec![
+                (0, ClaimHow::Contains, 0),
+                (1, ClaimHow::Split, 0),
+                (2, ClaimHow::Portal, 1),
+            ],
+        );
+        assert_eq!(c[1].fade_radius, 0.0, "a split is HARD — weight 1 across the far half");
+        assert_eq!(c[2].fade_entry, 1.0, "…so the door off it is a FIRST hop at full entry");
+        // Under the bar the same portal is an ordinary doorway again: g1 fades, g2 is hop TWO.
+        let small = vec![
+            [5.0, -1.0, 0.0], [5.0, 1.0, 0.0], [5.0, 1.0, 3.0], [5.0, -1.0, 3.0],
+            [15.0, 0.0, 0.0], [15.0, 2.0, 0.0], [15.0, 2.0, 3.0], [15.0, 0.0, 3.0],
+        ];
+        let portals = PortalGraph { vertices: &small, ..portals };
+        let c = room_claims(&groups, portals, [2.0, 0.0, 1.0], 20.0, &[]);
+        assert_eq!(
+            c.iter().map(|c| (c.group, c.how, c.hops)).collect::<Vec<_>>(),
+            vec![
+                (0, ClaimHow::Contains, 0),
+                (1, ClaimHow::Portal, 1),
+                (2, ClaimHow::Portal, 2),
+            ],
+        );
+    }
+
+    /// MONKEY (soft portal claims): TWO hops. A fixture two rooms away has to be claimed on BOTH
+    /// sides of the far group boundary or the seam simply moves one room outward — and the
+    /// second hop's fade is measured from the SECOND doorway, with what is left of the reach.
+    #[test]
+    fn the_second_hop_claims_the_room_beyond_and_fades_from_its_own_door() {
+        // Three rooms in a row along x, doors at x = 5 and x = 15.
+        let groups = [
+            g(true, [-5.0, -5.0, 0.0], [5.0, 5.0, 6.0]),
+            g(true, [5.0, -5.0, 0.0], [15.0, 5.0, 6.0]),
+            g(true, [15.0, -5.0, 0.0], [25.0, 5.0, 6.0]),
+        ];
+        let verts = vec![
+            [5.0, 0.0, 0.0], [5.0, 2.0, 0.0], [5.0, 2.0, 3.0], [5.0, 0.0, 3.0],
+            [15.0, 0.0, 0.0], [15.0, 2.0, 0.0], [15.0, 2.0, 3.0], [15.0, 0.0, 3.0],
+        ];
+        let infos = vec![
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, -5.0] },
+            WmoPortalInfo { start_vertex: 4, count: 4, plane: [1.0, 0.0, 0.0, -15.0] },
+        ];
+        let refs = [
+            WmoPortalRef { portal: 0, group: 1, side: 1 },  // g0 -> g1
+            WmoPortalRef { portal: 0, group: 0, side: -1 }, // g1 -> g0
+            WmoPortalRef { portal: 1, group: 2, side: 1 },  // g1 -> g2
+            WmoPortalRef { portal: 1, group: 1, side: -1 }, // g2 -> g1
+        ];
+        let slices = [(0u16, 1u16), (1u16, 2u16), (3u16, 1u16)];
+        let portals = PortalGraph {
+            vertices: &verts,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        // The fixture stands in g0 at x = 2, reach 20: 3 yd to the first door, 13 to the second.
+        let c = room_claims(&groups, portals, [2.0, 1.0, 1.0], 20.0, &[]);
+        assert_eq!(
+            c.iter().map(|c| (c.group, c.hops)).collect::<Vec<_>>(),
+            vec![(0, 0), (1, 1), (2, 2)],
+            "one claim per room, in hop order"
+        );
+        assert_eq!(c[2].fade_center[0], 15.0, "the SECOND door is what g2 fades from");
+        assert!((c[2].fade_radius - 7.0).abs() < 1e-5, "20 yd reach, 13 spent: {:?}", c[2]);
+        // CONTINUITY at the second threshold: g2 must START at exactly the weight g1's own fade
+        // has reached there, or the far room reads BRIGHTER than the near one across one plank.
+        // g1's door is at (5, 1, 1.5) with slack 1.803 and radius 17; g2's is at (15, 1, 1.5),
+        // 10 yd away, so g1 is at 1 - smoothstep(0, 17, 10 - 1.803) = 1 - 0.3835.
+        let g1 = c[1];
+        let gap = 10.0f32 - g1.fade_slack;
+        let t = gap / g1.fade_radius;
+        let expect = 1.0 - t * t * (3.0 - 2.0 * t);
+        assert_eq!(c[0].fade_entry, 1.0, "a base claim enters at full weight");
+        assert_eq!(g1.fade_entry, 1.0, "so does the first hop, at its own door");
+        assert!(
+            (c[2].fade_entry - expect).abs() < 1e-4,
+            "the second hop enters at the first hop's value there: {} vs {expect}",
+            c[2].fade_entry,
+        );
+
+        // Out of the reach of the second door, the third room stays unclaimed — the walk spends
+        // reach, it does not flood.
+        let c = room_claims(&groups, portals, [2.0, 1.0, 1.0], 10.0, &[]);
+        assert_eq!(c.iter().map(|c| c.group).collect::<Vec<_>>(), vec![0, 1]);
+    }
+}
diff --git a/crates/benilla-world/src/assets/mod.rs b/crates/benilla-world/src/assets/mod.rs
index 35739e26..7be9de02 100644
--- a/crates/benilla-world/src/assets/mod.rs
+++ b/crates/benilla-world/src/assets/mod.rs
@@ -21,6 +21,10 @@ impl Plugin for AssetPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, open_world_assets.in_set(AssetSet::Open));
         app.add_systems(Update, (evict_world_art, scope_world_art));
+        // MONKEY (torch shadows Phase 3A): the shared torch depth image + table buffer's extract
+        // plugins and per-frame table upload — always on, like the light buffer's, because every
+        // model material binds them (`open_world_assets` creates them below).
+        crate::static_gx::register_torch_shared(app);
     }
 }
 
@@ -60,7 +64,11 @@ fn scope_world_art(mut scope: ArtScope, assets: Option<ResMut<WorldAssets>>) {
 /// insert the shared [`WorldAssets`] (chain + dedup caches) + [`RenderConfig`]. If the client data
 /// can't be found or opened, `WorldAssets` is simply absent and downstream startup falls back to
 /// an empty free-fly scene.
-fn open_world_assets(mut commands: Commands, device: Res<RenderDevice>) {
+fn open_world_assets(
+    mut commands: Commands,
+    device: Res<RenderDevice>,
+    mut images: ResMut<Assets<Image>>,
+) {
     // The one shared global-light buffer, created here (RenderDevice is live by Startup) so it exists
     // before any material is built. Inserted FIRST — ahead of the install lookup, so no early return
     // below can skip it: it is cloned into `WorldAssets` (for model materials) and read as the
@@ -72,6 +80,16 @@ fn open_world_assets(mut commands: Commands, device: Res<RenderDevice>) {
     let shared_light = crate::lighting::new_shared_light_buffer(&device);
     let light_buf = shared_light.0.clone();
     commands.insert_resource(shared_light);
+    // MONKEY (torch shadows Phase 3A): the shared torch depth image + table buffer, on the same
+    // always-present rule and for the same reason — every model material binds them, and a
+    // material built against a missing image never gets a bind group (every model blanks).
+    let (torch_image, torch_buffer) = crate::static_gx::new_torch_shared(&device, &mut images);
+    let torch = benilla_assets::materials::TorchBinds {
+        depth: torch_image.0.clone(),
+        table: torch_buffer.0.clone(),
+    };
+    commands.insert_resource(torch_image);
+    commands.insert_resource(torch_buffer);
     let Some(data) = benilla_formats::wow_data() else {
         warn!(
             "no WoW install found — looked in {:?}; starting with no world",
@@ -99,7 +117,7 @@ fn open_world_assets(mut commands: Commands, device: Res<RenderDevice>) {
     });
 
     match open_chain(&data) {
-        Ok(chain) => commands.insert_resource(WorldAssets::open(chain, light_buf)),
+        Ok(chain) => commands.insert_resource(WorldAssets::open(chain, light_buf, torch)),
         Err(e) => error!("failed to open client data: {e:#}"),
     }
 }
diff --git a/crates/benilla-world/src/interior.rs b/crates/benilla-world/src/interior.rs
index 8348acee..f4aba86f 100644
--- a/crates/benilla-world/src/interior.rs
+++ b/crates/benilla-world/src/interior.rs
@@ -66,6 +66,17 @@ use benilla_assets::materials::WowModelMaterial;
 /// position compare and nothing else.
 const RESAMPLE_DIST_SQ: f32 = 1e-4;
 
+/// MONKEY (portal lane fade): how fast an anchor's crossfade weight travels between the exterior
+/// lane (`0`) and the room lane (`1`), in weight-units/s. The same 2.0/s the ground-shade node
+/// ramps its intensity at ([`crate::entity_shade`]'s ambient chase, the binary's `[0x810804]`) —
+/// deliberately, because the two are the SAME transition seen from two sides: crossing a portal
+/// re-seeds the node's ambient chase at the moment it re-lanes the part, and a half-second lane
+/// blend under a quarter-second light chase (or vice versa) reads as two events, not one.
+///
+/// Surfaces already blend across a portal seam by geometry; entities had nothing, so an NPC
+/// stepping through a doorway swapped from night-dark to torch-warm in ONE frame.
+const LANE_RAMP_PER_SEC: f32 = 2.0;
+
 /// Which WMO placements are resident — a generation counter the classifier re-evaluates entities on
 /// (a building streaming in under a standing NPC must re-light it even though it didn't move).
 /// Rebuilt each frame by the streamer ([`crate::terrain_stream`]) from its live placements; the
@@ -80,7 +91,11 @@ impl WmoResidency {
     /// The change counter — bumped whenever the resident set actually changes. Read by the per-unit
     /// room claim (`wmo_portal::track_unit_interiors`), whose re-test gate is otherwise movement
     /// alone: a building streaming in under a STANDING unit must still re-claim it.
-    pub(crate) fn generation(&self) -> u32 {
+    ///
+    /// MONKEY (GO room claims): `pub` — a CARRIED light's room-claim set is keyed to a resident
+    /// placement, so it must be rebuilt on the same tick a building streams in or out
+    /// (`benilla_app::entities::carried_light`). Same generation, same gate, one counter.
+    pub fn generation(&self) -> u32 {
         self.generation
     }
 
@@ -271,9 +286,82 @@ pub struct InteriorAnchor {
     /// joining a matte-resolved anchor must force a re-resolve (the reauthor drain checks this),
     /// or it would ride the matte fallback until the anchor next moves.
     kind_bake: bool,
+    /// MONKEY (portal lane fade): the crossfade weight this anchor's parts currently render at —
+    /// `0` fully on the exterior result, `1` fully on the room result, chasing
+    /// [`Self::lane_target`] at [`LANE_RAMP_PER_SEC`]. It lives on the ANCHOR and not per part for
+    /// the same reason the law does: a body must never split across the blend (a half-faded head
+    /// on a fully-faded torso is worse than the pop it replaces), and one `f32` per light node is
+    /// nothing beside the `Vec3` position it already keeps.
+    ///
+    /// The FIRST resolve snaps it to the target instead of ramping (see the insert site): an NPC
+    /// or GameObject that streams in already standing indoors has no "outside" to come from, and
+    /// fading it up from the exterior night result would make every indoor spawn flash dark —
+    /// which is the very artifact this ramp exists to remove, dressed as its cure.
+    lane: f32,
 }
 
 impl InteriorAnchor {
+    /// Where the lane weight is heading: the room result for either indoor law, the exterior one
+    /// outside. Both indoor laws share it because the shader gives them the SAME room lighting
+    /// (`wow_model.wgsl` routes `is_interior || matte_indoor` through `interior_room_light`), so a
+    /// `Bake`↔`Matte` flicker at a doorway must not restart the blend.
+    fn lane_target(law: AppliedLaw) -> f32 {
+        match law {
+            AppliedLaw::Exterior => 0.0,
+            AppliedLaw::Matte | AppliedLaw::Bake(_) => 1.0,
+        }
+    }
+
+    /// Step the crossfade toward this anchor's STANDING law's target, answering whether it moved —
+    /// which is what puts the anchor's parts back in the write path for a frame (the walk's
+    /// `changed` disjunct). Exact at both ends: the clamp lands the weight ON the target, so the
+    /// frame after a blend finishes reports `false` and the anchor is silent again.
+    fn step_lane(&mut self, dt: f32) -> bool {
+        let target = Self::lane_target(self.law);
+        if self.lane == target {
+            return false;
+        }
+        let step = dt * LANE_RAMP_PER_SEC;
+        self.lane = match self.lane < target {
+            true => (self.lane + step).min(target),
+            false => (self.lane - step).max(target),
+        };
+        true
+    }
+
+    /// The weight as the tag's 4-bit field ([`crate::mesh_tag::LANE_MAX`] steps).
+    fn lane_bits(&self) -> u8 {
+        lane_bits(self.lane)
+    }
+
+    /// MONKEY (fire GO lights): the room this anchor's own attach ray claimed — `None` outdoors.
+    ///
+    /// Exposed so the app can hand a GameObject's/creature's CARRIED lights the same room its
+    /// meshes were classified into (`benilla_app::entities::carried_light`'s room claim). Two
+    /// things need it: the faithful gate (a torch in a culled room lights nothing —
+    /// [`crate::lighting::LightRooms`], decision 0689), and cube-shadow eligibility, since
+    /// `torch_shadow's candidate query is `With<WorldPointLight>, With<LightRooms>` and a light with no
+    /// room can never be promoted to a caster however indoors it stands.
+    pub fn room(&self) -> Option<crate::wmo_portal::WmoRoom> {
+        self.room
+    }
+
+    /// MONKEY (carried light stability): the anchor's own crossfade weight - `0` fully exterior,
+    /// `1` fully in [`Self::room`], ramping at [`LANE_RAMP_PER_SEC`] (a half-second full travel).
+    ///
+    /// Exposed because it is the ONE already-smoothed interior/exterior signal a bearer carries,
+    /// and a CARRIED light's lane must be read off it rather than off the raw per-frame law. The
+    /// law itself is known to alternate frame to frame at a threshold - `WOW_INTERIOR_LOG` from
+    /// the 2026-09-09 run shows anchor `320v2` flipping `matte`<->`bake` on ten consecutive
+    /// resolves between t 73.75 and t 74.14 - and a light that re-decided its lane on that raw
+    /// verdict would swap consumer families (the exterior `point_light_sum` <-> the interior room
+    /// lane) at the same rate, i.e. strobe. One frame of a wrong verdict moves this weight by
+    /// `dt * LANE_RAMP_PER_SEC`, so a blip can never cross the `0.5` midpoint a consumer keys on;
+    /// only a verdict that HOLDS for ~0.25 s does.
+    pub fn lane(&self) -> f32 {
+        self.lane
+    }
+
     /// One line naming the lane this anchor's parts render under — the inspect card's light
     /// readout (`crate::interact`). "Which lane is this object on?" was the exact question decision
     /// 0776 was found by, and answering it took a rebuild with `WOW_INTERIOR_LOG` plus an offline
@@ -288,6 +376,15 @@ impl InteriorAnchor {
     }
 }
 
+/// MONKEY (portal lane fade): quantize a `0..=1` crossfade weight onto the tag's 4-bit lane field.
+/// Rounds rather than truncates, so a settled weight of exactly `1.0` reaches the saturated
+/// [`crate::mesh_tag::LANE_MAX`] — a truncating quantizer would leave every indoor entity one step
+/// short of the room lane forever.
+fn lane_bits(lane: f32) -> u8 {
+    let max = f32::from(crate::mesh_tag::LANE_MAX);
+    (lane * max).round().clamp(0.0, max) as u8
+}
+
 /// Parts whose material/tag need re-authoring from their anchor's current law — the classifier's
 /// convergence queue (0734), replacing the per-part sweep's repair duty. Fed by the
 /// [`InteriorLit`] `on_add` hook (a fresh part joining a settled anchor), the fade-latch observer
@@ -318,6 +415,12 @@ pub struct InteriorLit {
     /// by whether that room is on the camera's chain this frame — decision 1792 §4), so a part can
     /// need a rewrite for one with the other unchanged. Meaningless while `applied` is `None`.
     fogged: bool,
+    /// MONKEY (portal lane fade): the tag's lane field as last written, the third component of the
+    /// write gate. It has to be recorded separately from `applied` because two writes can name the
+    /// same EFFECTIVE law and differ only in their blend weight — which is exactly what every
+    /// frame of a portal crossing looks like — and a gate that saw only the law would write the
+    /// first step of the blend and then freeze the entity mid-fade.
+    lane: u8,
 }
 
 impl InteriorLit {
@@ -372,6 +475,7 @@ impl InteriorLit {
             exterior,
             applied: None,
             fogged: false,
+            lane: 0,
         }
     }
 
@@ -389,6 +493,7 @@ impl InteriorLit {
             exterior,
             applied: Some(AppliedLaw::Bake(0)),
             fogged: true,
+            lane: crate::mesh_tag::LANE_MAX,
         }
     }
 }
@@ -579,9 +684,21 @@ pub fn classify_entity_interior(
                 // thing a settled anchor still re-reads is this bit. A compare per anchor, and a
                 // part write only on the frames the verdict actually moves.
                 let fog = anchor_room_fogged(state.room, &instances);
-                if state.fog != fog {
+                // MONKEY (portal lane fade): the settled gate above is MOVEMENT, and the blend is
+                // TIME — a unit that steps through a doorway and stops dead in it (or is stopped
+                // by the server's next position update landing on the same spot) still owes the
+                // rest of its crossfade. So the lane steps here too, and a lane in motion puts the
+                // anchor's parts back through the write loop for exactly the frames it moves.
+                let lane_moved = state.step_lane(time.delta_secs());
+                if state.fog != fog || lane_moved {
                     state.fog = fog;
-                    n_written += write_anchor_parts(state.law, fog, lit_parts, &mut parts);
+                    n_written += write_anchor_parts(
+                        state.law,
+                        fog,
+                        state.lane_bits(),
+                        lit_parts,
+                        &mut parts,
+                    );
                 }
                 continue;
             }
@@ -634,19 +751,31 @@ pub fn classify_entity_interior(
         resolve_us += _r.elapsed().as_secs_f32() * 1e6;
         let fog = anchor_room_fogged(room, &instances);
         let kind_bake = bake.is_some();
-        let changed = match state.as_deref_mut() {
+        // MONKEY (portal lane fade): the law flip and the blend step are two DIFFERENT reasons to
+        // rewrite this anchor's parts, kept apart because only the first is an event — the second
+        // is the ~half-second of frames after it, and folding them into one `changed` would spam
+        // `WOW_INTERIOR_LOG` with 30 identical lines per doorway.
+        let (law_changed, lane_moved, lane) = match state.as_deref_mut() {
             Some(state) => {
-                let changed = state.law != law || state.fog != fog;
+                let law_changed = state.law != law || state.fog != fog;
                 state.law = law;
                 state.room = room;
                 state.fog = fog;
                 state.last_pos = pos;
                 state.generation = residency.generation;
                 state.kind_bake = kind_bake;
-                changed
+                // Stepped AFTER the law lands, so the blend chases the verdict resolved THIS
+                // frame — on the flip frame it moves one step off the lane it was on, never a
+                // frame of the old target.
+                let lane_moved = state.step_lane(time.delta_secs());
+                (law_changed, lane_moved, state.lane_bits())
             }
             None => {
                 // `try_insert`: the anchor may carry a same-frame despawn already queued.
+                // The first resolve SNAPS the blend to its target rather than ramping into it
+                // (see [`InteriorAnchor::lane`]): an entity that streams in already indoors has
+                // no exterior state to come from, and fading it up would flash it dark.
+                let lane = InteriorAnchor::lane_target(law);
                 commands.entity(anchor).try_insert(InteriorAnchor {
                     law,
                     room,
@@ -654,13 +783,15 @@ pub fn classify_entity_interior(
                     last_pos: pos,
                     generation: residency.generation,
                     kind_bake,
+                    lane,
                 });
-                true
+                (true, false, lane_bits(lane))
             }
         };
-        // Write the parts only when the law actually changed, so re-testing a moving NPC mid-room
-        // doesn't churn the render extraction.
-        if !changed {
+        // Write the parts only when the law actually changed (so re-testing a moving NPC mid-room
+        // doesn't churn the render extraction) — or while its blend is still travelling, which is
+        // a handful of parts on the few entities actually mid-portal.
+        if !law_changed && !lane_moved {
             continue;
         }
         // `WOW_INTERIOR_LOG=1`: print interior classifications — the live-probe instrument for
@@ -675,7 +806,9 @@ pub fn classify_entity_interior(
         // lighting like it": a node that resolves exterior and stays there is otherwise invisible
         // to this instrument, and looks identical to a node the walk never visited.
         let log = std::env::var("WOW_INTERIOR_LOG").ok();
+        // `law_changed` and not the write condition: the blend's frames are not classifications.
         if log.is_some()
+            && law_changed
             && (law != AppliedLaw::Exterior || had_state || log.as_deref() == Some("all"))
         {
             // The PART COUNT is load-bearing, not decoration: a lane readout says which law the
@@ -725,7 +858,7 @@ pub fn classify_entity_interior(
                 }
             );
         }
-        n_written += write_anchor_parts(law, fog, lit_parts, &mut parts);
+        n_written += write_anchor_parts(law, fog, lane, lit_parts, &mut parts);
     }
     // Drain the convergence queue: each entry re-authors from its anchor's standing law. Forced
     // through the part's change gate — the enqueuing edges (fade latch, zoom release) mean a
@@ -751,9 +884,13 @@ pub fn classify_entity_interior(
         if matches!(lit.kind, InteriorKind::Bake { .. }) && !state.kind_bake {
             commands.entity(edge.0).try_remove::<InteriorAnchor>();
         }
+        // MONKEY (portal lane fade): the anchor's CURRENT blend weight, so a part that converges
+        // mid-crossing lands on exactly what the walk wrote its siblings this frame — a fresh
+        // gear part authored at the settled weight would pop while the body it hangs off faded.
         n_written += usize::from(write_part_law(
             state.law,
             state.fog,
+            state.lane_bits(),
             &mut lit,
             &mut material,
             &mut tag,
@@ -818,6 +955,7 @@ type PartWrite<'w, 's> = Query<
 fn write_anchor_parts(
     law: AppliedLaw,
     fog: bool,
+    lane: u8,
     lit_parts: Option<&LitParts>,
     parts: &mut PartWrite,
 ) -> usize {
@@ -828,6 +966,7 @@ fn write_anchor_parts(
             written += usize::from(write_part_law(
                 law,
                 fog,
+                lane,
                 &mut lit,
                 &mut material,
                 &mut tag,
@@ -866,20 +1005,31 @@ fn write_anchor_parts(
 /// `mesh_tag::describe` exists to catch a violation of (0355 broke exactly this way). Skipping it
 /// would leave a part that classifies indoors while still *pending* carrying a probe slot on the
 /// exterior material, where the shader decodes those bits as a ground-shade byte.
+///
+/// `lane` is the anchor's crossfade weight as tag bits (MONKEY, portal lane fade) and it is the
+/// reason this function has an EFFECTIVE law distinct from its argument — see [`effective_law`].
 fn write_part_law(
     law: AppliedLaw,
     fog: bool,
+    lane: u8,
     lit: &mut InteriorLit,
     material: &mut MeshMaterial3d<WowModelMaterial>,
     tag: &mut MeshTag,
     force: bool,
     fade: Option<&crate::model_fade::FadeMaterials>,
 ) -> bool {
-    if lit.applied == Some(law) && lit.fogged == fog && !force {
+    let law = effective_law(law, lane);
+    // The gate is the full triple (law, fog, lane): two consecutive frames of a crossing name the
+    // same effective law and differ only in the weight, so a law+fog gate would write the blend's
+    // first step and freeze there. Exactly-gated in the other direction too — the weight reaches
+    // its target exactly (`InteriorAnchor::step_lane` clamps onto it), so a settled part still
+    // costs zero writes however long it stands there.
+    if lit.applied == Some(law) && lit.fogged == fog && lit.lane == lane && !force {
         return false;
     }
     lit.applied = Some(law);
     lit.fogged = fog;
+    lit.lane = lane;
     let want = match fade {
         Some(fm) => fm.material_for(Some(&*lit), true).clone(),
         None => lit.steady_material().clone(),
@@ -889,12 +1039,49 @@ fn write_part_law(
     }
     let payload = match law {
         AppliedLaw::Bake(slot) => crate::mesh_tag::with_interior_probe(tag.0, slot),
-        AppliedLaw::Matte | AppliedLaw::Exterior => crate::mesh_tag::with_exterior_reset(tag.0),
+        // MONKEY (torch shadows Phase 3A): the Matte law keeps the exterior material but flags
+        // the part INDOORS, so the shader's dynamic-interior lane holds across a Bake↔Matte
+        // flicker (the down-ray marginally hitting the baked floor at one spot). Since the portal
+        // lane fade it also carries the blend WEIGHT the shader mixes the two lanes by.
+        AppliedLaw::Matte => crate::mesh_tag::with_matte_indoor(tag.0, lane),
+        AppliedLaw::Exterior => crate::mesh_tag::with_exterior_reset(tag.0),
     };
     tag.0 = crate::mesh_tag::with_interior_fog(payload, fog);
     true
 }
 
+/// MONKEY (portal lane fade): the law a part is actually AUTHORED under, given its anchor's
+/// standing law and the blend weight that law is being reached at.
+///
+/// **The blend only ever exists in exterior material mode.** The exterior half of the crossfade is
+/// the day/night result the exterior material computes, so both halves have to be available in one
+/// fragment — and `Bake` is a different MATERIAL (interior mode, the probe-slot payload), which
+/// cannot produce an exterior day/night result to fade from. So a part heading for `Bake` is
+/// written as `Matte` — the exterior material, flagged indoors, at the current weight — for the
+/// whole of the ramp, and commits the interior material and its probe slot only on the frame the
+/// weight saturates. There is no visual seam at the commit: the shader routes `is_interior` and
+/// the matte-indoor flag through the *same* `interior_room_light`, so the two agree at weight 1.
+///
+/// The mirror case is leaving: the standing law is already `Exterior` while the weight is still
+/// unwinding, and until it reaches zero the part must keep the flag (and the exterior material it
+/// already has) so the shader still has a room lane to fade OUT of. At zero it becomes the plain
+/// exterior reset, which is what clears the flag and the field together.
+///
+/// The probe-slot lifecycle (`seat_probe_slot`/`BakeState`/`ParticleLight`) deliberately does NOT
+/// wait on this: it turns over at the law flip, so a slot is seated (and the SH fold running)
+/// slightly before the part starts reading it, and released slightly after it stops. That is the
+/// harmless order — the alternative, a part on the interior material naming a slot the anchor has
+/// already released, is the stuck-black-unit bug (0734).
+fn effective_law(law: AppliedLaw, lane: u8) -> AppliedLaw {
+    match law {
+        // Mid-ramp toward the room: hold the exterior material and blend on the tag.
+        AppliedLaw::Bake(_) if lane < crate::mesh_tag::LANE_MAX => AppliedLaw::Matte,
+        // Mid-ramp back out: the verdict is outdoors, the blend is not there yet.
+        AppliedLaw::Exterior if lane > 0 => AppliedLaw::Matte,
+        settled => settled,
+    }
+}
+
 /// **Is this anchor's room on the camera's interior-fog chain this frame?** — the `[P+0x98]` half
 /// of a unit's fog lane (decision 1792 §4), resolved through the same chain the room-visibility
 /// leg walks: anchor record → placement instance → the flood's per-group gate.
@@ -1181,6 +1368,10 @@ mod tests {
                     last_pos: Vec3::ZERO, // matches the transform: the settled gate sees NO movement
                     generation,
                     kind_bake: true,
+                    // MONKEY (portal lane fade): a SETTLED anchor — the blend already sits on its
+                    // law's target, so `step_lane` is a no-op and the walk reads exactly as it did
+                    // before the crossfade existed. Every fixture below is settled the same way.
+                    lane: 1.0,
                 },
             ))
             .id();
@@ -1299,6 +1490,7 @@ mod tests {
                     last_pos: Vec3::ZERO,
                     generation,
                     kind_bake: false,
+                    lane: 1.0,
                 },
             ))
             .id();
@@ -1345,6 +1537,7 @@ mod tests {
                     last_pos: Vec3::ZERO, // settled: the walk never re-rays this anchor
                     generation,
                     kind_bake: false,
+                    lane: 1.0,
                 },
             ))
             .id();
@@ -1414,6 +1607,7 @@ mod tests {
                     last_pos: Vec3::ZERO,
                     generation,
                     kind_bake: true,
+                    lane: 1.0,
                 },
             ))
             .id();
@@ -1484,6 +1678,7 @@ mod tests {
                     last_pos: Vec3::ZERO,
                     generation,
                     kind_bake: false,
+                    lane: 0.0,
                 },
             ))
             .id();
@@ -1574,6 +1769,7 @@ mod tests {
                     last_pos: Vec3::ZERO, // settled: the walk skips the ray, the drain does the work
                     generation,
                     kind_bake: true,
+                    lane: 1.0,
                 },
             ))
             .id();
diff --git a/crates/benilla-world/src/lighting/blob.rs b/crates/benilla-world/src/lighting/blob.rs
index 3cea4bad..90458ec2 100644
--- a/crates/benilla-world/src/lighting/blob.rs
+++ b/crates/benilla-world/src/lighting/blob.rs
@@ -20,7 +20,7 @@ use bevy::render::render_resource::{Buffer, BufferDescriptor, BufferUsages};
 use bevy::render::renderer::{RenderDevice, RenderQueue};
 
 use super::global_light::{
-    commit_raw, light_blob_bytes, pack_model_core_rows, LIGHT_HEADER_ROWS, MAX_POINT_LIGHTS,
+    commit_raw, light_blob_bytes, pack_model_core_rows, LIGHT_HEADER_ROWS, MAX_LIVE_POINT_LIGHTS,
 };
 use super::prop_probes::prop_probe_region_offset;
 use super::sh::prop_probe_coeffs;
@@ -94,11 +94,14 @@ impl LightBlob {
     /// Add a point light: position, range, and its diffuse colour **before** the raw commit (the
     /// over-gamut commit law is applied here — see [`commit_raw`]).
     ///
-    /// Silently capped at the table's capacity; past it a light is dropped rather than written
-    /// over the probe region that follows.
+    /// Silently capped at the table's LIVE capacity; past it a light is dropped rather than written
+    /// over the probe region that follows. MONKEY (ext light k8): that cap is
+    /// [`MAX_LIVE_POINT_LIGHTS`] (255), not the 256-slot buffer size — index 255 is the shaders'
+    /// `EXT_SEL_EMPTY` sentinel, so a light seated there would end every draw unit's selection list
+    /// early. Mirrors the truncation `build_light_data` applies to the scene table.
     pub fn point(mut self, pos: Vec3, range: f32, color: [f32; 3]) -> Self {
-        if self.points.len() / 2 >= MAX_POINT_LIGHTS {
-            warn!("light blob: over {MAX_POINT_LIGHTS} point lights — dropping the rest");
+        if self.points.len() / 2 >= MAX_LIVE_POINT_LIGHTS {
+            warn!("light blob: over {MAX_LIVE_POINT_LIGHTS} point lights — dropping the rest");
             return self;
         }
         let c = commit_raw(color);
@@ -167,6 +170,9 @@ impl LightBlob {
 #[cfg(test)]
 mod tests {
     use super::*;
+    // MONKEY (ext light k8): only the cap test needs the SLOT count now — the builder caps on the
+    // LIVE one.
+    use super::super::global_light::MAX_POINT_LIGHTS;
 
     /// The off-world defaults every producer used to hand-write: spec at the terrain convention,
     /// fog off with an inert farclip wall, an empty point table.
@@ -204,16 +210,24 @@ mod tests {
         );
     }
 
-    /// Past the table's capacity a light is dropped, never written over the probe region that
+    /// Past the table's LIVE capacity a light is dropped, never written over the probe region that
     /// follows it in the buffer.
+    ///
+    /// MONKEY (ext light k8): that capacity is 255, ONE SHORT of the 256-slot buffer, because the
+    /// shaders' packed per-draw-unit selection now uses 8 bits per rank and reserves index 255 as
+    /// `EXT_SEL_EMPTY`. The last two assertions pin that relationship: if the cap is ever "tidied"
+    /// back up to the slot count, a 256th light packs as the end-of-list sentinel and every draw
+    /// unit that selected it silently drops the rest of its lights — a bug with no log line.
     #[test]
     fn the_point_table_stops_at_capacity() {
         let mut b = LightBlob::model([0.0; 3], [0.0; 3], Vec3::NEG_Y);
         for _ in 0..MAX_POINT_LIGHTS + 32 {
             b = b.point(Vec3::ZERO, 1.0, [1.0; 3]);
         }
-        assert_eq!(b.point_count(), MAX_POINT_LIGHTS);
-        assert_eq!(b.points.len(), 2 * MAX_POINT_LIGHTS);
+        assert_eq!(b.point_count(), MAX_LIVE_POINT_LIGHTS);
+        assert_eq!(b.points.len(), 2 * MAX_LIVE_POINT_LIGHTS);
+        assert_eq!(MAX_LIVE_POINT_LIGHTS, MAX_POINT_LIGHTS - 1);
+        assert!(MAX_LIVE_POINT_LIGHTS <= 255, "EXT_SEL_EMPTY is index 255");
     }
 
     /// Fog states colour and far independently of whether the shader applies it — the glue
diff --git a/crates/benilla-world/src/lighting/daylight.rs b/crates/benilla-world/src/lighting/daylight.rs
new file mode 100644
index 00000000..3e50cc0f
--- /dev/null
+++ b/crates/benilla-world/src/lighting/daylight.rs
@@ -0,0 +1,2627 @@
+//! MONKEY (daylight fixtures): **the sun, as an interior-lane light, standing in the doorway.**
+//!
+//! THE SEAM. With `interiorLight` on, a WMO's interior groups light from the room law —
+//! `interiorAmbient` + the fixtures that claim the room, and no sun (`static_gx.wgsl`'s
+//! `interior_room_light`, folded through the `1 - exp(-x*interiorExposure)` rolloff). Everything
+//! around a doorway does NOT: an EXTERIOR-class group (the Goldshire inn's shell), and an
+//! EXT/TRANS-class BATCH of an interior group, both keep the reference sky law by day
+//! (`static_gx.wgsl` ~:1242 — `day_w = {TRANS: MOCV alpha, EXT: 1} x sun_w`, blended toward the
+//! reference result). So at the threshold one plank is `ambient + diffuse*N.L` and the next is
+//! `interiorAmbient` — a hard line, exactly where the artists' MOCV bake used to carry the sun
+//! bleed inward and the dynamic lane threw it away. At NIGHT the seam is already gone: `sun_w` is
+//! 0, `day_w` collapses, and both sides are on the room law.
+//!
+//! THE FIX. Give the room law a sun to find: an ordinary interior-lane point light standing in the
+//! doorway, coloured like the sky and calibrated so the room law's result AT THE DOOR equals the
+//! reference sunlit result the batch a plank away is rendering. The seam then closes by
+//! construction on both sides, and the light falls off inward the way daylight does. It rides the
+//! existing machinery whole — `LightRooms` / `LightLitRooms` claims through
+//! [`benilla_formats::room_claim`], `LightLane` interior, `LightReach`, the packer's soft window —
+//! so nothing in the shader, the claim table or the std430 layout changes.
+//!
+//! WHERE A DOORWAY IS. Two seeds, and they are the client's own two populations:
+//!  1. **PORTAL** — a portal whose two sides are one INTERIOR-class group and one EXTERIOR-class
+//!     group (or which only one group names at all: a portal straight to the outside). This is
+//!     byte-for-byte the set `FixColorVertexAlpha` (`0x6c43d0`, `benilla_formats`'s
+//!     `fix_color_vertex_alpha`) whitens a group's MOCV across — "the fade is specific to
+//!     interior<->exterior openings". The reference lights its dark transition corridors with
+//!     exactly this relation, so it is the authored answer to "which opening lets daylight in",
+//!     not a heuristic of ours.
+//!  2. **APERTURE** — an **EXT-class MOBA batch of an INTERIOR group**. That is the other half of
+//!     the same fact: the batch class IS the artist saying "this surface takes the full exterior
+//!     day/night law", and a batch that says so inside a room is a window or an open side. It is
+//!     also the population that draws the seam from the inside (the room's INT-class floor meeting
+//!     its own EXT-class window wall), which no portal describes.
+//!  3. **BOUNDARY** (MONKEY (daylight fixtures: boundary)) — the GROUP-LAW seam itself, taken off
+//!     the meshes: the vertices an INTERIOR-class group shares (to within [`SEAM_EPS`]) with an
+//!     EXTERIOR-class group of the same root. Where the artist split one continuous floor between a
+//!     room and the building's shell, the two meshes are stitched along the threshold line with
+//!     coincident vertices, and THAT line is the doorway — the one the inn's front door actually
+//!     is, and the only one of the three seeds that can see it (there is no portal there and no
+//!     EXT-class batch in the entry group; see MEASURED below). It is the exact locus of the seam
+//!     rather than an approximation of it: the hard line the owner photographed IS the polygon edge
+//!     where the sky law hands over to the room law.
+//!
+//! MEASURED, because the two seeds are not interchangeable (`benilla-extract wmolights` + a
+//! batch-class dump over the same roots, 2026-09-11):
+//!  * **Goldshire inn** (Lion's Pride) — 12 groups, 10 portals, and exactly ONE of them is
+//!    interior<->exterior (p0, `g0 <-> g11 room04`). Its **front door is not a portal at all**: the
+//!    entry group `g3` is 100 % INT-class batches with two portals, both to interior neighbours,
+//!    and the shell `g4 upstairs` that holds the threshold planks authors NO portals whatsoever.
+//!    The aperture seed reaches its upstairs (`g2/g6/g7/g8/g9` each carry one EXT-class batch —
+//!    the windows, diag 5.4-14.9 yd), and the BOUNDARY seed is what reaches the front door: `g3
+//!    entry` shares its threshold vertices with the shell `g4`, and that stitch line is the door.
+//!  * **Northshire abbey** — 14 groups, 14 portals, two of them interior<->exterior (p10
+//!    `g3 Main Hall <-> g5 mainlobby2`, 40.3 yd^2; p13 `g10 Stairs2 <-> g5`, 14.3 yd^2), i.e. the
+//!    portal seed's own best case.
+//!
+//! EXCLUSIONS. A daylight fixture is NOT a fire: no [`super::FlameFlicker`] (daylight does not
+//! wobble), no [`super::SyntheticFireLight`] (so `fireLightGain` cannot dim or kill it), and
+//! `benilla_app::torch_shadow` skips it as a caster candidate (`Without<DaylightFixture>`) — it is
+//! a 20 yd-wide area source standing in a hole in a wall, so a point-cube shadow of it would be
+//! wrong in kind, and it would outrank real fixtures for the twelve cube slots.
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use benilla_formats::{PortalGraph, WmoGroupInfo};
+use bevy::prelude::*;
+
+use super::{
+    DynamicInteriors, FireLightGain, LightLane, LightLitRooms, LightReach, SpellFxLight,
+    SpellLightGain, SyntheticFireLight, WorldPointLight, WowLighting,
+};
+
+/// A `PointLight` that IS the daylight standing in one exterior-facing opening. Spawned with the
+/// placement (`terrain_stream::spawn::fx`), re-aimed every frame by [`update_daylight_fixtures`],
+/// and stripped of its `PointLight` outright after dark (see that system for why not an epsilon).
+#[derive(Component, Clone, Copy, Debug)]
+pub struct DaylightFixture {
+    /// The `WmoPortalInstance` this opening belongs to — the placement, for the claim table's head
+    /// word and for the dump.
+    pub instance: Entity,
+    /// The INTERIOR-class group the fixture stands in (it is nudged into it, see [`NUDGE_YD`]).
+    pub group: u16,
+    /// The MOPT portal index for a [`DaylightHow::Portal`] seed; `None` for an aperture seed, which
+    /// is a batch and has no portal id.
+    pub portal: Option<u16>,
+    /// Which rule found this opening — the dump's readout, and the reason the two are separable.
+    pub how: DaylightHow,
+    /// The AUTHORED reach (yd), read exactly like a MOLT fixture's `attenuation_end`: the packer
+    /// multiplies it by the live `interiorAttenScale` to get the effective radius `R`.
+    pub reach: f32,
+    /// The CALIBRATION distance (yd) — fixture to the floor fragment directly under the opening.
+    pub cal_d: f32,
+    /// `N.L` at that fragment for a floor normal (the fixture stands `hz` above it).
+    pub cal_ndl: f32,
+}
+
+/// Which of the two rules found an opening — see the module doc's MEASURED note for why both are
+/// needed and what each one reaches.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum DaylightHow {
+    /// An interior<->exterior MOPT portal (the client's own `FixColorVertexAlpha` relation).
+    Portal,
+    /// An EXT-class MOBA batch of an INTERIOR group — a window or an open side.
+    Aperture,
+    /// MONKEY (daylight fixtures: boundary): a run of vertices an interior group SHARES with an
+    /// exterior-class group of the same root — the stitched threshold of a doorway the artist cut
+    /// between two groups without authoring a portal.
+    Boundary,
+    /// MONKEY (portal bleed): an INTERIOR<->INTERIOR portal -- a doorway between two ROOMS, whose
+    /// fixture is not the sun at all but the LIT room's own light carried across the threshold into
+    /// the dark one. See the PORTAL BLEED section near the bottom of this file.
+    Bleed,
+}
+
+impl DaylightHow {
+    /// The dump's one-word tag.
+    pub fn tag(self) -> &'static str {
+        match self {
+            DaylightHow::Portal => "portal",
+            DaylightHow::Aperture => "aperture",
+            DaylightHow::Boundary => "boundary",
+            DaylightHow::Bleed => "bleed",
+        }
+    }
+}
+
+/// One opening, resolved in WMO MODEL space (WoW axes) — everything the spawner needs and nothing
+/// about the world, so the whole selection rule is testable without a placement.
+#[derive(Clone, Copy, Debug)]
+pub struct DaylightSeed {
+    pub group: u16,
+    pub portal: Option<u16>,
+    pub how: DaylightHow,
+    /// Already nudged [`NUDGE_YD`] INTO `group` — the spawn position.
+    pub pos: [f32; 3],
+    /// The opening's bounding-box diagonal (yd) — the reach formula's input.
+    pub diag: f32,
+    /// The opening's area (yd^2) — the rank key WITHIN a quota round (largest first).
+    pub area: f32,
+    /// The seed's height above the opening's bottom edge (yd) — the calibration geometry.
+    pub hz: f32,
+    /// MONKEY (daylight quota): which ROUND of [`quota_select`] bought this slot — 0 = "this room
+    /// had no fixture yet", 1 = "its second opening", and so on. Carried on the seed rather than
+    /// returned beside it because the spawner consumes `Vec<DaylightSeed>` by value and the dump
+    /// wants the reason; 0 until the quota runs.
+    pub round: u8,
+}
+
+/// How far INTO the interior group an opening's fixture stands (yd). Far enough that the light is
+/// unambiguously on the room's side of the threshold plane (so the claim rule's containment test
+/// puts it in the room rather than in whatever the doorway itself belongs to), and near enough that
+/// the calibration below is measuring the doorway and not the middle of the room.
+const NUDGE_YD: f32 = 0.5;
+/// The widest opening the APERTURE seed will accept (bbox diagonal, yd). An EXT-class batch this
+/// large is not a window: it is a whole open side of a group (the Goldshire inn's kitchen authors
+/// one at 41.5 yd), and a single point light standing in the middle of it would be a sun in the
+/// room rather than daylight at an edge. The portal seed has no such cap — a portal IS an opening
+/// however big, and the reach clamp below bounds it anyway.
+const APERTURE_MAX_DIAG: f32 = 24.0;
+/// …and the narrowest. Below this an EXT-class batch is a trim strip or a sliver of frame, not an
+/// aperture, and seeding one would spend a budget slot on a light nobody can see through.
+const APERTURE_MIN_DIAG: f32 = 1.0;
+/// An APERTURE seed this close to a PORTAL seed (yd) is the same opening described twice — the
+/// window-frame batch beside the doorway it belongs to. The portal wins (it is the authored
+/// relation); the aperture is dropped. Sized like `MODD_SYNTH_DEDUPE`'s argument: comfortably wider
+/// than one doorway's own geometry, far narrower than the gap between two real openings.
+const SEED_DEDUPE_YD: f32 = 4.0;
+/// How high above an opening's SILL the fixture may stand (yd). An opening's centre is the obvious
+/// place for it, and for a doorway (sill on the floor, ~1-2 yd to the middle) that is exactly right
+/// — but a tall arch or a two-storey window puts its centre 4-5 yd up, and then two things go wrong
+/// at once: the pool lands on the wall rather than on the floor where the seam is, and the
+/// calibration cannot be met at all (the inverse-square core has already spent most of its value by
+/// the time the light reaches the ground, so the solve saturates at `I = 1` and the room still
+/// comes out short — MEASURED at 0.68 against a 0.83 target on the inn's `g6` and the abbey's `g9`).
+/// Two yards is chest height on a threshold: low enough to light the floor, high enough that the
+/// down-angle is still steep.
+const SEED_MAX_HZ: f32 = 2.0;
+/// MONKEY (daylight fixtures: boundary): how close two vertices of DIFFERENT groups have to be (yd)
+/// to count as the same stitched point. A WMO's groups are cut out of one authored mesh, so a
+/// shared edge is duplicated with bit-identical `MOVT` floats; 1/20 yd is two orders of magnitude
+/// above float noise and still far below any gap an artist would leave between separate surfaces.
+const SEAM_EPS: f32 = 0.05;
+/// …and how far apart two stitched points may be (yd) and still belong to the SAME opening. A
+/// threshold's vertex run is dense (a plank edge every few inches); a yard is comfortably wider
+/// than that and comfortably narrower than the gap between a building's separate doors.
+const SEAM_CLUSTER_YD: f32 = 1.0;
+/// …overridable once per process by `WOW_DAYLIGHT_SEAM_EPS`, because the right value is a fact
+/// about the CONTENT and the corpus disagrees with itself. The Goldshire inn's shell stitches its
+/// upstairs rooms at the default and its ground floor not at all (`g4 <-> g5`: 0 coincident cells at
+/// 0.05, 59 at 0.25), so a building whose seam the default misses can be re-measured live rather
+/// than by another build. Read once; a bad value clamps back into `0.01..1.0`.
+fn seam_eps() -> f32 {
+    static EPS: std::sync::OnceLock<f32> = std::sync::OnceLock::new();
+    *EPS.get_or_init(|| {
+        std::env::var("WOW_DAYLIGHT_SEAM_EPS")
+            .ok()
+            .and_then(|v| v.parse::<f32>().ok())
+            .map_or(SEAM_EPS, |v| v.clamp(0.01, 1.0))
+    })
+}
+/// The slack (yd) the exterior group's authored MOGI box is grown by before the pair is considered
+/// at all. The boxes of two stitched groups touch rather than overlap, and an authored box is not
+/// always tight around its own faces (NSabbey g3's bottom floats 1.5 yd above its floor), so a
+/// strict overlap test would drop real pairs.
+const SEAM_BOX_SLACK: f32 = 0.5;
+/// MONKEY (daylight fixtures: boundary): a cluster taller than this (yd) is not a doorway sill. It
+/// is the whole vertical seam where a room's wall is stitched to the shell's — the population that
+/// would otherwise put a light against every party wall in the building. A door frame's own floor
+/// line is centimetres tall and even a stair mouth stays well under three yards.
+const SEAM_MAX_Z_EXTENT: f32 = 3.0;
+/// …and its horizontal run must be at least this wide (yd), or it is a corner stitch rather than an
+/// opening: three or four coincident vertices where two walls and a floor meet.
+const SEAM_MIN_XY_EXTENT: f32 = 1.0;
+/// MONKEY (daylight fixtures: boundary): the vertex budget above which the stitch pass is SKIPPED
+/// (batch vertices summed over the whole root).
+///
+/// The pass is `27 hash probes per unique interior vertex per touching exterior neighbour`, and a
+/// building pays nothing for it -- MEASURED at 6.6 ms for the Goldshire inn (20 470 batch verts)
+/// and 7.4 ms for Northshire abbey (25 206), both including the other two seeds. A CITY does:
+/// `Stormwind.wmo` is 306 groups / 3 088 batches / **761 733** batch verts and the whole selection
+/// costs **162 ms**, synchronously, on the frame its placement spawns.
+///
+/// What makes the guard free rather than a trade is that the city gets nothing from the pass
+/// anyway: Stormwind's eight surviving seeds are four portals and two apertures and two more
+/// portals -- not one boundary cluster ranks into the budget, because a district's authored portals
+/// are 338 yd^2 and a stitched threshold is tens. So the guard costs the city nothing it was
+/// keeping, and buys back the hitch.
+const SEAM_VERT_BUDGET: usize = 300_000;
+/// Openings per placement — **a BUILDING's budget, and now the floor of [`daylight_budget`]**. The
+/// rank is by AREA within each quota round, so what survives a cap is the building's real doorways
+/// and its largest windows. Eight is a whole facade's worth and still far under the 256-slot packed
+/// table, which a city's placements share.
+pub const MAX_DAYLIGHT_PER_PLACEMENT: usize = 8;
+/// MONKEY (daylight quota): the interior-group count above which a placement stops being a BUILDING
+/// and starts being a DISTRICT — past it [`daylight_budget`] scales with the rooms instead of
+/// holding at [`MAX_DAYLIGHT_PER_PLACEMENT`].
+///
+/// Not a taste number: MEASURED over the whole shipped WMO corpus (`benilla-extract wmolights` run
+/// on all 1 211 root `.wmo`s, 2026-09-13), the interior-group count is bimodal and the gap is wide.
+/// **1 183 of 1 211 roots (97.7 %) author 32 interior groups or fewer** — 1 049 author five or
+/// fewer, the Lion's Pride Inn authors 10, Northshire abbey 11 — and every one of those keeps the
+/// eight-slot budget it was calibrated on, unchanged. The 28 roots above the line are the cities and
+/// the raid interiors: Undercity 200, Stormwind 190, alphairon 146, Orgrimmar 129, Sunken Temple
+/// 122, Ironforge 103, Stratholme 91, Diremaul 74. Nothing in the corpus sits between 74 and 32.
+const DAYLIGHT_DISTRICT_ROOMS: usize = 32;
+/// MONKEY (daylight quota): the hard ceiling on one placement's fixtures, however many rooms it
+/// authors. The resource it protects is the 255-row packed point table (`global_light`'s
+/// `MAX_LIVE_POINT_LIGHTS`), which a city's own MOLT fixtures already contest — MEASURED, Stormwind
+/// puts up to 392 of its 606 MOLT lights inside `POINT_PACK_RADIUS` (300 yd) of one camera.
+///
+/// What makes 160 affordable rather than reckless is that **spawned is not packed**. A daylight
+/// fixture carries `LightRooms` naming its own group, so the packer admits it only when that room is
+/// in this frame's portal PVS or the fixture is within `INTERIOR_NEAR_ADMIT` (90 yd) of the camera.
+/// MEASURED over the whole selection, per placement (10 yd camera grid over each city): the worst
+/// 90 yd neighbourhood anywhere in the corpus holds **31** daylight rows — Stormwind, of the 154
+/// fixtures it spawns — against the **133** MOLT rows that same neighbourhood already packs. Undercity
+/// 19 of 74, Ironforge 15 of 71, Orgrimmar 10 of 48. So the per-frame cost of a whole city is ~20 %
+/// on top of its own torches, and the truncation that guards the 255-row cap is nearest-camera-first:
+/// what a full table drops is the FARTHEST fixture, whose ~20 yd pool was sub-pixel anyway.
+///
+/// 160 rather than 154 leaves the measured worst case (Stormwind, the largest seed list in the
+/// corpus) inside the ceiling with room to spare, so what decides a city's daylight is its ROOMS and
+/// not this constant. Lower it and the rooms that fall off are the ones with the narrowest openings.
+const DAYLIGHT_BUDGET_MAX: usize = 160;
+
+/// MONKEY (daylight quota): **how many openings THIS placement may seed** — the fix for a city
+/// being handed a building's budget.
+///
+/// MEASURED, and this is the whole argument (`benilla-extract wmolights` on
+/// `World\wmo\Azeroth\Buildings\Stormwind\Stormwind.wmo`, 2026-09-13): the city is ONE placement of
+/// 306 groups, **190 of them interior-class**, authoring 96 daylight seeds (71 portal + 25 aperture)
+/// and 58 bleed seeds across **136 distinct rooms**. Against a flat eight-slot budget ranked by
+/// area, the whole city's daylight is four 338 yd² canal-mouth portals (p233-p236, into g187-g190),
+/// two ~115 yd² apertures (g241 Dwarf01, g65) and two cathedral portals (g286, g183) — **eight
+/// fixtures in eight rooms, while 128 other rooms with an authored exterior doorway get nothing**.
+/// Every tavern and shop interior in the round-3 list (g21 Old Town, g44 Taventrance13, g57 Trade
+/// District, g58 BM02, g66 NEM02, g67/g69 The Canals, g68 NEH02) is in the losing 128: their
+/// doorways are 8-16 yd², two orders under a district portal, so no AREA rank can ever reach them —
+/// which is why the ranking changes too ([`quota_select`]) and not just the number.
+///
+/// The budget scales with ROOMS because a room is what a fixture is spent on, and one per room is
+/// the quota's own unit. Below [`DAYLIGHT_DISTRICT_ROOMS`] nothing moves at all; above it the
+/// placement gets one slot per interior group, capped at [`DAYLIGHT_BUDGET_MAX`].
+///
+/// What it produces: Goldshire inn 8 (and its eight are byte-identical to the old merge's — MEASURED,
+/// see [`quota_select`]), Northshire abbey 8, Ironforge 103, Stormwind 160. At Stormwind that budget
+/// takes the WHOLE seed list — 154 fixtures, 145 of them round-0, covering all 136 seedable rooms —
+/// so the ceiling binds nowhere in the corpus; Ironforge's whole list is 71 against a budget of 103.
+pub fn daylight_budget(groups: &[WmoGroupInfo]) -> usize {
+    let rooms = groups.iter().filter(|g| g.interior).count();
+    if rooms <= DAYLIGHT_DISTRICT_ROOMS {
+        MAX_DAYLIGHT_PER_PLACEMENT
+    } else {
+        rooms.min(DAYLIGHT_BUDGET_MAX)
+    }
+}
+
+/// The EFFECTIVE reach (yd) of an opening `diag` yards across — the radius `R` the shader actually
+/// windows the pool with: `clamp(1.5*diag + 4, 6, 20)`. The linear term says a wide doorway throws
+/// light further in than an arrow slit; the `+4` floor keeps even a small window's pool bigger than
+/// its own frame; the clamp keeps a 250 yd^2 cathedral opening from claiming a reach no interior
+/// could absorb.
+pub fn daylight_reach(diag: f32) -> f32 {
+    (1.5 * diag + 4.0).clamp(6.0, 20.0)
+}
+
+/// …and what a daylight fixture actually CARRIES, which is one step removed: the packer windows
+/// every interior fixture at `authored end x interiorAttenScale`, so an opening whose effective
+/// reach is to be [`daylight_reach`] must author `daylight_reach / atten_scale`.
+///
+/// The division is by the cvar's DEFAULT, not its live value, for the same reason
+/// [`benilla_formats::room_claim::CLAIM_ATTEN_SCALE`] exists: the number is baked once at spawn and
+/// the cvar is live, so dividing by the live one would make the knob a no-op on exactly these
+/// fixtures. At the default the effective reach is the formula's own answer; move the cvar and
+/// daylight widens or tightens with every other fixture in the building, which is the behaviour a
+/// global knob should have.
+///
+/// It lands where the corpus does, which is the corroboration: the Goldshire inn's own MOLT
+/// fixtures author 6.97-9.53 yd, and a 5.9 yd doorway of its authors 8.1 here.
+pub fn daylight_authored_reach(diag: f32) -> f32 {
+    daylight_reach(diag) / benilla_formats::room_claim::CLAIM_ATTEN_SCALE
+}
+
+// MONKEY (daylight fixtures): the interior pool's PROFILE, MIRRORED from the block
+// `static_gx.wgsl` and `wow_model.wgsl` carry ("MONKEY (soft falloff)") — the same mirror
+// `benilla_app::torch_shadow` keeps for its caster ranking, and for the same reason: this module
+// has to predict the shader's own answer at the door, and predicting it with a different curve
+// would calibrate against a pool that is not the one being drawn. **Keep the four in sync.**
+const INTERIOR_WRAP: f32 = 0.5;
+const INTERIOR_CORE_YD: f32 = 1.75;
+const INTERIOR_CORE_GAIN: f32 = 1.5;
+const INTERIOR_DIRECT_POW: f32 = 10.0;
+const INTERIOR_FILL_SPAN: f32 = 1.5;
+const INTERIOR_FILL_POW: f32 = 1.0;
+
+/// `(clamp01(1 - (d/r)^p))^2` — `static_gx.wgsl`'s `interior_window`.
+fn interior_window(d: f32, r: f32, p: f32) -> f32 {
+    let w = (1.0 - (d / r.max(1e-4)).clamp(0.0, 1.0).powf(p)).clamp(0.0, 1.0);
+    w * w
+}
+
+/// The shader's DIRECT term at `d` yards on a surface whose normal sees the fixture at `ndl`, for a
+/// fixture of effective radius `r_eff` and committed colour 1 — i.e. the factor the packed colour
+/// is multiplied by. `atten * nl * window`, the three lines of `interior_room_light`.
+fn direct_profile(d: f32, ndl: f32, r_eff: f32) -> f32 {
+    let atten = INTERIOR_CORE_GAIN / (1.0 + (d / INTERIOR_CORE_YD).powi(2));
+    let nl = ((ndl + INTERIOR_WRAP) / (1.0 + INTERIOR_WRAP)).max(0.0);
+    atten * nl * interior_window(d, r_eff, INTERIOR_DIRECT_POW)
+}
+
+/// MONKEY (night fade): a three-line mirror of `global_light`'s private `sun_shadow_strength` — the
+/// same one `blob_shadow` keeps, and for the same reason (the function is three lines and the
+/// alternative is widening a private packer detail into the crate API). 0 at or below the horizon,
+/// 1 by ~12 degrees of elevation, smoothstepped.
+fn sun_shadow_strength(sun_height: f32) -> f32 {
+    let t = (sun_height / 0.208).clamp(0.0, 1.0);
+    t * t * (3.0 - 2.0 * t)
+}
+
+/// Rec.709 luminance — the ONE scalar the calibration matches on. Matching per channel would be
+/// wrong as well as impossible: the room law's hue comes from the fixture's normalised colour and
+/// the reference's from `ambient + diffuse*N.L`, and the two agree in luminance at the door by
+/// construction but not channel for channel (the ambient half is bluer than the diffuse half).
+fn luminance(c: [f32; 3]) -> f32 {
+    0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]
+}
+
+/// **THE CALIBRATION.** The packed intensity `I` in `[0, 1]` that makes the room law's result at the
+/// door equal the reference sunlit result there.
+///
+/// The room law is `illum = 1 - exp(-(direct + fill + interiorAmbient) * interiorExposure)` and the
+/// reference is `lit_int_base = clamp(ambient + diffuse*N.L)`, so with `T` the reference's luminance
+/// the required illumination is `X = -ln(1 - T) / exposure`. Both the direct and the FILL term ride
+/// the same committed colour (`c_norm`, and `c_fill` is a half-desaturated mix of it, which
+/// preserves luminance), so both are linear in `I`:
+///
+/// ```text
+/// X = hue_lum * I * (A + interiorFill * W_fill) + interiorAmbient
+/// ```
+///
+/// `I` is clamped to 1 because the shader NORMALISES the committed colour
+/// (`c_norm = c / max(1, max channel)`): past a peak of 1 the extra intensity is divided straight
+/// back out, so an uncalibratable opening saturates rather than silently reading as if it carried
+/// more light than it does. `I = 0` when the room already exceeds the target from its ambient floor
+/// alone.
+pub fn daylight_intensity(
+    target_lum: f32,
+    hue_lum: f32,
+    a_direct: f32,
+    w_fill: f32,
+    knobs: &DynamicInteriors,
+) -> f32 {
+    // `1 - exp(-x)` never reaches 1, so a reference luminance of exactly 1 has no finite solution;
+    // 0.999 is a thousandth of a byte-step short and keeps the log finite.
+    let t = target_lum.clamp(0.0, 0.999);
+    let x = -(1.0 - t).ln() / knobs.exposure.max(1e-3);
+    let denom = hue_lum.max(1e-3) * (a_direct + knobs.fill.max(0.0) * w_fill);
+    if denom <= 1e-6 {
+        return 0.0;
+    }
+    ((x - knobs.ambient) / denom).clamp(0.0, 1.0)
+}
+
+/// The day's own colour and brightness AT A FLOOR, as the reference law renders it — the target the
+/// calibration above matches, and the hue the fixture is given.
+///
+/// Returns `(hue, target_lum, sun_w)`: `hue` is the reference colour renormalised to peak 1 (what
+/// the packed colour carries, so `c_norm` in the shader comes back as `hue * I`), `target_lum` its
+/// luminance, and `sun_w` the day envelope every daylight fixture is scaled by — the SAME
+/// `sun_shadow_strength(celestial_dir.y)` the shader's `day_w` is scaled by, so the two halves of
+/// the threshold fade in and out of the sky law together instead of crossing.
+///
+/// The normal is UP because the seam the feature exists to close is a FLOOR seam — threshold plank
+/// to floorboard. A wall at the same door reads a different `N.L` under both laws, and no single
+/// point source can match a directional one on every normal at once; the floor is the surface the
+/// eye compares across the threshold.
+pub fn daylight_target(light: &WowLighting) -> ([f32; 3], f32, f32) {
+    // `static_gx.wgsl`: `L = -normalize(light_sun.xyz)`, `ndotl = max(dot(N, L), 0)`.
+    let l = -light.sun_dir.normalize_or_zero();
+    let ndotl = l.y.max(0.0);
+    let mut target = [0.0f32; 3];
+    let mut peak = 0.0f32;
+    for i in 0..3 {
+        target[i] = (light.ambient[i] + light.diffuse[i] * ndotl).clamp(0.0, 1.0);
+        peak = peak.max(target[i]);
+    }
+    let hue = if peak > 1e-4 {
+        [target[0] / peak, target[1] / peak, target[2] / peak]
+    } else {
+        [0.0; 3]
+    };
+    (
+        hue,
+        luminance(target),
+        sun_shadow_strength(light.celestial_dir().y),
+    )
+}
+
+/// The AABB of a point cloud in WMO model space — the one measurement both seeds take of their
+/// opening (centre, diagonal, and the bottom edge the calibration height is measured from).
+fn bounds(points: impl Iterator<Item = [f32; 3]>) -> Option<([f32; 3], [f32; 3])> {
+    let mut lo = [f32::MAX; 3];
+    let mut hi = [f32::MIN; 3];
+    let mut any = false;
+    for p in points {
+        any = true;
+        for a in 0..3 {
+            lo[a] = lo[a].min(p[a]);
+            hi[a] = hi[a].max(p[a]);
+        }
+    }
+    any.then_some((lo, hi))
+}
+
+/// The two largest extents of a box multiplied — the opening's AREA as the budget ranks it. An
+/// aperture is a slab (a window is thin in its wall normal), so dropping the smallest extent is
+/// exactly "how big is the hole", and it is the same number a portal's own polygon area approaches.
+fn opening_area(lo: [f32; 3], hi: [f32; 3]) -> f32 {
+    let mut e = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
+    e.sort_by(f32::total_cmp);
+    (e[1] * e[2]).max(0.0)
+}
+
+fn diagonal(lo: [f32; 3], hi: [f32; 3]) -> f32 {
+    ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2) + (hi[2] - lo[2]).powi(2)).sqrt()
+}
+
+/// Where in an opening the fixture stands, and how far that is above the opening's SILL —
+/// the box centre in plan, but no more than [`SEED_MAX_HZ`] up. See that constant.
+fn seed_point(lo: [f32; 3], hi: [f32; 3]) -> ([f32; 3], f32) {
+    let c = center(lo, hi);
+    let z = c[2].min(lo[2] + SEED_MAX_HZ);
+    ([c[0], c[1], z], (z - lo[2]).max(0.0))
+}
+
+/// MONKEY (daylight fixtures: boundary): where a STITCHED cluster's fixture stands — the cluster's
+/// centre in plan, but a full [`SEED_MAX_HZ`] ABOVE its lowest point rather than at its own height.
+///
+/// The difference from [`seed_point`] is the whole geometry of the case. A portal or a window IS the
+/// opening, so its own centre is where the light comes through. A boundary cluster is the THRESHOLD
+/// — a line of vertices lying on the floor — and the opening is the doorway standing on top of it.
+/// Seeding at the cluster's own height would put a point light in the floorboards: calibrated
+/// correctly at the threshold (the solve does not care) but with a hot ring on the planks and a much
+/// steeper fall inward than a doorway has.
+fn seed_point_above(lo: [f32; 3], hi: [f32; 3]) -> ([f32; 3], f32) {
+    let c = center(lo, hi);
+    ([c[0], c[1], lo[2] + SEED_MAX_HZ], SEED_MAX_HZ)
+}
+
+fn center(lo: [f32; 3], hi: [f32; 3]) -> [f32; 3] {
+    [
+        0.5 * (lo[0] + hi[0]),
+        0.5 * (lo[1] + hi[1]),
+        0.5 * (lo[2] + hi[2]),
+    ]
+}
+
+/// Nudge `from` [`NUDGE_YD`] toward the inside of `g`, preferring the direction `plane_n` when the
+/// opening has an authored plane (a portal): stepping along the doorway's own normal crosses the
+/// threshold squarely, where stepping toward the room's box centre can slide ALONG a wall in an
+/// L-shaped room and leave the fixture in the frame. The sign is taken from the room centre either
+/// way — that is the only thing that says which side is "in".
+fn nudge_inward(from: [f32; 3], g: &WmoGroupInfo, plane_n: Option<[f32; 3]>) -> [f32; 3] {
+    let gc = center(g.bbox_min, g.bbox_max);
+    let to_room = Vec3::new(gc[0] - from[0], gc[1] - from[1], gc[2] - from[2]);
+    let dir = match plane_n.map(|n| Vec3::from(n).normalize_or_zero()) {
+        Some(n) if n.length_squared() > 0.5 && to_room.dot(n).abs() > 1e-3 => {
+            n * to_room.dot(n).signum()
+        }
+        _ => to_room.normalize_or_zero(),
+    };
+    let p = Vec3::new(from[0], from[1], from[2]) + dir * NUDGE_YD;
+    [p.x, p.y, p.z]
+}
+
+/// **THE SELECTION RULE** — every exterior-facing opening of one WMO root, in WMO model space,
+/// ranked and capped by the same quota the live path uses ([`quota_select`] over
+/// [`daylight_budget`]) with the bleed lane empty. See the module doc for the two seeds and the
+/// corpus measurement behind having both.
+///
+/// `batches` is `(absolute group index, EXT-class?, the batch's model-space positions)` for every
+/// render batch of the root — the aperture seed's input, passed as an iterator so the caller can
+/// hand it the loaded asset's parallel `submeshes` / `submesh_group` arrays without building a
+/// second copy, and a test can hand it three points.
+pub fn daylight_seeds<'a, I>(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    batches: I,
+) -> Vec<DaylightSeed>
+where
+    I: IntoIterator<Item = (u16, bool, &'a [[f32; 3]])>,
+{
+    let ranked = daylight_seeds_ranked(groups, portals, batches);
+    // MONKEY (daylight quota): the quota, not a truncate — so this entry point and
+    // [`placement_openings`] can never answer the same root differently.
+    quota_select(&ranked, &[], daylight_budget(groups)).0
+}
+
+/// MONKEY (portal bleed): the same rule, RANKED but not capped — the budget is now shared with the
+/// bleed seeds ([`placement_openings`]), and a cap applied here would spend the eight slots on
+/// daylight before a doorway between two rooms was ever compared against them.
+pub fn daylight_seeds_ranked<'a, I>(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    batches: I,
+) -> Vec<DaylightSeed>
+where
+    I: IntoIterator<Item = (u16, bool, &'a [[f32; 3]])>,
+{
+    let (want_portals, want_apertures, want_boundaries) = daylight_modes();
+    let mut out: Vec<DaylightSeed> = Vec::new();
+    let interior_of = |g: u16| groups.get(usize::from(g)).map(|g| g.interior);
+    // Collected because TWO seeds read it: the aperture rule walks it for its EXT-class batches,
+    // and the boundary rule needs every batch of every group, grouped. It is one small Vec of
+    // `(u16, bool, &[_])` per placement per spawn wave -- borrowed slices, no vertex copy.
+    let batches: Vec<(u16, bool, &[[f32; 3]])> = batches.into_iter().collect();
+
+    // --- 1. PORTAL seeds. Both endpoints of a MOPR edge count as "a side": a portal is authored
+    // once per group that owns it, and a portal only ONE group names is a portal to the outside,
+    // whose missing side is exterior by definition (there is no group out there).
+    let mut sides: Vec<(u16, Vec<u16>)> = Vec::new();
+    if want_portals {
+        let note = |portal: u16, group: u16, sides: &mut Vec<(u16, Vec<u16>)>| {
+            match sides.iter_mut().find(|(p, _)| *p == portal) {
+                Some((_, gs)) => {
+                    if !gs.contains(&group) {
+                        gs.push(group);
+                    }
+                }
+                None => sides.push((portal, vec![group])),
+            }
+        };
+        for (gi, (start, count)) in portals.slices.iter().enumerate() {
+            let (start, count) = (usize::from(*start), usize::from(*count));
+            for r in portals.refs.get(start..start + count).unwrap_or(&[]) {
+                note(r.portal, gi as u16, &mut sides);
+                note(r.portal, r.group, &mut sides);
+            }
+        }
+    }
+    for (portal, gs) in &sides {
+        let mut ins = gs.iter().copied().filter(|g| interior_of(*g) == Some(true));
+        let (Some(inside), None) = (ins.next(), ins.next()) else {
+            continue; // zero interior sides (an exterior-to-exterior seam) or two (a room to a room)
+        };
+        // One interior side is not yet a doorway: the other side must be exterior-CLASS, or absent
+        // entirely (a portal straight to the outside, which only one group names).
+        if gs.len() > 1 && !gs.iter().any(|g| interior_of(*g) == Some(false)) {
+            continue;
+        }
+        let Some(g) = groups.get(usize::from(inside)) else {
+            continue;
+        };
+        let info = portals.infos.get(usize::from(*portal));
+        let verts = info.and_then(|i| {
+            let s = usize::from(i.start_vertex);
+            portals.vertices.get(s..s + usize::from(i.count))
+        });
+        let Some((lo, hi)) = verts.and_then(|v| bounds(v.iter().copied())) else {
+            continue;
+        };
+        let (c, hz) = seed_point(lo, hi);
+        let n = info.map(|i| [i.plane[0], i.plane[1], i.plane[2]]);
+        out.push(DaylightSeed {
+            group: inside,
+            portal: Some(*portal),
+            how: DaylightHow::Portal,
+            pos: nudge_inward(c, g, n),
+            diag: diagonal(lo, hi),
+            // The real polygon area where the record gives one — a doorway is rarely its own box.
+            area: benilla_formats::room_claim::portal_area(&portals, *portal)
+                .unwrap_or_else(|| opening_area(lo, hi)),
+            hz,
+            round: 0,
+        });
+    }
+    let portal_seeds = out.len();
+
+    // --- 2. APERTURE seeds: an EXT-class batch of an INTERIOR group (see the module doc).
+    if want_apertures {
+        for &(gi, ext_class, positions) in &batches {
+            if !ext_class || interior_of(gi) != Some(true) {
+                continue;
+            }
+            let Some(g) = groups.get(usize::from(gi)) else {
+                continue;
+            };
+            let Some((lo, hi)) = bounds(positions.iter().copied()) else {
+                continue;
+            };
+            let diag = diagonal(lo, hi);
+            if !(APERTURE_MIN_DIAG..=APERTURE_MAX_DIAG).contains(&diag) {
+                continue;
+            }
+            let (c, hz) = seed_point(lo, hi);
+            let pos = nudge_inward(c, g, None);
+            // The authored portal wins a shared opening — see [`SEED_DEDUPE_YD`].
+            let dup = out[..portal_seeds].iter().any(|s| {
+                (s.pos[0] - pos[0]).powi(2)
+                    + (s.pos[1] - pos[1]).powi(2)
+                    + (s.pos[2] - pos[2]).powi(2)
+                    < SEED_DEDUPE_YD * SEED_DEDUPE_YD
+            });
+            if dup {
+                continue;
+            }
+            out.push(DaylightSeed {
+                group: gi,
+                portal: None,
+                how: DaylightHow::Aperture,
+                pos,
+                diag,
+                area: opening_area(lo, hi),
+                hz,
+                round: 0,
+            });
+        }
+    }
+
+    // --- 3. BOUNDARY seeds: the stitched interior<->exterior group seam (see the module doc).
+    // Skipped outright on a city-scale root -- see [`SEAM_VERT_BUDGET`] for the measurement.
+    let root_verts: usize = batches.iter().map(|(_, _, p)| p.len()).sum();
+    if want_boundaries && root_verts <= SEAM_VERT_BUDGET {
+        let authored = out.len();
+        for (group, lo, hi, inward) in boundary_clusters(groups, &batches) {
+            let (c, hz) = seed_point_above(lo, hi);
+            let pos = [
+                c[0] + inward[0] * NUDGE_YD,
+                c[1] + inward[1] * NUDGE_YD,
+                c[2],
+            ];
+            // The authored seeds win a shared opening: a real doorway often has BOTH a portal (or
+            // an EXT batch) and a stitch line, and two lights in one door would double the pool.
+            let dup = out[..authored].iter().any(|s| {
+                (s.pos[0] - pos[0]).powi(2)
+                    + (s.pos[1] - pos[1]).powi(2)
+                    + (s.pos[2] - pos[2]).powi(2)
+                    < SEED_DEDUPE_YD * SEED_DEDUPE_YD
+            });
+            if dup {
+                continue;
+            }
+            let diag = diagonal(lo, hi);
+            out.push(DaylightSeed {
+                group,
+                portal: None,
+                how: DaylightHow::Boundary,
+                pos,
+                diag,
+                // A threshold is a LINE, not a slab: `opening_area`'s two-largest-extents measure
+                // would call a 4 yd doorway sill `4 x 0.3 = 1.2` yd^2 and the budget would drop it
+                // under every window in the building. The opening the line REPRESENTS is about as
+                // tall as it is wide, so its run squared is the honest comparable.
+                area: diag * diag,
+                hz,
+                round: 0,
+            });
+        }
+    }
+
+    // Largest opening first. MONKEY (daylight quota): this is now the rank WITHIN one quota round
+    // (and the deterministic order [`quota_select`]'s index tie-break inherits) rather than the
+    // budget's own cut — what a room keeps is its widest opening, and what it drops is the trim.
+    out.sort_by(|a, b| b.area.total_cmp(&a.area));
+    out
+}
+
+/// MONKEY (daylight fixtures: boundary): every stitched interior<->exterior opening of one root, as
+/// `(interior group, cluster lo, cluster hi, inward unit direction)` in WMO model space.
+///
+/// **The rule.** A WMO's groups are cut out of one authored mesh, so where a room's floor runs into
+/// the building shell's the two group files carry the SAME vertices -- the threshold is literally
+/// duplicated geometry. For each exterior-class group `E` we hash its vertices onto a [`SEAM_EPS`]
+/// grid; then for each interior-class group `G` whose authored box reaches `E`'s (grown by
+/// [`SEAM_BOX_SLACK`]) we keep the `G` vertices landing within `SEAM_EPS` of one of `E`'s. The
+/// survivors are clustered, and each cluster is one opening.
+///
+/// **The loop order is E-outer on purpose.** One hash per exterior group, reused across every
+/// interior group it touches, so peak memory is the LARGEST exterior group rather than the sum --
+/// Stormwind carries ~8 district shells of six figures of vertices each, and a per-pair hash would
+/// have rebuilt the big one eight times over.
+///
+/// **Clustering is by CELL, not by point.** Single-link over points is `O(k^2)` in the worst case
+/// and a dense threshold is exactly that worst case (a vertex every few inches). Instead the hits
+/// are dropped onto a [`SEAM_CLUSTER_YD`] grid and the occupied CELLS are union-found over their
+/// 27-neighbourhood, which links any two points closer than the cell size and at most its diagonal.
+/// The difference from exact single-link is a yard of slack at the joins, which the extent filters
+/// absorb.
+///
+/// **The filters** are the difference between "the doorway" and "every wall this room shares with
+/// the shell": a cluster must run at least [`SEAM_MIN_XY_EXTENT`] horizontally (or it is a corner
+/// stitch -- three vertices where two walls meet a floor), must stand no more than
+/// [`SEAM_MAX_Z_EXTENT`] tall (or it is the vertical seam of a whole party wall), and must fall in
+/// the same 1..24 yd size band the aperture seed uses.
+fn boundary_clusters(
+    groups: &[WmoGroupInfo],
+    batches: &[(u16, bool, &[[f32; 3]])],
+) -> Vec<(u16, [f32; 3], [f32; 3], [f32; 3])> {
+    // Per-group batch slices + each group's own vertex CENTROID, which is what "inward" points at.
+    // The centroid rather than the authored box centre: a box centre can sit outside an L-shaped
+    // room entirely, and a threshold's inward direction is the one thing this seed cannot get wrong
+    // without putting the light inside the wall.
+    let mut per_group: Vec<Vec<&[[f32; 3]]>> = vec![Vec::new(); groups.len()];
+    let mut sum: Vec<([f64; 3], u64)> = vec![([0.0; 3], 0); groups.len()];
+    for &(gi, _, positions) in batches {
+        let Some(slot) = per_group.get_mut(usize::from(gi)) else {
+            continue;
+        };
+        slot.push(positions);
+        let acc = &mut sum[usize::from(gi)];
+        for p in positions {
+            for a in 0..3 {
+                acc.0[a] += f64::from(p[a]);
+            }
+            acc.1 += 1;
+        }
+    }
+    let eps = seam_eps();
+    let key = |p: [f32; 3]| {
+        [
+            (p[0] / eps).round() as i32,
+            (p[1] / eps).round() as i32,
+            (p[2] / eps).round() as i32,
+        ]
+    };
+    // Each INTERIOR group's unique grid keys, built ONCE. A group repeats every vertex across the
+    // batches that use it (the Goldshire inn authors 92 batches over 12 groups), and the walk below
+    // is `27 hash probes per key per exterior neighbour` -- so deduplicating here, rather than
+    // inside that walk, is the difference between paying for vertices and paying for vertex USES.
+    let mut g_keys: Vec<Vec<[i32; 3]>> = vec![Vec::new(); groups.len()];
+    for (gi, g) in groups.iter().enumerate() {
+        if !g.interior || per_group[gi].is_empty() {
+            continue;
+        }
+        let mut seen: HashSet<[i32; 3]> = HashSet::new();
+        for slice in &per_group[gi] {
+            for p in *slice {
+                seen.insert(key(*p));
+            }
+        }
+        g_keys[gi] = seen.into_iter().collect();
+    }
+    // Stitched hits per interior group, deduped by grid key (a group repeats each vertex across
+    // every batch that uses it, and a threshold vertex is shared by several).
+    let mut hits: HashMap<u16, HashSet<[i32; 3]>> = HashMap::new();
+    for (ei, e) in groups.iter().enumerate() {
+        if e.interior || per_group[ei].is_empty() {
+            continue;
+        }
+        let elo = [
+            e.bbox_min[0] - SEAM_BOX_SLACK,
+            e.bbox_min[1] - SEAM_BOX_SLACK,
+            e.bbox_min[2] - SEAM_BOX_SLACK,
+        ];
+        let ehi = [
+            e.bbox_max[0] + SEAM_BOX_SLACK,
+            e.bbox_max[1] + SEAM_BOX_SLACK,
+            e.bbox_max[2] + SEAM_BOX_SLACK,
+        ];
+        let mut cells: HashSet<[i32; 3]> = HashSet::new();
+        for slice in &per_group[ei] {
+            for p in *slice {
+                cells.insert(key(*p));
+            }
+        }
+        for (gi, g) in groups.iter().enumerate() {
+            if !g.interior || per_group[gi].is_empty() {
+                continue;
+            }
+            if (0..3).any(|a| g.bbox_min[a] > ehi[a] || g.bbox_max[a] < elo[a]) {
+                continue; // the two groups are nowhere near each other
+            }
+            let seen = hits.entry(gi as u16).or_default();
+            for k in &g_keys[gi] {
+                // Cheap reject first: a vertex outside the exterior group's grown box cannot be
+                // within `eps` of one of its vertices, and that is most of them.
+                let p = [k[0] as f32 * eps, k[1] as f32 * eps, k[2] as f32 * eps];
+                if (0..3).any(|a| p[a] < elo[a] || p[a] > ehi[a]) {
+                    continue;
+                }
+                if seen.contains(k) {
+                    continue; // already stitched by another exterior neighbour
+                }
+                let hit = (-1..=1).any(|dx| {
+                    (-1..=1).any(|dy| {
+                        (-1..=1).any(|dz| cells.contains(&[k[0] + dx, k[1] + dy, k[2] + dz]))
+                    })
+                });
+                if hit {
+                    seen.insert(*k);
+                }
+            }
+        }
+    }
+
+    let mut out = Vec::new();
+    for (gi, keys) in hits {
+        let (acc, n) = sum[usize::from(gi)];
+        if keys.is_empty() || n == 0 {
+            continue;
+        }
+        let centroid = [
+            (acc[0] / n as f64) as f32,
+            (acc[1] / n as f64) as f32,
+            (acc[2] / n as f64) as f32,
+        ];
+        let points: Vec<[f32; 3]> = keys
+            .iter()
+            .map(|k| [k[0] as f32 * eps, k[1] as f32 * eps, k[2] as f32 * eps])
+            .collect();
+        for (lo, hi) in cluster_boxes(&points) {
+            let d = diagonal(lo, hi);
+            if !(APERTURE_MIN_DIAG..=APERTURE_MAX_DIAG).contains(&d) {
+                continue;
+            }
+            if hi[2] - lo[2] > SEAM_MAX_Z_EXTENT {
+                continue;
+            }
+            let xy = ((hi[0] - lo[0]).powi(2) + (hi[1] - lo[1]).powi(2)).sqrt();
+            if xy < SEAM_MIN_XY_EXTENT {
+                continue;
+            }
+            let c = center(lo, hi);
+            // Horizontal only: the room's centroid is usually a storey up or down from a threshold,
+            // and a light nudged along that slope would leave the floor it is meant to be lighting.
+            let mut inward = Vec3::new(centroid[0] - c[0], centroid[1] - c[1], 0.0);
+            if inward.length_squared() < 1e-6 {
+                inward = Vec3::X; // degenerate (the centroid is over the door) -- any push will do
+            }
+            let inward = inward.normalize();
+            out.push((gi, lo, hi, [inward.x, inward.y, 0.0]));
+        }
+    }
+    // Deterministic across runs: a `HashMap` walk is not, and the budget TRUNCATES, so an unstable
+    // order would give the same building different doorways on different launches.
+    out.sort_by(|a, b| {
+        a.0.cmp(&b.0)
+            .then(a.1[0].total_cmp(&b.1[0]))
+            .then(a.1[1].total_cmp(&b.1[1]))
+            .then(a.1[2].total_cmp(&b.1[2]))
+    });
+    out
+}
+
+/// Single-link clustering of `points` at [`SEAM_CLUSTER_YD`], by grid cell (see
+/// [`boundary_clusters`] for why by cell): one `(lo, hi)` box per cluster.
+fn cluster_boxes(points: &[[f32; 3]]) -> Vec<([f32; 3], [f32; 3])> {
+    fn find(parent: &mut [usize], mut i: usize) -> usize {
+        while parent[i] != i {
+            parent[i] = parent[parent[i]];
+            i = parent[i];
+        }
+        i
+    }
+    let cell = |p: [f32; 3]| {
+        [
+            (p[0] / SEAM_CLUSTER_YD).floor() as i32,
+            (p[1] / SEAM_CLUSTER_YD).floor() as i32,
+            (p[2] / SEAM_CLUSTER_YD).floor() as i32,
+        ]
+    };
+    let mut index: HashMap<[i32; 3], usize> = HashMap::new();
+    let mut cells: Vec<[i32; 3]> = Vec::new();
+    let mut of_point: Vec<usize> = Vec::with_capacity(points.len());
+    for p in points {
+        let c = cell(*p);
+        let i = *index.entry(c).or_insert_with(|| {
+            cells.push(c);
+            cells.len() - 1
+        });
+        of_point.push(i);
+    }
+    let mut parent: Vec<usize> = (0..cells.len()).collect();
+    for (i, c) in cells.iter().enumerate() {
+        for dx in -1..=1 {
+            for dy in -1..=1 {
+                for dz in -1..=1 {
+                    if let Some(&j) = index.get(&[c[0] + dx, c[1] + dy, c[2] + dz]) {
+                        let (a, b) = (find(&mut parent, i), find(&mut parent, j));
+                        if a != b {
+                            parent[a] = b;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    let mut boxes: HashMap<usize, ([f32; 3], [f32; 3])> = HashMap::new();
+    for (p, ci) in points.iter().zip(of_point.iter()) {
+        let root = find(&mut parent, *ci);
+        let e = boxes.entry(root).or_insert((*p, *p));
+        for a in 0..3 {
+            e.0[a] = e.0[a].min(p[a]);
+            e.1[a] = e.1[a].max(p[a]);
+        }
+    }
+    let mut out: Vec<([f32; 3], [f32; 3])> = boxes.into_values().collect();
+    // Same determinism argument as `boundary_clusters`.
+    out.sort_by(|a, b| {
+        a.0[0]
+            .total_cmp(&b.0[0])
+            .then(a.0[1].total_cmp(&b.0[1]))
+            .then(a.0[2].total_cmp(&b.0[2]))
+    });
+    out
+}
+
+impl DaylightSeed {
+    /// The component this seed becomes — the calibration geometry resolved once, at spawn.
+    ///
+    /// `cal_d` is the distance from the fixture to the floor fragment directly under the opening:
+    /// [`NUDGE_YD`] horizontally (the fixture stands that far inside the threshold) and `hz`
+    /// vertically (the opening's centre sits that far above its own sill). `cal_ndl` is that
+    /// fragment's `N.L` for a floor normal, which is `hz / cal_d` — so a low sill (a doorway,
+    /// `hz ~ 1.1`) reads nearly straight down and a high window reads more grazing, exactly as the
+    /// geometry says.
+    pub fn fixture(&self, instance: Entity) -> DaylightFixture {
+        let hz = self.hz.max(0.25);
+        let cal_d = (NUDGE_YD * NUDGE_YD + hz * hz).sqrt().max(1e-3);
+        DaylightFixture {
+            instance,
+            group: self.group,
+            portal: self.portal,
+            how: self.how,
+            reach: daylight_authored_reach(self.diag),
+            cal_d,
+            cal_ndl: (hz / cal_d).clamp(0.0, 1.0),
+        }
+    }
+}
+
+/// `WOW_DAYLIGHT` — the feature's own kill switch, read once. `0`/`off` disables it entirely;
+/// `portals`, `apertures` and `boundaries` each keep one seed alone. A plain env var rather than a
+/// cvar because the cvar table is another agent's file this round; the A/B it buys ("is THIS seam a
+/// portal opening, a window, or a stitched threshold?") is worth more than the tidier home.
+pub fn daylight_modes() -> (bool, bool, bool) {
+    static MODES: std::sync::OnceLock<(bool, bool, bool)> = std::sync::OnceLock::new();
+    *MODES.get_or_init(|| match std::env::var("WOW_DAYLIGHT").ok().as_deref() {
+        Some("0" | "off" | "false") => (false, false, false),
+        Some("portals") => (true, false, false),
+        Some("apertures") => (false, true, false),
+        Some("boundaries") => (false, false, true),
+        _ => (true, true, true),
+    })
+}
+
+/// Re-aim every daylight fixture at this frame's sun: the colour, the calibrated intensity, and the
+/// day/night existence switch.
+///
+/// Scheduled in `PostUpdate` **before** `global_light::classify_light_lanes`, which is itself
+/// chained before the packer `build_light_data` — so a fixture is packed on THIS frame's sun rather
+/// than last frame's. It needs no transform-propagation ordering of its own (unlike the packer): a
+/// daylight fixture never moves, and nothing here reads a `GlobalTransform`.
+///
+/// **After dark the `PointLight` is REMOVED, not dimmed.** The packer has no zero-intensity skip —
+/// it packs any `PointLight` within 300 yd — so an epsilon fixture would still hold one of the 256
+/// table slots and still be walked by every interior fragment in its fill radius, all night, to
+/// contribute nothing. Removing the component takes it out of the packer's query outright and costs
+/// two archetype moves per game day. Everything else about the entity (its claims, its lane, its
+/// reach) is untouched, so dawn re-inserts and the claim set is exactly the one built at spawn.
+pub fn update_daylight_fixtures(
+    mut commands: Commands,
+    light: Res<WowLighting>,
+    knobs: Res<DynamicInteriors>,
+    // MONKEY (portal bleed): `Without<BleedFixture>` -- a bleed fixture wears `DaylightFixture` as
+    // its marker (for the packer's `interiorGain` skip and `torch_shadow`'s caster refusal) but is
+    // aimed by `update_bleed_fixtures` instead, from the room next door rather than from the sun.
+    // The exclusion is also what makes the two systems' `&mut PointLight` access disjoint.
+    mut fixtures: Query<
+        (
+            Entity,
+            &DaylightFixture,
+            Option<&LightReach>,
+            Option<&mut WorldPointLight>,
+        ),
+        Without<BleedFixture>,
+    >,
+    time: Res<Time>,
+    mut last_dump: Local<f64>,
+) {
+    let (hue, target_lum, sun_w) = daylight_target(&light);
+    // The room lane being off is the feature being off: with `interiorLight 0` every interior
+    // surface is back on its MOCV bake, nothing reads the interior half of the point table, and a
+    // daylight fixture would be a slot spent on a lane nobody is listening to.
+    let day = knobs.enabled && sun_w > 1e-3 && target_lum > 1e-3;
+    let hue_lum = luminance(hue);
+    let mut lit: Vec<(Entity, DaylightFixture, f32)> = Vec::new();
+    for (e, fx, reach, pl) in &mut fixtures {
+        let intensity = if day {
+            // The EFFECTIVE radius the shader will window this fixture with — the same
+            // `interior_reach(authored, interiorAttenScale)` the packer folds into the colour row's
+            // `.w`, so the profile predicted here is the profile drawn.
+            let r_eff = super::interior_reach(reach.map_or(fx.reach, |r| r.0), knobs.atten_scale);
+            let a = direct_profile(fx.cal_d, fx.cal_ndl, r_eff);
+            let w_fill = interior_window(fx.cal_d, INTERIOR_FILL_SPAN * r_eff, INTERIOR_FILL_POW);
+            daylight_intensity(target_lum, hue_lum, a, w_fill, &knobs) * sun_w
+        } else {
+            0.0
+        };
+        match pl {
+            Some(mut pl) if intensity > 1e-4 => {
+                pl.color = hue;
+                pl.intensity = 4.0 * std::f32::consts::PI * intensity;
+            }
+            Some(_) => {
+                commands.entity(e).remove::<WorldPointLight>();
+            }
+            None if intensity > 1e-4 => {
+                commands
+                    .entity(e)
+                    .insert(daylight_point_light(hue, intensity));
+            }
+            None => {}
+        }
+        if intensity > 1e-4 {
+            lit.push((e, *fx, intensity));
+        }
+    }
+    // `WOW_POINTS_DUMP`: the DAYLIGHT rows. They ride their own block rather than the packer's
+    // because the packer is another agent's file this round — the numbers are the same ones,
+    // printed one stage earlier, and a DAY-only block is itself the readout that the night switch
+    // above is working.
+    if let Some(mode) = std::env::var_os("WOW_POINTS_DUMP") {
+        let every = if mode == *"frame" { 0.0 } else { 1.0 };
+        let now = time.elapsed_secs_f64();
+        if now - *last_dump >= every {
+            *last_dump = now;
+            if !lit.is_empty() {
+                eprintln!(
+                    "[daylight] {} DAYLIGHT fixture(s) lit — sun_w {sun_w:.3}, target lum {target_lum:.3}, hue [{:.3},{:.3},{:.3}]",
+                    lit.len(),
+                    hue[0],
+                    hue[1],
+                    hue[2],
+                );
+                for (e, fx, i) in lit.iter().take(8) {
+                    eprintln!(
+                        "  DAYLIGHT {e}  inst {} g{}  {}{}  reach {:5.2}  cal d {:4.2} N.L {:4.2}  I {i:.4}",
+                        fx.instance,
+                        fx.group,
+                        fx.how.tag(),
+                        fx.portal.map_or(String::new(), |p| format!(" p{p}")),
+                        fx.reach,
+                        fx.cal_d,
+                        fx.cal_ndl,
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// The `PointLight` a daylight fixture carries. The same 4*PI convention every other authored
+/// source uses (`terrain_stream::spawn::fx::point_light`): the packer recovers `intensity/(4*PI)`
+/// and multiplies the linear colour by it, so the committed colour is exactly `hue * I` — which is
+/// what the calibration above solved for, and what the shader's `c_norm` reads back unchanged while
+/// `I <= 1`.
+pub fn daylight_point_light(hue: [f32; 3], intensity: f32) -> WorldPointLight {
+    WorldPointLight {
+        color: hue,
+        intensity: 4.0 * std::f32::consts::PI * intensity.max(0.0),
+        // The 48 yd CANDIDACY constant every source packs — not a reach (that rides `LightReach`).
+        range: 48.0,
+    }
+}
+
+/// The claim set of a daylight fixture — the SAME rule every MOLT fixture's claims are built by
+/// ([`benilla_formats::room_claim`]), seeded with the interior group it stands in as its MOLR
+/// referrer. Spelled here rather than at the spawn site so the reach the claim's portal hop is
+/// measured against can never drift from the reach the packer windows the fixture with.
+pub fn daylight_claims(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    seed: &DaylightSeed,
+) -> Vec<benilla_formats::room_claim::Claim> {
+    benilla_formats::room_claim::room_claims(
+        groups,
+        portals,
+        seed.pos,
+        benilla_formats::room_claim::claim_reach(daylight_authored_reach(seed.diag)),
+        &[seed.group],
+    )
+}
+
+/// The one-room visibility claim a daylight fixture carries — it exists while its own room is
+/// drawn, exactly like the MOLT fixture standing in that room (`LightRooms`, decision 0689).
+pub fn daylight_rooms(instance: Entity, group: u16) -> super::LightRooms {
+    super::LightRooms::new(crate::wmo_portal::WmoGroupVis {
+        instance,
+        groups: Arc::from([group].as_slice()),
+    })
+}
+
+/// A daylight fixture's lane is SETTLED interior, stamped at spawn rather than rayed.
+///
+/// `classify_light_lanes`'s down-ray would usually agree — the fixture stands a half-yard inside an
+/// interior group — but "usually" is the problem: it stands in a DOORWAY, the one place in a
+/// building where the surface under a light can belong to the exterior shell (the threshold plank),
+/// and a fixture flipped to the exterior lane would stop lighting the room it was built for and
+/// start pooling on the street instead. The seed already knows the answer from the authored group
+/// class, so it states it and the classifier skips the entity ([`super::LightLane::SETTLED`]).
+pub fn daylight_lane() -> super::LightLane {
+    super::LightLane {
+        interior: true,
+        generation: super::LightLane::SETTLED,
+    }
+}
+
+// ===========================================================================================
+// MONKEY (portal bleed): **the LIT room next door, glowing in the doorway.**
+//
+// THE BUG. Three seeds above stand the SUN in an opening, and every one of them needs the opening
+// to face OUTSIDE (a portal to an exterior group, an EXT-class batch, a stitch to the shell). A
+// room whose only doorways lead to other ROOMS gets nothing from them — and with `interiorDaylight`
+// defaulted to 0 (the director's call: by day light comes in at doorways and windows, not through
+// the walls) it gets nothing from the enclosed day floor either. What is left is `interiorAmbient`.
+//
+// MEASURED, the Lion's Pride Inn's front vestibule (`benilla-extract wmolights`, 2026-09-12). It is
+// group `g0`, the WMO's only TRANS-batch group, and it hangs off the end of a CHAIN of doorways:
+// porch `g11` --p0--> `g0` --p1--> `g1` --p2--> the hall `g5`, where the ten MOLT fixtures live.
+// No fixture CONTAINS-claims g0 or g1; both rooms are lit, if at all, by portal hops. And the hops
+// have run out by the time they reach p1: the nearest fixture claiming g1 (L2, 9.0 yd from p2)
+// carries 2.6 yd of unspent reach past p2's own 3.2 yd of doorway slack, and p1's centre is 5.8 yd
+// from p2's — so every claim weight at p1 is EXACTLY 0. The vestibule's budget there is the bare
+// `interiorAmbient x interiorGain` = 0.0075, i.e. `1 - exp(-0.0075 x 2.5)` = **0.019 x tex**, while
+// the `trans_night_floor` bake share renders the same planks at **0.324 x tex**: a flat grey band
+// seventeen times its own neighbour, which is what the owner photographed at 20:50 and 23:59.
+//
+// THE FIX, and it is the owner's own principle stated as a light: a doorway between two rooms
+// TRANSMITS. Stand an ordinary interior-lane point light IN such a portal, claiming both rooms, and
+// give it every frame [`BLEED_K`] times the irradiance the BRIGHTER side has at the portal plane.
+// Each room then reads a fraction of its neighbour AT the threshold (so nothing steps across the
+// doorway) and falls off inward on the room lane's own profile (so it is a doorway's spill, not a
+// second candle).
+//
+// **IN the doorway, not on the dark side of it, and that is the whole direction rule.** The obvious
+// design stands the fixture inside the darker room and points it at the lit one — but which room is
+// darker is not a fact about the building, it is a fact about the HOUR. At midnight the inn's
+// vestibule takes light from the hall through p1; at noon the porch's own DAYLIGHT fixture lights
+// the vestibule through p0 and the flow reverses, g0 into g1, which is exactly the owner's "by day
+// only doorways admit light". A fixture standing on one side would have to be moved, and a light
+// that moves through a wall when a cloud passes is worse than the seam it fixes. An APERTURE has no
+// side: it sits in the hole, it is claimed by both rooms, and only its INTENSITY and COLOUR move —
+// it carries whichever neighbour is brighter this frame, in that neighbour's own hue, and the
+// direction reverses without anything moving. The cost is that the brighter room also gains a
+// doorway glow (bounded at `BLEED_K` of what it already has there, falling off within a yard or
+// two), which is what a lit doorway looks like anyway.
+//
+// IT IS THE SAME ENTITY SHAPE as a daylight fixture, and it carries [`DaylightFixture`] as its
+// marker for exactly that reason — three exclusions ride on that component and none of them wants
+// re-deciding here: `benilla_app::torch_shadow` refuses it as a cube-shadow caster
+// (`Without<DaylightFixture>` — a 6 yd-wide doorway is not a point source), the packer skips
+// `interiorGain` on it (`Has<DaylightFixture>`, and this module folds that gain into the TARGET
+// already, so packing it again would dim the doorway twice), and it is neither a
+// [`super::SyntheticFireLight`] (no `fireLightGain` over it) nor a [`super::FlameFlicker`] (a
+// doorway does not wobble). [`BleedFixture`] beside it carries what is bleed-specific — the two
+// rooms and the portal plane — and doubles as the query filter that keeps the two per-frame
+// systems' `PointLight` access disjoint.
+//
+// NO FEEDBACK, ONE LEVEL. A bleed must not read another bleed as if it were a candle, or a run of
+// doorways would ring up without bound. But refusing outright breaks the very case this exists for:
+// the inn's vestibule is TWO doorways from the hall, so a p1 bleed that cannot see the p2 bleed sees
+// nothing at all. So [`update_bleed_fixtures`] runs the evaluation TWICE in one system over its own
+// local arrays: pass A lights every bleed from the REAL fixtures only, pass B re-lights each one
+// from the real fixtures plus the PASS-A value of any OTHER bleed standing in the room being
+// sampled. That is exactly one level of chaining, it resolves inside a single frame (no cross-frame
+// accumulation), and the order the bleeds happen to be queried in cannot change the answer.
+// ===========================================================================================
+
+/// The fraction of a neighbour's irradiance a doorway transmits, measured at the portal plane. A
+/// real opening passes most of the light that reaches it (it is a hole, not a filter) and loses the
+/// rest to the frame, the door leaf and the solid angle the wall subtends — so this is deliberately
+/// near, but under, 1: at the threshold the dark room reads a little dimmer than the lit one, which
+/// is the direction a threshold reads in life.
+pub const BLEED_K: f32 = 0.6;
+
+/// MONKEY (portal bleed): the bleed-specific half of the fixture — everything [`DaylightFixture`]
+/// has no field for, plus the marker that keeps the two per-frame systems' `PointLight` access
+/// disjoint (`update_daylight_fixtures` filters `Without<BleedFixture>`).
+#[derive(Component, Clone, Copy, Debug)]
+pub struct BleedFixture {
+    /// The two interior groups this doorway joins. Both are sampled every frame and the BRIGHTER one
+    /// is what the fixture carries — see the aperture argument in the block above.
+    pub sides: [u16; 2],
+    /// The portal's centre in BEVY WORLD space: the plane both sides are measured at, and the point
+    /// the calibration matches. World rather than model space for [`super::ClaimFade::center`]'s own
+    /// reason — the per-frame evaluation has world-space fixture positions and nothing else.
+    pub probe: Vec3,
+}
+
+/// One interior<->interior doorway, resolved in WMO MODEL space — the bleed twin of
+/// [`DaylightSeed`], and deliberately a separate type: a daylight seed's whole payload is the
+/// CALIBRATION geometry (`hz`, the floor fragment under the opening), and a bleed seed's is the two
+/// ROOMS and the plane between them.
+#[derive(Clone, Copy, Debug)]
+pub struct BleedSeed {
+    /// The two interior groups the portal joins.
+    pub sides: [u16; 2],
+    pub portal: u16,
+    /// The portal's centre, z-clamped exactly like [`seed_point`] so a two-storey arch stands near
+    /// its sill rather than at its apex. This is both the spawn position and the probe point: the
+    /// fixture IS the opening.
+    pub pos: [f32; 3],
+    pub diag: f32,
+    /// The portal polygon's area — the rank key WITHIN a quota round.
+    pub area: f32,
+    /// MONKEY (daylight quota): the round of [`quota_select`] that bought this slot. A bleed seed
+    /// serves BOTH its rooms, so its round is the LOWER of the two — a doorway into a room that has
+    /// nothing yet is a round-0 candidate even when its neighbour is already lit.
+    pub round: u8,
+}
+
+/// Every portal of one root whose BOTH sides are interior-class groups, ranked by area — the bleed
+/// seed's whole rule, and it needs nothing but the group table and the portal graph.
+///
+/// A portal only one group names is excluded by construction (its missing side is the outside, which
+/// is the DAYLIGHT portal seed's population, not this one), and so is any portal touching an
+/// exterior-class group: the porch outside the inn's front door is dark at night and lit by the sky
+/// by day, and neither is a room whose candles want carrying inward. The one size filter is
+/// [`APERTURE_MIN_DIAG`] — below it a "portal" is a sliver an artist left between two halves of one
+/// room, and a light in it would be a light inside a wall.
+pub fn bleed_seeds(groups: &[WmoGroupInfo], portals: PortalGraph<'_>) -> Vec<BleedSeed> {
+    if !bleed_enabled() {
+        return Vec::new();
+    }
+    let mut sides: Vec<(u16, Vec<u16>)> = Vec::new();
+    let note = |portal: u16, group: u16, sides: &mut Vec<(u16, Vec<u16>)>| {
+        match sides.iter_mut().find(|(p, _)| *p == portal) {
+            Some((_, gs)) => {
+                if !gs.contains(&group) {
+                    gs.push(group);
+                }
+            }
+            None => sides.push((portal, vec![group])),
+        }
+    };
+    for (gi, (start, count)) in portals.slices.iter().enumerate() {
+        let (start, count) = (usize::from(*start), usize::from(*count));
+        for r in portals.refs.get(start..start + count).unwrap_or(&[]) {
+            note(r.portal, gi as u16, &mut sides);
+            note(r.portal, r.group, &mut sides);
+        }
+    }
+    let mut out = Vec::new();
+    for (portal, gs) in &sides {
+        if gs.len() != 2 {
+            continue;
+        }
+        if !gs
+            .iter()
+            .all(|g| groups.get(usize::from(*g)).is_some_and(|g| g.interior))
+        {
+            continue;
+        }
+        let info = portals.infos.get(usize::from(*portal));
+        let verts = info.and_then(|i| {
+            let s = usize::from(i.start_vertex);
+            portals.vertices.get(s..s + usize::from(i.count))
+        });
+        let Some((lo, hi)) = verts.and_then(|v| bounds(v.iter().copied())) else {
+            continue;
+        };
+        let diag = diagonal(lo, hi);
+        if diag < APERTURE_MIN_DIAG {
+            continue;
+        }
+        let area = benilla_formats::room_claim::portal_area(&portals, *portal)
+            .unwrap_or_else(|| opening_area(lo, hi));
+        // …and a portal at or above [`benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA`] is NOT a
+        // doorway. It is a room the artist CUT IN HALF for rendering, and the claim rule already
+        // says so: `ClaimHow::Split` gives a fixture on either side a HARD claim on the other, so
+        // both halves are lit by the same candles at full weight and there is nothing to transmit.
+        // A bleed there would stand a light in the middle of one room and add `BLEED_K` of that
+        // room's own light back to it. MEASURED, this is the whole difference between "the Goldshire
+        // inn's doorways" and "Northshire abbey changed character": the abbey's four biggest portals
+        // are 252.6 / 50.9 / 50.7 / 47.1 yd^2 splits of its nave and would have taken half the
+        // building's budget, while its real doorways are the 14-16 yd^2 ones underneath them. The
+        // inn's p8 (95.9) and p3 (35.1) go the same way, which is what lets BOTH halves of its
+        // entrance chain (p2 at 20.5 and p1 at 17.3) into the eight.
+        if area >= benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA {
+            continue;
+        }
+        let (pos, _) = seed_point(lo, hi);
+        out.push(BleedSeed {
+            sides: [gs[0], gs[1]],
+            portal: *portal,
+            pos,
+            diag,
+            area,
+            round: 0,
+        });
+    }
+    // Deterministic, largest first — the shared budget TRUNCATES, so an unstable order would give
+    // the same building different doorways on different launches.
+    out.sort_by(|a, b| b.area.total_cmp(&a.area).then(a.portal.cmp(&b.portal)));
+    out
+}
+
+/// **THE ONE SELECTION ENTRY POINT** a placement calls: every opening of one WMO root that gets a
+/// fixture, daylight and bleed together, sharing one budget ([`daylight_budget`]) and ranked against
+/// each other by the [`quota_select`] rule.
+///
+/// One budget rather than two because the resource being spent is the same one — slots in the packed
+/// point table, and fragments walked by every interior pixel of the building — and because the
+/// ranking question is the same question: which of this placement's openings matter.
+///
+/// The Lion's Pride Inn's eight are unchanged by the quota (10 interior groups is under
+/// [`DAYLIGHT_DISTRICT_ROOMS`], and its openings are spread roughly one per room anyway): the hall
+/// doorway p2 (20.5, bleed), its porch door p0 (17.3, daylight) and the vestibule doorway p1 (17.3,
+/// bleed) — both halves of its entrance chain, because the two portals that used to outrank them
+/// (95.9 and 35.1 yd^2) are SPLIT cuts the bleed seed refuses.
+///
+/// Ties go to DAYLIGHT: the sun standing in an opening is the bigger visual fact, and the inn's
+/// p0/p1 pair is exactly a tie at 17.34 yd^2.
+pub fn placement_openings<'a, I>(
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
+    batches: I,
+) -> (Vec<DaylightSeed>, Vec<BleedSeed>)
+where
+    I: IntoIterator<Item = (u16, bool, &'a [[f32; 3]])>,
+{
+    let day = daylight_seeds_ranked(groups, portals, batches);
+    let bleed = bleed_seeds(groups, portals);
+    quota_select(&day, &bleed, daylight_budget(groups))
+}
+
+/// MONKEY (daylight quota): **one fixture per ROOM before any room gets a second** — the ranking
+/// half of the city fix, and the reason raising the budget alone would not have been enough.
+///
+/// THE BUG THE OLD RANK HAD. Both lanes arrived sorted by opening AREA and were merged straight into
+/// the budget, so the budget went to the placement's biggest HOLES rather than to its rooms. That is
+/// the right question for a building — a facade's openings are all in a room or two, and area really
+/// does say which one matters — and exactly the wrong one for a district, where the areas span two
+/// orders of magnitude across rooms that are all equally dark inside their own door. MEASURED at
+/// Stormwind (see [`daylight_budget`]): four canal-mouth portals at 338 yd^2 took HALF the city's
+/// budget for four groups of one canal, while 68 interior groups holding an authored exterior portal
+/// — every tavern, shop and vestibule — sat at 8-16 yd^2 and could never rank. Raising the cap alone
+/// does not fix that: at a cap of 40 the next 32 winners are still 29-115 yd^2 apertures in the
+/// cathedral and the wine shop, and the taverns are still last.
+///
+/// THE RULE. Round-robin over rooms. A candidate's ROUND is how many fixtures its room already holds
+/// ON ITS OWN LANE (for a bleed, the LOWER of its two rooms — a doorway into a room with no bleed yet
+/// is a round-0 candidate even when its neighbour has one, because it is that room's first). Take the
+/// lowest round; break ties by area descending, then daylight over bleed, then seed order. So every
+/// room gets its best opening before any room gets a second, and WITHIN a round the old area rank is
+/// untouched — which is why a placement whose openings all share one room gets a byte-identical
+/// answer to the old merge's.
+///
+/// TWO BOOKS, NOT ONE, and the Lion's Pride Inn is why. A daylight fixture and a bleed fixture serve
+/// DIFFERENT HOURS: the sun in a doorway is gone after dark (`update_daylight_fixtures` strips its
+/// `PointLight` outright), and a doorway carrying the next room's candles is worth nothing at noon
+/// beside the sun. So a room holding one is not served against the other, and charging both to one
+/// counter mis-ranks exactly the case the bleed feature was built for. MEASURED: with ONE counter
+/// the inn loses `p1`, the vestibule doorway — its two rooms `g0` and `g1` are both already
+/// "served", `g0` by the porch DAYLIGHT portal `p0` and `g1` by the hall bleed `p2` — and the
+/// vestibule goes back to `interiorAmbient` at 20:50, the exact frame the owner photographed. With
+/// separate books `p1` is still a round-0 bleed and **the inn's eight come out identical to the old
+/// area merge's, fixture for fixture**. Northshire abbey moves by one swap (its `g7<->g2` doorway,
+/// which is the SECOND bleed of both its rooms, for `g9<->g8`, which is `g8`'s first).
+///
+/// COST. `O(budget x candidates)` with no allocation per step: 154 x 154 = 23 716 float compares for
+/// Stormwind, once, on the frame its placement spawns — against the 162 ms the boundary pass costs on
+/// the same root (and which [`SEAM_VERT_BUDGET`] already refuses). A linear rescan per slot rather
+/// than a heap because the key CHANGES as rooms fill, which is the thing a heap cannot express.
+pub fn quota_select(
+    day: &[DaylightSeed],
+    bleed: &[BleedSeed],
+    budget: usize,
+) -> (Vec<DaylightSeed>, Vec<BleedSeed>) {
+    // How many fixtures each room already holds, **keyed by `(group, daylight?)`** — the two books of
+    // the rule above. A `HashMap` rather than a `Vec` indexed by group: the caller's group ids are
+    // absolute indices into a root that may have 306 of them while eight rooms are ever touched —
+    // and nothing here ITERATES the map, so its non-deterministic order can never reach the output.
+    let mut taken: HashMap<(u16, bool), u8> = HashMap::new();
+    let mut used_day = vec![false; day.len()];
+    let mut used_bleed = vec![false; bleed.len()];
+    let (mut day_keep, mut bleed_keep) = (Vec::new(), Vec::new());
+    while day_keep.len() + bleed_keep.len() < budget {
+        // The comparison key, smallest wins: `(round, -area, lane, index)`. `lane` is 0 for daylight
+        // and 1 for bleed — the tie the inn's p0/p1 pair lands on. `index` makes the order TOTAL, so
+        // two identical openings can never swap between launches.
+        let mut best: Option<(u8, f32, u8, usize, bool)> = None;
+        let consider = |round: u8, area: f32, lane: u8, i: usize, is_day: bool, best: &mut Option<(u8, f32, u8, usize, bool)>| {
+            let key = (round, -area, lane, i);
+            if best.is_none_or(|b| key < (b.0, b.1, b.2, b.3)) {
+                *best = Some((key.0, key.1, key.2, key.3, is_day));
+            }
+        };
+        for (i, s) in day.iter().enumerate() {
+            if used_day[i] {
+                continue;
+            }
+            let round = taken.get(&(s.group, true)).copied().unwrap_or(0);
+            consider(round, s.area, 0, i, true, &mut best);
+        }
+        for (i, s) in bleed.iter().enumerate() {
+            if used_bleed[i] {
+                continue;
+            }
+            // The LOWER of the two rooms, on the BLEED book — see THE RULE above.
+            let round = s
+                .sides
+                .iter()
+                .map(|g| taken.get(&(*g, false)).copied().unwrap_or(0))
+                .min()
+                .unwrap_or(0);
+            consider(round, s.area, 1, i, false, &mut best);
+        }
+        let Some((round, _, _, i, is_day)) = best else {
+            break; // every candidate spent
+        };
+        // The round is stamped on the KEPT copy (the dump's `q<n>` column) and the rooms it serves
+        // are charged for it, which is what moves the next pick on to the rooms still at zero.
+        if is_day {
+            used_day[i] = true;
+            let mut s = day[i];
+            s.round = round;
+            *taken.entry((s.group, true)).or_default() += 1;
+            day_keep.push(s);
+        } else {
+            used_bleed[i] = true;
+            let mut s = bleed[i];
+            s.round = round;
+            // BOTH rooms are charged: the doorway lights the pair, so neither of them is still
+            // waiting for its first one.
+            for g in s.sides {
+                *taken.entry((g, false)).or_default() += 1;
+            }
+            bleed_keep.push(s);
+        }
+    }
+    quota_dump(&day_keep, &bleed_keep, day.len() + bleed.len(), budget);
+    (day_keep, bleed_keep)
+}
+
+/// MONKEY (daylight quota): the selection's own `WOW_POINTS_DUMP` block — WHY each opening got a
+/// slot, printed once when the placement spawns.
+///
+/// It rides here rather than on the per-frame `DAYLIGHT` lines because the round is a SELECTION-time
+/// fact and `DaylightFixture` is read (and struct-literal-built) by `global_light.rs`, another
+/// agent's file this round — a new field there would be a merge conflict for a readout. The format
+/// is the same family as [`update_daylight_fixtures`]'s: a header with the totals, then one indented
+/// row per fixture. `q<n>` is the reason: **`q0` = the first light this room has ever had** (the
+/// rule's whole point, and what a city's shop interiors now win on), `q1+` = its room was already
+/// served and this is its second opening. In a city an all-`q0` block IS the quota working; a block
+/// full of `q1`/`q2` on one group is the old failure mode coming back.
+fn quota_dump(day: &[DaylightSeed], bleed: &[BleedSeed], candidates: usize, budget: usize) {
+    if std::env::var_os("WOW_POINTS_DUMP").is_none() || day.is_empty() && bleed.is_empty() {
+        return;
+    }
+    let rooms: HashSet<u16> = day
+        .iter()
+        .map(|s| s.group)
+        .chain(bleed.iter().flat_map(|s| s.sides))
+        .collect();
+    eprintln!(
+        "[daylight] quota: {} of {candidates} opening(s) kept on a budget of {budget} — {} daylight + {} bleed over {} room(s)",
+        day.len() + bleed.len(),
+        day.len(),
+        bleed.len(),
+        rooms.len(),
+    );
+    for s in day {
+        eprintln!(
+            "  QUOTA q{}  g{}  {}{}  area {:7.2} yd^2  diag {:5.2}",
+            s.round,
+            s.group,
+            s.how.tag(),
+            s.portal.map_or(String::new(), |p| format!(" p{p}")),
+            s.area,
+            s.diag,
+        );
+    }
+    for s in bleed {
+        eprintln!(
+            "  QUOTA q{}  g{} <-> g{}  bleed p{}  area {:7.2} yd^2  diag {:5.2}",
+            s.round, s.sides[0], s.sides[1], s.portal, s.area, s.diag,
+        );
+    }
+}
+
+/// `entry * (1 - smoothstep(0, radius, max(|P - center| - slack, 0)))` — the CPU mirror of
+/// `static_gx.wgsl`'s `interior_room_admits` fade arm. `radius == 0` is the hard claim.
+fn claim_fade_weight(radius: f32, slack: f32, entry: f32, center: Vec3, p: Vec3) -> f32 {
+    if radius <= 0.0 {
+        return 1.0;
+    }
+    let t = (((p - center).length() - slack).max(0.0) / radius.max(1e-4)).clamp(0.0, 1.0);
+    entry * (1.0 - t * t * (3.0 - 2.0 * t))
+}
+
+/// `INTERIOR_CORE_GAIN / (1 + (d/INTERIOR_CORE_YD)^2)` — the shader's soft-core inverse square, split
+/// out of [`direct_profile`] because the bleed lane measures IRRADIANCE (no surface, so no `N.L`)
+/// while the daylight calibration measures a floor fragment.
+fn core_atten(d: f32) -> f32 {
+    INTERIOR_CORE_GAIN / (1.0 + (d / INTERIOR_CORE_YD).powi(2))
+}
+
+/// `c / max(1, max channel)` — `static_gx.wgsl`'s `c_norm`. The table commits raw over-gamut colour
+/// x intensity and the shader normalises it per fixture, so anything predicting the shader's answer
+/// has to normalise it too.
+fn commit_norm(c: [f32; 3]) -> [f32; 3] {
+    let peak = c[0].max(c[1]).max(c[2]).max(1.0);
+    [c[0] / peak, c[1] / peak, c[2] / peak]
+}
+
+/// `WOW_BLEED=0` — the feature's own kill switch, read once, for the same A/B reason
+/// [`daylight_modes`] has one. Anything else (absent included) leaves it on.
+fn bleed_enabled() -> bool {
+    static ON: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *ON.get_or_init(|| {
+        !matches!(
+            std::env::var("WOW_BLEED").ok().as_deref(),
+            Some("0" | "off" | "false")
+        )
+    })
+}
+
+impl BleedSeed {
+    /// The shared component this seed becomes. `cal_d`/`cal_ndl` state the BLEED lane's calibration
+    /// rather than the daylight lane's: the match is made at the PORTAL PLANE, [`NUDGE_YD`] from the
+    /// fixture, as irradiance (`N.L = 1`) — a doorway has no one surface normal, and the wrapped
+    /// Lambert spans only 1/3..1 anyway, so choosing a normal would add a factor to both sides of the
+    /// ratio and information to neither. `group` is the first side, for the dump and the claim head;
+    /// the pair that matters lives on [`BleedFixture::sides`].
+    pub fn fixture(&self, instance: Entity) -> DaylightFixture {
+        DaylightFixture {
+            instance,
+            group: self.sides[0],
+            portal: Some(self.portal),
+            how: DaylightHow::Bleed,
+            reach: daylight_authored_reach(self.diag),
+            cal_d: NUDGE_YD,
+            cal_ndl: 1.0,
+        }
+    }
+
+    /// The claim set — the SAME rule every other fixture's is built by, seeded with BOTH rooms as
+    /// its MOLR referrers, which is the aperture argument spelled in claim terms: the doorway is not
+    /// in one room, it is in the wall between two, and it lights both. Groups one hop beyond either
+    /// come in soft, exactly as they do for a candle standing in the room.
+    pub fn claims(
+        &self,
+        groups: &[WmoGroupInfo],
+        portals: PortalGraph<'_>,
+    ) -> Vec<benilla_formats::room_claim::Claim> {
+        benilla_formats::room_claim::room_claims(
+            groups,
+            portals,
+            self.pos,
+            benilla_formats::room_claim::claim_reach(daylight_authored_reach(self.diag)),
+            &self.sides,
+        )
+    }
+
+    /// The VISIBILITY gate — the doorway exists while EITHER of its rooms is drawn
+    /// ([`crate::wmo_portal::WmoGroupVis::drawn_by`] ORs), which is the same fail-open a prop several
+    /// rooms name gets. A doorway culled with one of its two rooms would switch a light off in the
+    /// room still on screen.
+    pub fn rooms(&self, instance: Entity) -> super::LightRooms {
+        super::LightRooms::new(crate::wmo_portal::WmoGroupVis {
+            instance,
+            groups: Arc::from(self.sides.as_slice()),
+        })
+    }
+}
+
+/// One interior-lane source as the bleed evaluation needs it — the packer's own arithmetic, minus
+/// the flicker (a bleed must not breathe with the hearth it carries: the pool it feeds is a whole
+/// doorway, and a wobbling doorway is a wobbling building).
+struct BleedSource<'a> {
+    pos: Vec3,
+    /// Committed colour, NORMALISED like the shader's `c_norm`.
+    c_norm: [f32; 3],
+    r_eff: f32,
+    claims: Option<&'a LightLitRooms>,
+}
+
+/// The irradiance (direct + fill, as a colour) the fixtures claiming `group` of `instance` deliver
+/// at `p` — `static_gx.wgsl`'s `interior_room_light` with `N.L` pinned to 1 and the ambient floor
+/// left out. The floor is excluded because the OTHER side has its own copy of it; carrying the
+/// neighbour's across would make every doorway in the world transmit `interiorAmbient` as if it were
+/// light, and every room would end up at twice its own floor.
+fn room_irradiance(
+    sources: &[BleedSource<'_>],
+    extra: &[(Vec3, [f32; 3], f32)],
+    p: Vec3,
+    instance: Entity,
+    group: u16,
+    k_fill: f32,
+) -> [f32; 3] {
+    let mut direct = [0.0f32; 3];
+    let mut fill = [0.0f32; 3];
+    let mut add = |pos: Vec3, c_norm: [f32; 3], r_eff: f32, w: f32| {
+        let d = (pos - p).length();
+        if d > INTERIOR_FILL_SPAN * r_eff {
+            return;
+        }
+        let a = core_atten(d) * interior_window(d, r_eff, INTERIOR_DIRECT_POW) * w;
+        let fw = k_fill * interior_window(d, INTERIOR_FILL_SPAN * r_eff, INTERIOR_FILL_POW) * w;
+        // The fill is HALF-DESATURATED and taken as a MAX over fixtures, exactly like the shader: an
+        // ambient room glow that summed would scale with the candle count.
+        let grey = 0.299 * c_norm[0] + 0.587 * c_norm[1] + 0.114 * c_norm[2];
+        for i in 0..3 {
+            direct[i] += c_norm[i] * a;
+            fill[i] = fill[i].max(0.5 * (c_norm[i] + grey) * fw);
+        }
+    };
+    for s in sources {
+        // Range first, claim second -- the reverse of the shader's order, deliberately. The shader
+        // tests the gate first because a fragment's room claims one or two of the table's fixtures
+        // and the gate throws away the most; here the loop is over every interior source in the
+        // WORLD against a handful of doorways, so the cheap squared-distance reject is what throws
+        // away the most. The answer is identical either way (both terms multiply).
+        if (s.pos - p).length_squared() > (INTERIOR_FILL_SPAN * s.r_eff).powi(2) {
+            continue;
+        }
+        let w = claim_weight(s.claims, instance, group, p);
+        if w > 0.0 {
+            add(s.pos, s.c_norm, s.r_eff, w);
+        }
+    }
+    // The ONE level of chaining: another doorway's bleed, standing in the room being sampled, with
+    // the value pass A gave it. It claims that room hard (both its sides are MOLR seeds), so its
+    // weight there is 1.
+    for (pos, c_norm, r_eff) in extra {
+        add(*pos, *c_norm, *r_eff, 1.0);
+    }
+    [
+        direct[0] + fill[0],
+        direct[1] + fill[1],
+        direct[2] + fill[2],
+    ]
+}
+
+/// The CPU mirror of `static_gx.wgsl`'s `interior_room_admits`, NON-strict arm: may this fixture
+/// light room `(instance, group)`, and at what weight. Every fail-OPEN arm the shader has is kept
+/// (no claims = the packer's UNGATED head, which is also what `interiorRoomGate 0` packs), because
+/// predicting a gate with a stricter rule than the gate's own would calibrate a doorway against light
+/// the room is not actually getting.
+fn claim_weight(claims: Option<&LightLitRooms>, instance: Entity, group: u16, p: Vec3) -> f32 {
+    let Some(c) = claims.filter(|c| !c.rooms.groups.is_empty()) else {
+        return 1.0;
+    };
+    if c.rooms.instance != instance {
+        return 0.0;
+    }
+    // The packer keeps at most `ROOM_CLAIM_MAX` claims per fixture (highest priority first), so a
+    // claim past the cap is one the shader will never see.
+    let n = c.rooms.groups.len().min(super::ROOM_CLAIM_MAX);
+    for k in 0..n {
+        if c.rooms.groups[k] & !super::LIT_ROOM_EXT_DENY != group {
+            continue;
+        }
+        let Some(f) = c.fades.get(k) else {
+            return 1.0; // a producer with no fades: every claim hard, the pre-soft-claims gate
+        };
+        return claim_fade_weight(f.radius, f.slack, f.entry, f.center, p);
+    }
+    0.0
+}
+
+/// The packed intensity in `[0, 1]` that makes this fixture deliver `BLEED_K x lit` at the portal
+/// plane, and the hue it delivers it in (the brighter side's own chroma renormalised to peak 1 — what
+/// the packed colour carries, so the shader's `c_norm` reads back exactly `hue * I` while `I <= 1`).
+///
+/// Both sides of the equality are IRRADIANCE in the room lane's own pre-rolloff units, so no exposure
+/// inversion is involved and the answer cannot be perturbed by the user's `interiorExposure` — a
+/// budget matched against a budget stays matched however the rolloff is tuned. That is the difference
+/// from the daylight calibration, which has to hit a DISPLAY value the reference sky law is already
+/// rendering a plank away.
+fn bleed_intensity(lit: [f32; 3], r_eff: f32, k_fill: f32) -> ([f32; 3], f32) {
+    let peak = lit[0].max(lit[1]).max(lit[2]);
+    if peak <= 1e-6 {
+        return ([0.0; 3], 0.0);
+    }
+    let hue = [lit[0] / peak, lit[1] / peak, lit[2] / peak];
+    let hue_lum = luminance(hue).max(1e-3);
+    // What this fixture is worth at the portal plane: it stands NUDGE_YD from it. The fill is taken
+    // as ADDITIVE here where the shader takes a max over fixtures — at half a yard the bleed wins that
+    // max against anything else in the room, and where it does not the fixture simply lands a touch
+    // under nominal, which errs toward the dark side of the trade.
+    let self_factor = core_atten(NUDGE_YD) * interior_window(NUDGE_YD, r_eff, INTERIOR_DIRECT_POW)
+        + k_fill * interior_window(NUDGE_YD, INTERIOR_FILL_SPAN * r_eff, INTERIOR_FILL_POW);
+    if self_factor <= 1e-6 {
+        return (hue, 0.0);
+    }
+    (
+        hue,
+        (BLEED_K * luminance(lit) / (hue_lum * self_factor)).clamp(0.0, 1.0),
+    )
+}
+
+/// Re-aim every bleed fixture at this frame's room light — see the PORTAL BLEED block above for the
+/// rule, for why the fixture is an aperture with no side, and for why the evaluation runs in two
+/// passes inside one system.
+///
+/// Scheduled after [`update_daylight_fixtures`] (so a doorway reading the porch's daylight fixture as
+/// its brighter side reads THIS frame's sun, not last frame's) and before
+/// `global_light::classify_light_lanes`, which is chained before the packer. The one-frame lag that
+/// remains is structural and harmless: `update_daylight_fixtures` INSERTS and REMOVES its `PointLight`
+/// through `Commands`, so on the single frame a daylight fixture switches on at dawn or off at dusk
+/// the bleed reading it is one frame stale. Its steady-state value is written in place and is current.
+pub fn update_bleed_fixtures(
+    mut commands: Commands,
+    knobs: Res<DynamicInteriors>,
+    fire_gain: Res<FireLightGain>,
+    // MONKEY (spellLightGain): the spell lane's own dial, mirrored here for the same reason the fire
+    // one is — a doorway carries what its neighbour room is WORTH after the dials, not before.
+    spell_gain: Res<SpellLightGain>,
+    mut bleeds: Query<(
+        Entity,
+        &DaylightFixture,
+        &BleedFixture,
+        &GlobalTransform,
+        Option<&LightReach>,
+        Option<&mut WorldPointLight>,
+    )>,
+    sources: Query<
+        (
+            &WorldPointLight,
+            &GlobalTransform,
+            Option<&LightReach>,
+            Option<&LightLitRooms>,
+            Option<&LightLane>,
+            Option<&super::LightRooms>,
+            Has<SyntheticFireLight>,
+            Has<DaylightFixture>,
+            // MONKEY (spellLightGain): last, and it OVERRIDES the synthetic bit below — every spell
+            // light also carries [`SyntheticFireLight`], so testing fire first would put a fireball
+            // on the hearth dial.
+            Has<SpellFxLight>,
+        ),
+        Without<BleedFixture>,
+    >,
+    time: Res<Time>,
+    mut last_dump: Local<f64>,
+) {
+    // The room lane being off is the feature being off, exactly as for a daylight fixture.
+    let on = knobs.enabled && bleed_enabled();
+    // The packed fill gain — `interiorFill x interiorGain`, the same product `build_light_data`
+    // writes into `point_count.z`.
+    let k_fill = knobs.fill.max(0.0) * knobs.interior_gain;
+    // Which placements have a doorway to light at all. A source claiming a DIFFERENT building is
+    // refused by `claim_weight`'s instance compare anyway, so dropping it here changes no answer --
+    // it just stops a city's few thousand interior fixtures being walked once per doorway per side
+    // per pass. An UNGATED source (no claims) is kept: the gate fails open on it, so it lights every
+    // room in range, this building's included.
+    let live: std::collections::HashSet<Entity> =
+        bleeds.iter().map(|(_, fx, ..)| fx.instance).collect();
+    let src: Vec<BleedSource<'_>> = if on && !live.is_empty() {
+        sources
+            .iter()
+            .filter_map(|(pl, gt, reach, lit_rooms, lane, rooms, synthetic, daylight, spell)| {
+                if lit_rooms.is_some_and(|c| {
+                    !c.rooms.groups.is_empty() && !live.contains(&c.rooms.instance)
+                }) {
+                    return None;
+                }
+                // The packer's own lane verdict, fallback included (a light lives a frame or two
+                // before the classifier's first pass).
+                if !lane.map_or_else(|| rooms.is_some(), |l| l.interior) {
+                    return None;
+                }
+                let c = pl.color;
+                let base = pl.intensity / (4.0 * std::f32::consts::PI);
+                // `fireLightGain` IS mirrored (a dial that darkens the hearth must darken what the
+                // doorway carries of it); the FLICKER deliberately is not.
+                //
+                // MONKEY (spellLightGain): and the spell dial the same way, in the same ORDER the
+                // packer folds them (`global_light::build_light_data` ~:1328) — spell first, fire
+                // second, because a spell light carries BOTH markers and the two dials answer
+                // different questions (a hearth's brightness vs how hard combat may strobe a room).
+                // Without the mirror a player who turned `spellLightGain` to 0 would still see the
+                // fireball's light arrive through the doorway while its own row was dark.
+                let s = base
+                    * if spell {
+                        spell_gain.0.max(0.0)
+                    } else if synthetic {
+                        fire_gain.0.max(0.0)
+                    } else {
+                        1.0
+                    };
+                // …and `interiorGain`, which the packer applies to every interior fixture EXCEPT a
+                // `DaylightFixture`. Mirroring that exclusion here is what keeps the doorway from
+                // being dimmed twice: a bleed fixture IS a `DaylightFixture`, so the packer will not
+                // scale it, and the gain therefore has to be in the TARGET.
+                let g = if daylight { 1.0 } else { knobs.interior_gain };
+                let c_norm = commit_norm([
+                    (c[0] * s * g).max(0.0),
+                    (c[1] * s * g).max(0.0),
+                    (c[2] * s * g).max(0.0),
+                ]);
+                let r = reach
+                    .map(|r| r.0)
+                    .filter(|r| *r > 0.5)
+                    .unwrap_or_else(|| super::m2_light_reach(base));
+                Some(BleedSource {
+                    pos: gt.translation(),
+                    c_norm,
+                    r_eff: super::interior_reach(r, knobs.atten_scale),
+                    claims: lit_rooms,
+                })
+            })
+            .collect()
+    } else {
+        Vec::new()
+    };
+
+    /// One bleed fixture's per-frame working row — the two passes' shared scratch.
+    struct Row {
+        e: Entity,
+        instance: Entity,
+        sides: [u16; 2],
+        portal: u16,
+        authored: f32,
+        probe: Vec3,
+        pos: Vec3,
+        r_eff: f32,
+        hue: [f32; 3],
+        i: f32,
+    }
+    // The brighter of the two sides, as a colour: the aperture carries whichever neighbour has more
+    // light at the plane THIS frame, which is how the direction reverses between midnight and noon
+    // without the fixture moving.
+    let brighter = |a: [f32; 3], b: [f32; 3]| if luminance(a) >= luminance(b) { a } else { b };
+
+    // --- PASS A: every bleed lit by the REAL fixtures alone.
+    let mut rows: Vec<Row> = Vec::new();
+    for (e, fx, bl, gt, reach, _) in &bleeds {
+        let r_eff = super::interior_reach(reach.map_or(fx.reach, |r| r.0), knobs.atten_scale);
+        let lit = if on {
+            brighter(
+                room_irradiance(&src, &[], bl.probe, fx.instance, bl.sides[0], k_fill),
+                room_irradiance(&src, &[], bl.probe, fx.instance, bl.sides[1], k_fill),
+            )
+        } else {
+            [0.0; 3]
+        };
+        let (hue, i) = bleed_intensity(lit, r_eff, k_fill);
+        rows.push(Row {
+            e,
+            instance: fx.instance,
+            sides: bl.sides,
+            portal: fx.portal.unwrap_or(u16::MAX),
+            authored: fx.reach,
+            probe: bl.probe,
+            pos: gt.translation(),
+            r_eff,
+            hue,
+            i,
+        });
+    }
+    // --- PASS B: …and again, with each OTHER bleed's PASS-A value standing in the room being
+    // sampled. One level, and no more: `extra` is built from `rows` as pass A left it, never from the
+    // values being written now, so a ring of doorways cannot ring up. A doorway's own contribution is
+    // excluded from both of its own sides (`j != i`) — it must never calibrate against itself.
+    // Grouped by placement first: a doorway can only ever chain to a doorway of its OWN building, and
+    // a city holds hundreds of both, so the alternative is a quadratic scan across every building in
+    // the frame to find the seven rows that could matter.
+    let mut by_instance: HashMap<Entity, Vec<usize>> = HashMap::new();
+    for (i, r) in rows.iter().enumerate() {
+        by_instance.entry(r.instance).or_default().push(i);
+    }
+    let mut out: Vec<([f32; 3], f32, [f32; 3])> = Vec::with_capacity(rows.len());
+    for (i, r) in rows.iter().enumerate() {
+        let siblings = by_instance.get(&r.instance).map_or(&[][..], |v| &v[..]);
+        let side_extra = |g: u16| -> Vec<(Vec3, [f32; 3], f32)> {
+            siblings
+                .iter()
+                .map(|j| (*j, &rows[*j]))
+                .filter(|(j, o)| *j != i && o.i > 1e-4 && o.sides.contains(&g))
+                .map(|(_, o)| {
+                    (
+                        o.pos,
+                        [o.hue[0] * o.i, o.hue[1] * o.i, o.hue[2] * o.i],
+                        o.r_eff,
+                    )
+                })
+                .collect()
+        };
+        let lit = if on {
+            brighter(
+                room_irradiance(
+                    &src,
+                    &side_extra(r.sides[0]),
+                    r.probe,
+                    r.instance,
+                    r.sides[0],
+                    k_fill,
+                ),
+                room_irradiance(
+                    &src,
+                    &side_extra(r.sides[1]),
+                    r.probe,
+                    r.instance,
+                    r.sides[1],
+                    k_fill,
+                ),
+            )
+        } else {
+            [0.0; 3]
+        };
+        let (hue, intensity) = bleed_intensity(lit, r.r_eff, k_fill);
+        out.push((hue, intensity, lit));
+    }
+    for (r, (hue, intensity, _)) in rows.iter().zip(out.iter()) {
+        // Same existence rule as a daylight fixture, and for the same reason: the packer has no
+        // zero-intensity skip, so a doorway between two unlit rooms must leave the table outright
+        // rather than hold one of its 256 slots to contribute nothing.
+        let Ok((_, _, _, _, _, pl)) = bleeds.get_mut(r.e) else {
+            continue;
+        };
+        match pl {
+            Some(mut pl) if *intensity > 1e-4 => {
+                pl.color = *hue;
+                pl.intensity = 4.0 * std::f32::consts::PI * intensity;
+            }
+            Some(_) => {
+                commands.entity(r.e).remove::<WorldPointLight>();
+            }
+            None if *intensity > 1e-4 => {
+                commands
+                    .entity(r.e)
+                    .insert(daylight_point_light(*hue, *intensity));
+            }
+            None => {}
+        }
+    }
+    // `WOW_POINTS_DUMP`: the BLEED rows, tagged like the daylight ones and carrying the number the
+    // whole rule turns on — the brighter side's irradiance at the portal plane.
+    if let Some(mode) = std::env::var_os("WOW_POINTS_DUMP") {
+        let every = if mode == *"frame" { 0.0 } else { 1.0 };
+        let now = time.elapsed_secs_f64();
+        if now - *last_dump >= every {
+            *last_dump = now;
+            let n = out.iter().filter(|(_, i, _)| *i > 1e-4).count();
+            if n > 0 {
+                eprintln!(
+                    "[daylight] {n} BLEED fixture(s) lit — k {BLEED_K:.2}, fill gain {k_fill:.4}"
+                );
+                for (r, (hue, i, lit)) in rows
+                    .iter()
+                    .zip(out.iter())
+                    .filter(|(_, (_, i, _))| *i > 1e-4)
+                    .take(8)
+                {
+                    eprintln!(
+                        "  BLEED {}  inst {} g{} <-> g{}  p{}  reach {:5.2} (R {:5.2})  lit [{:.5},{:.5},{:.5}] lum {:.5}  hue [{:.3},{:.3},{:.3}]  I {i:.5}",
+                        r.e,
+                        r.instance,
+                        r.sides[0],
+                        r.sides[1],
+                        r.portal,
+                        r.authored,
+                        r.r_eff,
+                        lit[0],
+                        lit[1],
+                        lit[2],
+                        luminance(*lit),
+                        hue[0],
+                        hue[1],
+                        hue[2],
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Wire the per-frame aim in. One `add_systems` — the fixtures themselves are spawned by the
+/// placement lane and need no resource of their own.
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        PostUpdate,
+        (
+            update_daylight_fixtures,
+            // MONKEY (portal bleed): AFTER the daylight aim, so a doorway reading the porch's
+            // daylight fixture as its lit-side source reads this frame's sun, not last frame's.
+            update_bleed_fixtures,
+        )
+            .chain()
+            .before(super::global_light::classify_light_lanes),
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use benilla_formats::{WmoPortalInfo, WmoPortalRef};
+
+    fn group(interior: bool, lo: [f32; 3], hi: [f32; 3]) -> WmoGroupInfo {
+        WmoGroupInfo {
+            interior,
+            show_skybox: false,
+            bbox_min: lo,
+            bbox_max: hi,
+        }
+    }
+
+    /// The reach formula: linear in the opening's diagonal, floored at 6 and capped at 20.
+    #[test]
+    fn reach_is_the_clamped_opening_width() {
+        assert_eq!(daylight_reach(0.0), 6.0); // the floor, not 4
+        assert_eq!(daylight_reach(2.0), 7.0);
+        assert!((daylight_reach(2.6) - 7.9).abs() < 1e-5); // a 1.2 x 2.2 yd door
+        assert_eq!(daylight_reach(100.0), 20.0); // the cap
+        // Monotone in between, so a wider opening never throws light LESS far.
+        let mut prev = 0.0;
+        for i in 0..40 {
+            let r = daylight_reach(i as f32 * 0.5);
+            assert!(r >= prev);
+            prev = r;
+        }
+    }
+
+    /// The class test: exactly one INTERIOR side and an exterior (or absent) other side.
+    #[test]
+    fn only_exterior_facing_portals_are_doorways() {
+        // g0 interior room (west of the doorway plane), g1 exterior shell, g2 a second interior
+        // room (east of it) — the two rooms sit on OPPOSITE sides of x = 0, which is what gives the
+        // nudge a sign to find.
+        let groups = [
+            group(true, [-10.0, -5.0, 0.0], [0.0, 5.0, 5.0]),
+            group(false, [-20.0, -20.0, 0.0], [20.0, 20.0, 10.0]),
+            group(true, [0.0, -5.0, 0.0], [10.0, 5.0, 5.0]),
+        ];
+        // One 2 x 2 yd quad reused by all three portals (position is irrelevant to the class test).
+        let vertices = [
+            [0.0, -1.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, -1.0, 2.0],
+        ];
+        let infos = [
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+        ];
+        // p0: g0 <-> g1 (interior to exterior — a doorway).
+        // p1: g0 <-> g2 (room to room — not).
+        // p2: named by g2 alone (a portal to the outside — a doorway).
+        let refs = [
+            WmoPortalRef { portal: 0, group: 1, side: 1 },
+            WmoPortalRef { portal: 1, group: 2, side: 1 },
+            WmoPortalRef { portal: 0, group: 0, side: -1 },
+            WmoPortalRef { portal: 1, group: 0, side: -1 },
+            WmoPortalRef { portal: 2, group: 2, side: 1 },
+        ];
+        // g0 owns refs 0..2, g1 owns 2..3, g2 owns 3..5.
+        let slices = [(0, 2), (2, 1), (3, 2)];
+        let portals = PortalGraph {
+            vertices: &vertices,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        let seeds = daylight_seeds(&groups, portals, std::iter::empty());
+        let mut found: Vec<(u16, u16)> =
+            seeds.iter().map(|s| (s.portal.unwrap(), s.group)).collect();
+        found.sort_unstable();
+        // p0 seeded into the interior side g0; p2 into g2; p1 (room to room) refused outright.
+        assert_eq!(found, vec![(0, 0), (2, 2)]);
+        // …and the seed really did step INTO the room: the quad lies on the plane x = 0, so the
+        // nudge must have taken it a full NUDGE_YD off that plane.
+        let s = seeds.iter().find(|s| s.portal == Some(0)).unwrap();
+        assert!((s.pos[0] + NUDGE_YD).abs() < 1e-4, "pos {:?}", s.pos);
+        // …and the OTHER room's own doorway steps the other way, off the same plane.
+        let s2 = seeds.iter().find(|s| s.portal == Some(2)).unwrap();
+        assert!((s2.pos[0] - NUDGE_YD).abs() < 1e-4, "pos {:?}", s2.pos);
+    }
+
+    /// The APERTURE seed: an EXT-class batch of an INTERIOR group, and nothing else.
+    #[test]
+    fn apertures_are_ext_batches_of_interior_groups() {
+        let groups = [
+            group(true, [-5.0, -5.0, 0.0], [5.0, 5.0, 5.0]),
+            group(false, [-20.0, -20.0, 0.0], [20.0, 20.0, 10.0]),
+        ];
+        // A 2 x 3 yd window slab on g0's south wall; the same slab on the exterior shell (which
+        // must not seed — the sky already lights it); and an INT-class batch of g0 (the floor).
+        let window = [
+            [-1.0, -5.0, 1.0],
+            [1.0, -5.0, 1.0],
+            [1.0, -4.9, 4.0],
+            [-1.0, -4.9, 4.0],
+        ];
+        let floor = [[-4.0, -4.0, 0.0], [4.0, 4.0, 0.0], [4.0, -4.0, 0.0]];
+        let seeds = daylight_seeds(
+            &groups,
+            PortalGraph::default(),
+            [
+                (0u16, true, &window[..]),
+                (0u16, false, &floor[..]),
+                (1u16, true, &window[..]),
+            ],
+        );
+        assert_eq!(seeds.len(), 1);
+        assert_eq!(seeds[0].group, 0);
+        assert_eq!(seeds[0].how, DaylightHow::Aperture);
+        // Nudged toward the room centre, i.e. +Y off the south wall.
+        assert!(seeds[0].pos[1] > -5.0);
+        // The sill is at z = 1 and the centre at z = 2.5, so the calibration stands 1.5 yd up.
+        let fx = seeds[0].fixture(Entity::PLACEHOLDER);
+        assert!((fx.cal_d - (0.25f32 + 1.5 * 1.5).sqrt()).abs() < 1e-4);
+        assert!(fx.cal_ndl > 0.9); // a floor fragment under the sill looks almost straight up at it
+    }
+
+    /// The budget: largest openings first, capped per placement.
+    #[test]
+    fn the_budget_keeps_the_widest_openings() {
+        let groups = [group(true, [-50.0, -50.0, 0.0], [50.0, 50.0, 20.0])];
+        // Twelve windows of strictly increasing area, all EXT-class batches of the one room and all
+        // inside `APERTURE_MAX_DIAG` (this test is about the BUDGET, not the size filter).
+        let quads: Vec<[[f32; 3]; 4]> = (1..=12)
+            .map(|i| {
+                let w = i as f32 * 0.5;
+                [
+                    [-w, -50.0, 1.0],
+                    [w, -50.0, 1.0],
+                    [w, -49.9, 1.0 + w],
+                    [-w, -49.9, 1.0 + w],
+                ]
+            })
+            .collect();
+        let seeds = daylight_seeds(
+            &groups,
+            PortalGraph::default(),
+            quads.iter().map(|q| (0u16, true, &q[..])),
+        );
+        assert_eq!(seeds.len(), MAX_DAYLIGHT_PER_PLACEMENT);
+        // Descending area, and the smallest survivor is window 5 (2*2.5 wide x 2.5 tall = 12.5
+        // yd^2) — i.e. the four narrowest of the twelve were the ones dropped.
+        for w in seeds.windows(2) {
+            assert!(w[0].area >= w[1].area);
+        }
+        assert!(
+            (seeds.last().unwrap().area - 12.5).abs() < 1e-3,
+            "smallest survivor {:?}",
+            seeds.last().unwrap().area
+        );
+    }
+
+    /// MONKEY (daylight quota): **a room's FIRST opening outranks any room's second** — the rule
+    /// that stops a district spending its whole budget on one canal.
+    ///
+    /// Twelve rooms, each with two windows, sized so the area rank INTERLEAVES them: room `i` has a
+    /// big window of `26 - 2i` yd^2 and a small one of `23 - 2i`, so by pure area the order runs
+    /// g0-big (26), g1-big (24), g0-small (23), g2-big (22), g1-small (21)… and the old rank's top
+    /// eight covered only FIVE rooms while three of them got two lights each. This is the shape of
+    /// Stormwind's failure in miniature (four canal portals, one canal, half the city's budget).
+    #[test]
+    fn the_quota_gives_every_room_one_before_any_room_two() {
+        // Room `i` is a 16 x 10 x 10 box centred at x = 10i, its windows on the y = -5 wall.
+        let groups: Vec<WmoGroupInfo> = (0..12)
+            .map(|i| {
+                let x = i as f32 * 10.0;
+                group(true, [x - 8.0, -5.0, 0.0], [x + 8.0, 5.0, 10.0])
+            })
+            .collect();
+        // `opening_area` is the two largest extents multiplied, so a `w x 0.1 x 2` slab on the wall
+        // is exactly `2w` yd^2 — the areas above, spelled as widths.
+        let window = |cx: f32, area: f32| {
+            let hw = 0.5 * (area / 2.0);
+            [
+                [cx - hw, -5.0, 1.0],
+                [cx + hw, -5.0, 1.0],
+                [cx + hw, -4.9, 3.0],
+                [cx - hw, -4.9, 3.0],
+            ]
+        };
+        let quads: Vec<(u16, [[f32; 3]; 4])> = (0..12u16)
+            .flat_map(|i| {
+                let x = i as f32 * 10.0;
+                let big = 26.0 - 2.0 * i as f32;
+                [(i, window(x - 4.0, big)), (i, window(x + 4.0, big - 3.0))]
+            })
+            .collect();
+        let batches = || quads.iter().map(|(g, q)| (*g, true, &q[..]));
+
+        // THE CONTROL: the uncapped, area-ranked list really does interleave the rooms — its first
+        // eight cover five rooms, three of them twice. Without this the test below could pass on a
+        // corpus the old rule would have handled just as well.
+        let ranked = daylight_seeds_ranked(&groups, PortalGraph::default(), batches());
+        assert_eq!(ranked.len(), 24, "every window seeds: {ranked:?}");
+        let by_area: HashSet<u16> = ranked[..MAX_DAYLIGHT_PER_PLACEMENT]
+            .iter()
+            .map(|s| s.group)
+            .collect();
+        assert_eq!(by_area.len(), 5, "pure area doubles up: {by_area:?}");
+
+        // THE RULE, through the live entry point. Twelve interior groups is under
+        // `DAYLIGHT_DISTRICT_ROOMS`, so the budget is still the building floor of eight — and those
+        // eight now land in eight DIFFERENT rooms, every one of them a room's first light.
+        assert_eq!(daylight_budget(&groups), MAX_DAYLIGHT_PER_PLACEMENT);
+        let kept = daylight_seeds(&groups, PortalGraph::default(), batches());
+        assert_eq!(kept.len(), MAX_DAYLIGHT_PER_PLACEMENT);
+        let rooms: HashSet<u16> = kept.iter().map(|s| s.group).collect();
+        assert_eq!(rooms.len(), MAX_DAYLIGHT_PER_PLACEMENT, "one each: {kept:?}");
+        assert!(kept.iter().all(|s| s.round == 0), "all first lights: {kept:?}");
+        // …and the eight rooms are the ones with the WIDEST first opening, in that order: within a
+        // round the old area rank is untouched.
+        for (n, s) in kept.iter().enumerate() {
+            assert_eq!(s.group, n as u16);
+            assert!((s.area - (26.0 - 2.0 * n as f32)).abs() < 1e-3, "{s:?}");
+        }
+
+        // THE SECOND ROUND, and the cap. With twenty slots every room takes its big window first
+        // (twelve round-0 picks), and only then do eight rooms take their small one — nothing
+        // reaches a third opening because no room has one.
+        let (day, _) = quota_select(&ranked, &[], 20);
+        assert_eq!(day.len(), 20);
+        assert_eq!(day.iter().filter(|s| s.round == 0).count(), 12);
+        assert_eq!(day.iter().filter(|s| s.round == 1).count(), 8);
+        assert!(day.iter().all(|s| s.round < 2));
+        assert_eq!(
+            day.iter().map(|s| s.group).collect::<HashSet<_>>().len(),
+            12,
+            "every room served in round 0"
+        );
+        // The budget TRUNCATES, at any size, and a budget of zero spends nothing.
+        assert_eq!(quota_select(&ranked, &[], 5).0.len(), 5);
+        assert_eq!(quota_select(&ranked, &[], 0).0.len(), 0);
+        assert_eq!(quota_select(&ranked, &[], 999).0.len(), 24, "runs out of seeds, not slots");
+    }
+
+    /// MONKEY (daylight quota): the budget itself — a building holds at eight, a district scales
+    /// with its rooms, and nothing scales past the ceiling.
+    #[test]
+    fn the_budget_scales_only_past_a_district() {
+        let rooms = |n: usize, interior: bool| -> Vec<WmoGroupInfo> {
+            (0..n)
+                .map(|_| group(interior, [0.0; 3], [10.0, 10.0, 10.0]))
+                .collect()
+        };
+        // The whole small-building corpus (1 183 of 1 211 shipped roots) is on this arm, the inn
+        // (10 interior groups) and the abbey (11) included: nothing moves.
+        assert_eq!(daylight_budget(&rooms(0, true)), MAX_DAYLIGHT_PER_PLACEMENT);
+        assert_eq!(daylight_budget(&rooms(10, true)), MAX_DAYLIGHT_PER_PLACEMENT);
+        assert_eq!(
+            daylight_budget(&rooms(DAYLIGHT_DISTRICT_ROOMS, true)),
+            MAX_DAYLIGHT_PER_PLACEMENT
+        );
+        // One room past the line it is a district and pays per room — Ironforge's 103 interior
+        // groups, Stormwind's 190 against the 128 ceiling.
+        assert_eq!(daylight_budget(&rooms(DAYLIGHT_DISTRICT_ROOMS + 1, true)), 33);
+        assert_eq!(daylight_budget(&rooms(103, true)), 103);
+        assert_eq!(daylight_budget(&rooms(190, true)), DAYLIGHT_BUDGET_MAX);
+        // EXTERIOR groups are not rooms: Stormwind's 116 exterior-class groups buy nothing, which is
+        // why the count is `g.interior` and not `groups.len()`.
+        assert_eq!(daylight_budget(&rooms(200, false)), MAX_DAYLIGHT_PER_PLACEMENT);
+    }
+
+    /// MONKEY (daylight quota): a BLEED serves TWO rooms, so its round is the lower of them — a
+    /// doorway into a room with nothing yet beats a second opening of an already-lit room, even
+    /// when that second opening is five times its area.
+    #[test]
+    fn a_bleed_ranks_by_its_darker_room() {
+        let seed = |group: u16, area: f32| DaylightSeed {
+            group,
+            portal: None,
+            how: DaylightHow::Aperture,
+            pos: [0.0, 0.0, 0.0],
+            diag: 4.0,
+            area,
+            hz: 1.0,
+            round: 0,
+        };
+        let day = [seed(0, 100.0), seed(0, 50.0)];
+        let bleed = [BleedSeed {
+            sides: [0, 1],
+            portal: 7,
+            pos: [0.0, 0.0, 0.0],
+            diag: 4.0,
+            area: 10.0,
+            round: 0,
+        }];
+        let (d, b) = quota_select(&day, &bleed, 2);
+        // Slot 1: g0's 100 yd^2 aperture (every candidate is round 0; area decides).
+        assert_eq!(d.len(), 1);
+        assert!((d[0].area - 100.0).abs() < 1e-3);
+        // Slot 2: g0's own 50 yd^2 aperture is now a ROUND-1 candidate, while the doorway is still
+        // round 0 — g1 has nothing. The doorway wins on round, not on area.
+        assert_eq!(b.len(), 1, "the doorway into the dark room took the slot");
+        assert_eq!(b[0].round, 0);
+        // Slot 3 is what is left, and its round shows the TWO BOOKS: the doorway charged g0's BLEED
+        // book, not its daylight one, so g0's second aperture comes in at daylight-round 1 — not 2.
+        // One shared counter would say 2 here, and that off-by-one is exactly what costs the inn its
+        // vestibule doorway (see [`quota_select`]).
+        let (d3, b3) = quota_select(&day, &bleed, 3);
+        assert_eq!(d3.len() + b3.len(), 3);
+        assert_eq!(d3.last().unwrap().round, 1, "{d3:?}");
+
+        // …and the mirror of the same fact: a room served only by a DOORWAY still has a round-0
+        // DAYLIGHT candidate, because the sun it is missing by day is not the candles it borrows by
+        // night. g1 has the doorway above and one small window; both come in at round 0.
+        let day2 = [seed(0, 100.0), seed(1, 5.0)];
+        let (d4, b4) = quota_select(&day2, &bleed, 3);
+        assert_eq!(b4.len(), 1);
+        assert!(d4.iter().all(|s| s.round == 0), "{d4:?}");
+        assert!(d4.iter().any(|s| s.group == 1), "g1's window is a first light: {d4:?}");
+    }
+
+    /// MONKEY (daylight fixtures: boundary): the stitched-threshold seed — it finds the shared
+    /// vertex run, refuses a vertical party-wall seam and a corner stitch, and steps into the room.
+    #[test]
+    fn boundary_seeds_are_the_stitched_threshold() {
+        // g0 the room (0..10 square, floor at z = 0), g1 the building shell around it.
+        let groups = [
+            group(true, [0.0, 0.0, 0.0], [10.0, 10.0, 5.0]),
+            group(false, [-10.0, -10.0, -1.0], [20.0, 20.0, 10.0]),
+        ];
+        // THE DOORWAY: a 4 yd run of floor vertices on the y = 0 wall, authored into BOTH groups.
+        let door: Vec<[f32; 3]> = (0..=8)
+            .map(|i| [2.0 + i as f32 * 0.5, 0.0, 0.0])
+            .collect();
+        // A PARTY-WALL seam: the same stitch, but running 5 yd UP the x = 10 wall.
+        let wall: Vec<[f32; 3]> = (0..=10)
+            .map(|i| [10.0, 8.0, i as f32 * 0.5])
+            .collect();
+        // A CORNER stitch: three coincident vertices where two walls meet the floor.
+        let corner = [[0.0, 10.0, 0.0], [0.0, 10.0, 0.2], [0.2, 10.0, 0.0]];
+        // …and interior-only floor the shell never sees.
+        let inside = [[5.0, 5.0, 0.0], [6.0, 5.0, 0.0], [5.0, 6.0, 0.0]];
+        let mut shared: Vec<[f32; 3]> = door.clone();
+        shared.extend_from_slice(&wall);
+        shared.extend_from_slice(&corner);
+        let seeds = daylight_seeds(
+            &groups,
+            PortalGraph::default(),
+            [
+                (0u16, false, &shared[..]),
+                (0u16, false, &inside[..]),
+                (1u16, false, &shared[..]),
+            ],
+        );
+        assert_eq!(seeds.len(), 1, "{seeds:#?}");
+        let s = &seeds[0];
+        assert_eq!(s.how, DaylightHow::Boundary);
+        assert_eq!(s.group, 0);
+        // The threshold run is 4 yd wide, so the opening it stands for ranks as ~16 yd^2.
+        assert!((s.diag - 4.0).abs() < 0.2, "diag {}", s.diag);
+        assert!((s.area - 16.0).abs() < 2.0, "area {}", s.area);
+        // Centred on the 4 yd run (x = 4, y = 0), stepped exactly NUDGE_YD HORIZONTALLY toward the
+        // room's vertex centroid — so the step is into the room (+y) and its length is the nudge,
+        // but its bearing is the centroid's, not the wall normal's. And it stands SEED_MAX_HZ above
+        // the threshold rather than on it.
+        let step = ((s.pos[0] - 4.0).powi(2) + s.pos[1].powi(2)).sqrt();
+        assert!((step - NUDGE_YD).abs() < 1e-3, "pos {:?} step {step}", s.pos);
+        assert!(s.pos[1] > 0.0, "did not step into the room: {:?}", s.pos);
+        assert!((s.pos[2] - SEED_MAX_HZ).abs() < 1e-3, "pos {:?}", s.pos);
+        assert!((s.hz - SEED_MAX_HZ).abs() < 1e-3);
+        // A doorway that ALSO has an authored seed is not seeded twice.
+        let with_portal = daylight_seeds(
+            &groups,
+            PortalGraph::default(),
+            [
+                (0u16, false, &shared[..]),
+                (1u16, false, &shared[..]),
+                // an EXT-class batch of the room, right at the same doorway
+                (0u16, true, &door[..]),
+            ],
+        );
+        assert_eq!(with_portal.len(), 1, "{with_portal:#?}");
+        assert_eq!(with_portal[0].how, DaylightHow::Aperture);
+    }
+
+
+    /// MONKEY (portal bleed): the seed rule — interior<->interior portals only, standing IN the
+    /// opening, carrying both sides.
+    #[test]
+    fn bleed_seeds_are_the_room_to_room_doorways() {
+        // g0 and g2 interior rooms either side of x = 0; g1 the building's exterior shell.
+        let groups = [
+            group(true, [-10.0, -5.0, 0.0], [0.0, 5.0, 5.0]),
+            group(false, [-20.0, -20.0, 0.0], [20.0, 20.0, 10.0]),
+            group(true, [0.0, -5.0, 0.0], [10.0, 5.0, 5.0]),
+        ];
+        // One 2 x 2 yd quad at x = 0, sill at z = 0, reused by all three portals.
+        let vertices = [
+            [0.0, -1.0, 0.0],
+            [0.0, 1.0, 0.0],
+            [0.0, 1.0, 2.0],
+            [0.0, -1.0, 2.0],
+        ];
+        let infos = [
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+            WmoPortalInfo { start_vertex: 0, count: 4, plane: [1.0, 0.0, 0.0, 0.0] },
+        ];
+        // p0: g0 <-> g1 (a room to the SHELL — the daylight seed's population, not this one).
+        // p1: g0 <-> g2 (room to room — the one bleed seed).
+        // p2: named by g2 alone (a portal to the outside — not a doorway between two rooms).
+        let refs = [
+            WmoPortalRef { portal: 0, group: 1, side: 1 },
+            WmoPortalRef { portal: 1, group: 2, side: 1 },
+            WmoPortalRef { portal: 0, group: 0, side: -1 },
+            WmoPortalRef { portal: 1, group: 0, side: -1 },
+            WmoPortalRef { portal: 2, group: 2, side: 1 },
+        ];
+        let slices = [(0, 2), (2, 1), (3, 2)];
+        let portals = PortalGraph {
+            vertices: &vertices,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        let seeds = bleed_seeds(&groups, portals);
+        assert_eq!(seeds.len(), 1, "{seeds:#?}");
+        assert_eq!(seeds[0].portal, 1);
+        let mut sides = seeds[0].sides;
+        sides.sort_unstable();
+        assert_eq!(sides, [0, 2]);
+        // …and it stands IN the opening: the quad lies on x = 0 and is NOT nudged off it (that is
+        // the whole aperture argument — a doorway has no side, so there is no side to step onto).
+        assert!(seeds[0].pos[0].abs() < 1e-4, "pos {:?}", seeds[0].pos);
+        // The z clamp is `seed_point`'s: the quad's centre is 1 yd up, under `SEED_MAX_HZ`.
+        assert!((seeds[0].pos[2] - 1.0).abs() < 1e-4, "pos {:?}", seeds[0].pos);
+        // Both rooms are MOLR-seeded, so both are claimed HARD — a doorway lights either side.
+        let claims = seeds[0].claims(&groups, portals);
+        for g in [0u16, 2] {
+            let c = claims.iter().find(|c| c.group == g).expect("claim");
+            assert_eq!(c.fade_radius, 0.0, "g{g} claim should be hard: {c:?}");
+        }
+    }
+
+    /// MONKEY (portal bleed): the calibration really does deliver `BLEED_K x lit` at the portal
+    /// plane — fed back through the shader's own profile, which is the claim the whole rule rests on.
+    #[test]
+    fn a_doorway_transmits_bleed_k_at_its_own_plane() {
+        let knobs = DynamicInteriors::default();
+        let k_fill = knobs.fill * knobs.interior_gain;
+        let r_eff = super::super::interior_reach(daylight_authored_reach(5.91), knobs.atten_scale);
+        // A warm candle-coloured irradiance, the Goldshire hall's own hue.
+        let lit = [0.0240f32, 0.0240, 0.0158];
+        let (hue, i) = bleed_intensity(lit, r_eff, k_fill);
+        assert!(i > 0.0 && i <= 1.0, "I {i}");
+        // The fixture's own contribution at NUDGE_YD, evaluated exactly as `room_irradiance` would.
+        let delivered = luminance(hue)
+            * i
+            * (core_atten(NUDGE_YD) * interior_window(NUDGE_YD, r_eff, INTERIOR_DIRECT_POW)
+                + k_fill * interior_window(NUDGE_YD, INTERIOR_FILL_SPAN * r_eff, INTERIOR_FILL_POW));
+        assert!(
+            (delivered - BLEED_K * luminance(lit)).abs() < 1e-6,
+            "delivered {delivered} vs {}",
+            BLEED_K * luminance(lit)
+        );
+        // …and it can never out-shine what it carries: `BLEED_K < 1` by construction.
+        assert!(delivered < luminance(lit));
+        // The hue is the lit side's chroma renormalised to peak 1, so the packed colour is `hue * I`.
+        assert!((hue[0] - 1.0).abs() < 1e-5 && hue[2] < hue[1]);
+        // A dark neighbour is no fixture at all — the packer must not hold a slot for it.
+        assert_eq!(bleed_intensity([0.0; 3], r_eff, k_fill).1, 0.0);
+        // Brighter in, brighter out, monotone.
+        let (_, brighter) = bleed_intensity([0.05, 0.05, 0.033], r_eff, k_fill);
+        assert!(brighter > i);
+    }
+
+    /// MONKEY (portal bleed): the two lanes share ONE eight-slot budget, ranked by area, and a tie
+    /// goes to daylight (the inn's p0 porch door and p1 vestibule doorway are exactly that tie).
+    #[test]
+    fn the_shared_budget_ranks_both_lanes_by_area() {
+        let groups = [
+            group(true, [-50.0, -50.0, 0.0], [0.0, 50.0, 20.0]),
+            group(true, [0.0, -50.0, 0.0], [50.0, 50.0, 20.0]),
+        ];
+        // Six room-to-room doorways on the x = 0 wall, of strictly increasing area -- all under
+        // `SPLIT_PORTAL_MIN_AREA` (28 yd^2), which the seed rule refuses as a cut room rather than
+        // a door: `2w x w` for w in 1..=6 is 2..24 yd^2.
+        let quads: Vec<[[f32; 3]; 4]> = (1..=6)
+            .map(|i| {
+                let w = i as f32;
+                let y = i as f32 * 10.0 - 45.0;
+                [
+                    [0.0, y - w, 0.0],
+                    [0.0, y + w, 0.0],
+                    [0.0, y + w, w],
+                    [0.0, y - w, w],
+                ]
+            })
+            .collect();
+        let vertices: Vec<[f32; 3]> = quads.iter().flatten().copied().collect();
+        let infos: Vec<WmoPortalInfo> = (0..6)
+            .map(|i| WmoPortalInfo {
+                start_vertex: i * 4,
+                count: 4,
+                plane: [1.0, 0.0, 0.0, 0.0],
+            })
+            .collect();
+        let mut refs = Vec::new();
+        for i in 0..6u16 {
+            refs.push(WmoPortalRef { portal: i, group: 1, side: 1 });
+        }
+        for i in 0..6u16 {
+            refs.push(WmoPortalRef { portal: i, group: 0, side: -1 });
+        }
+        let slices = [(0, 6), (6, 6)];
+        let portals = PortalGraph {
+            vertices: &vertices,
+            infos: &infos,
+            refs: &refs,
+            slices: &slices,
+        };
+        // …plus five WINDOWS (EXT-class batches of g0), all smaller than the widest doorways.
+        let windows: Vec<[[f32; 3]; 4]> = (1..=5)
+            .map(|i| {
+                let y = i as f32 * 8.0 - 40.0;
+                [
+                    [-50.0, y - 1.0, 1.0],
+                    [-50.0, y + 1.0, 1.0],
+                    [-49.9, y + 1.0, 3.0],
+                    [-49.9, y - 1.0, 3.0],
+                ]
+            })
+            .collect();
+        let (day, bleed) = placement_openings(
+            &groups,
+            portals,
+            windows.iter().map(|q| (0u16, true, &q[..])),
+        );
+        assert_eq!(
+            day.len() + bleed.len(),
+            MAX_DAYLIGHT_PER_PLACEMENT,
+            "day {day:?} bleed {bleed:?}"
+        );
+        // The widest doorways (2w x w = 2, 8, 18, 32*, 50*, 72* yd^2 -- starred ones refused as
+        // SPLIT cuts) outrank the 2 x 2 yd windows, and the narrowest doorway loses to them.
+        assert!(bleed.iter().all(|b| b.area < 28.0), "a split cut got seeded: {bleed:?}");
+        assert!(bleed.len() >= 2, "{bleed:?}");
+        for w in bleed.windows(2) {
+            assert!(w[0].area >= w[1].area);
+        }
+        assert!(bleed.iter().all(|b| b.sides.contains(&0) && b.sides.contains(&1)));
+    }
+
+    /// The sun curve: dark at and below the horizon, monotone up to full — and the calibration
+    /// really does solve the equation it claims to.
+    #[test]
+    fn intensity_tracks_the_sun() {
+        let knobs = DynamicInteriors {
+            // The owner's live settings (`benilla-config/config.toml`), not the defaults.
+            ambient: 0.02,
+            exposure: 4.0,
+            ..DynamicInteriors::default()
+        };
+        let mut light = WowLighting {
+            ambient: [0.25, 0.26, 0.30],
+            diffuse: [0.55, 0.53, 0.47],
+            ..WowLighting::default()
+        };
+        // Straight overhead: the floor takes the whole diffuse band.
+        light.sun_dir = Vec3::NEG_Y;
+        light.celestial_dir = Vec3::Y;
+        let (hue, t_day, w_day) = daylight_target(&light);
+        assert_eq!(w_day, 1.0);
+        assert!(t_day > luminance(light.ambient));
+        // …and below the horizon the fixture is off however bright the bands read.
+        light.celestial_dir = Vec3::new(0.0, -0.3, 1.0);
+        assert_eq!(daylight_target(&light).2, 0.0);
+        // Monotone through the dawn knee.
+        let mut prev = -1.0;
+        for i in 0..=20 {
+            light.celestial_dir = Vec3::new(0.0, -0.05 + i as f32 * 0.02, 1.0);
+            let w = daylight_target(&light).2;
+            assert!(w >= prev, "sun weight went backwards at step {i}");
+            prev = w;
+        }
+        // The calibration: a dimmer target needs less intensity, and a target the ambient floor
+        // already exceeds needs none.
+        let a = direct_profile(1.21, 0.909, 11.2);
+        let w_fill = interior_window(1.21, INTERIOR_FILL_SPAN * 11.2, INTERIOR_FILL_POW);
+        let hue_lum = luminance(hue);
+        let bright = daylight_intensity(t_day, hue_lum, a, w_fill, &knobs);
+        let dim = daylight_intensity(t_day * 0.5, hue_lum, a, w_fill, &knobs);
+        assert!(bright > dim && dim > 0.0, "bright {bright} dim {dim}");
+        assert!(bright <= 1.0);
+        assert_eq!(daylight_intensity(0.0, hue_lum, a, w_fill, &knobs), 0.0);
+        // Feed the solved intensity back through the shader's own arithmetic: the rolloff must land
+        // on the reference target, which is the whole claim the seam closure rests on.
+        let room = hue_lum * bright * (a + knobs.fill * w_fill) + knobs.ambient;
+        let illum = 1.0 - (-room * knobs.exposure).exp();
+        assert!((illum - t_day).abs() < 1e-3, "illum {illum} vs target {t_day}");
+    }
+}
diff --git a/crates/benilla-world/src/lighting/flicker.rs b/crates/benilla-world/src/lighting/flicker.rs
new file mode 100644
index 00000000..be9bc639
--- /dev/null
+++ b/crates/benilla-world/src/lighting/flicker.rs
@@ -0,0 +1,447 @@
+//! MONKEY (flame flicker): the per-light brightness wobble that makes a fire read as FIRE.
+//!
+//! Every flame in the world is a CONSTANT today. An authored M2 light block is sampled at its first
+//! animation key and never again (the tracks are read once at bake), and a light SYNTHESISED from a
+//! flame emitter ([`benilla_formats::fire_light`]) has no track at all — it is one number off an
+//! intensity rung. So a wall torch, a candelabra and a bonfire all light their room with the
+//! steadiness of a light bulb, which is the one cue that reads as "this is not fire".
+//!
+//! The fix is CPU-side and costs nothing, because of where it lands: `build_light_data` repacks the
+//! whole point table into the storage buffer every single frame anyway (it re-sorts by camera
+//! distance), so a per-light multiplier folded in at pack time is one hash and three sines per
+//! packed entry — a few hundred flops for the whole table — and zero extra GPU work, zero extra
+//! bandwidth, and no new `LightStd430` lane. Nothing is written back onto the `PointLight`
+//! component, which is what keeps the flicker out of every OTHER consumer of that intensity:
+//! `torch_shadow`'s caster ranking and hysteresis read the component and therefore still score the
+//! UNMODULATED intensity, so a flame breathing at 5 Hz can never make a shadow map thrash in and
+//! out of its slot.
+//!
+//! **What it must not be.** The failure mode has a name here — the "epileptic imp", the carried
+//! light whose shadow slot toggled at frame rate (see `benilla_app::entities::carried_light`'s
+//! stability note). A flicker that reads as a DISCO rather than as a flame is worse than no flicker
+//! at all, so the waveform is built to be band-limited by construction rather than tuned by eye:
+//!
+//! * **Amplitude is small and ordered by mass.** A candle is a thumbnail of burning gas that a
+//!   draught can visibly bend (±12%); a bonfire is a cubic yard of it with a thermal time constant
+//!   (±6%). Ordering the rungs candle > torch > brazier > bonfire is the whole of the "plausible"
+//!   claim — the big fires are STEADIER, not just slower.
+//! * **Frequency is bounded, and the fast partials carry the LEAST weight.** Three sines spread
+//!   across the kind's band, weighted `0.42 / 0.28 / 0.18` low→high, so the slowest partial
+//!   dominates the eye's impression and the peak slew is roughly half what the top of the band
+//!   would allow ([`FlameKind::max_rate`] states the bound the test asserts).
+//! * **Weights sum to exactly 1**, so the excursion can never exceed the stated amplitude even when
+//!   all four terms align, and every term is zero-mean, so the MEAN multiplier is exactly 1.0 and
+//!   the room's tuned exposure ([`super::DynamicInteriors::exposure`]) is untouched.
+//!
+//! It is a function of ABSOLUTE time and a per-light seed only: frame-rate independent (the same
+//! wall clock gives the same brightness at 30 fps and 240), deterministic, and — because the seed
+//! hashes the light's own position — never in sync between two candles on the same table.
+
+use bevy::prelude::*;
+
+/// Which fire this is, and therefore how it burns. The four rungs are exactly the intensity ladder
+/// the synthesiser buckets a flame emitter onto ([`benilla_formats::fire_intensity`]: candle 0.6 /
+/// torch 1.5 / brazier 2.0 / bonfire 3.0) and the reach ladder the packer buckets an M2 light on
+/// ([`super::m2_light_reach`]) — one ladder, so a light's flicker, its reach and its brightness can
+/// never disagree about what kind of fire it is.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum FlameKind {
+    Candle,
+    Torch,
+    Brazier,
+    Bonfire,
+}
+
+impl FlameKind {
+    /// The rung this intensity sits on. Cut points are the MIDPOINTS of the synthesiser's own rungs
+    /// (0.6 / 1.5 / 2.0 / 3.0), so a synthesised light lands on its bucket exactly and an AUTHORED
+    /// one is filed by how bright the artist made it — the same "bucket it, don't read it" rule
+    /// [`super::m2_light_reach`] already applies to reach, and for the same reason (the authored
+    /// records carry brightness honestly and everything else as a template default).
+    pub fn from_intensity(i: f32) -> Self {
+        match i {
+            v if v < 1.0 => Self::Candle,
+            v if v < 1.75 => Self::Torch,
+            v if v < 2.5 => Self::Brazier,
+            _ => Self::Bonfire,
+        }
+    }
+
+    /// Peak excursion of the intensity multiplier at `fireFlicker 1` — `0.12` = ±12%.
+    ///
+    /// Ordered candle > torch > brazier > bonfire because FLAME MASS is what damps a fire: a candle
+    /// tip is grams of gas and every draught in the room shows in it, a bonfire is a slow thermal
+    /// body whose brightness barely moves. Reading the order the other way (big fire = big flicker)
+    /// is the intuitive mistake, and it looks like a fault rather than like fire.
+    pub fn amplitude(self) -> f32 {
+        match self {
+            Self::Candle => 0.12,
+            Self::Torch => 0.10,
+            Self::Brazier => 0.08,
+            Self::Bonfire => 0.06,
+        }
+    }
+
+    /// The band (Hz) the three sine partials are spread across — again mass-ordered, and again for
+    /// the physical reason: a small flame's turbulence is fast, a big one's is slow. The top of the
+    /// candle band (7 Hz) is the highest rate anything here runs at, and it is the LEAST weighted
+    /// partial, so nothing in the feature approaches a strobe.
+    pub fn band(self) -> (f32, f32) {
+        match self {
+            Self::Candle => (4.0, 7.0),
+            Self::Torch => (3.0, 5.0),
+            Self::Brazier => (2.0, 4.0),
+            Self::Bonfire => (1.5, 3.0),
+        }
+    }
+
+    /// A hard upper bound on `|d/dt|` of the intensity multiplier, in units of multiplier per
+    /// second — the number that makes "band-limited" an assertion rather than an adjective.
+    ///
+    /// Every partial's slew is `amp × weight × 2π × f`, bounded by the top of the band; the value
+    /// noise adds at most `amp × weight × 3 × f` (a smoothstep's max slope is 1.5, over a span of
+    /// at most 2). Loose by design — it bounds the worst possible phase alignment, which the
+    /// waveform will not actually reach — but that is what a bound is for.
+    pub fn max_rate(self, gain: f32) -> f32 {
+        let (_, hi) = self.band();
+        let sines = std::f32::consts::TAU * hi * (W_SLOW + W_MID + W_FAST);
+        let noise = 3.0 * hi * W_NOISE;
+        self.amplitude() * gain.max(0.0) * (sines + noise)
+    }
+}
+
+// The four term weights. They SUM TO EXACTLY 1, which is the invariant that makes
+// [`FlameKind::amplitude`] a true peak bound (all four terms at +1 gives exactly `1 + amp`), and
+// the ordering slow > mid > fast > noise is what keeps the eye's impression on the low frequencies
+// — the difference between "the flame breathes" and "the lamp is faulty".
+const W_SLOW: f32 = 0.42;
+const W_MID: f32 = 0.28;
+const W_FAST: f32 = 0.18;
+const W_NOISE: f32 = 0.12;
+
+/// Peak wobble on the BLUE channel alone at `fireFlicker 1` — the colour-temperature term.
+///
+/// A flame's colour genuinely moves with its brightness (a starved flame is redder, a fed one
+/// whiter), and 3% on blue alone is the cheapest honest expression of that: it needs no colour
+/// space, cannot push the light out of gamut, and at this size reads as warmth rather than as a
+/// hue shift. It runs at its own slow rate and its own phase, so it never simply tracks the
+/// intensity — a flame that dims and reddens in lockstep looks like a dimmer knob.
+const BLUE_WOBBLE: f32 = 0.03;
+
+/// The blue term's rate as a fraction of the kind's slowest partial — deliberately SLOWER than any
+/// brightness partial. Colour temperature is a property of the whole flame body, not of the tip
+/// that flickers.
+const BLUE_RATE: f32 = 0.37;
+
+/// MONKEY (flame flicker): marks a `PointLight` that burns rather than shines, with everything the
+/// modulation needs — `kind` (how deep and how fast) and `seed` (whose phase).
+///
+/// Inserted ONCE, at spawn, and never removed or changed: the flicker is a pure function of the
+/// component plus the clock, so there is no per-frame write, no `Changed` traffic and no archetype
+/// churn — the entity's archetype is settled by the end of the spawn command queue exactly as it
+/// was before this component existed.
+#[derive(Component, Clone, Copy)]
+pub struct FlameFlicker {
+    pub kind: FlameKind,
+    /// The phase seed — [`flicker_seed`] of the light's own position, so no two flames in a room
+    /// are ever in step. Two candles flickering together is the single most artificial thing this
+    /// feature could do, and it is what a shared global phase would produce.
+    pub seed: u32,
+}
+
+/// One frame's modulation: multipliers, not values, so the caller keeps its authored colour and
+/// intensity intact and folds these in at the last moment.
+#[derive(Clone, Copy, Debug)]
+pub struct FlickerMod {
+    /// Multiplier on the light's committed intensity. Mean exactly 1.0.
+    pub intensity: f32,
+    /// Multiplier on the BLUE channel only — the colour-temperature wobble. Mean exactly 1.0.
+    pub blue: f32,
+}
+
+impl FlickerMod {
+    /// The identity — what a non-flame light gets, and what every flame gets at `fireFlicker 0`.
+    pub const STEADY: Self = Self {
+        intensity: 1.0,
+        blue: 1.0,
+    };
+}
+
+impl FlameFlicker {
+    pub fn new(kind: FlameKind, seed: u32) -> Self {
+        Self { kind, seed }
+    }
+
+    /// This flame's multipliers at absolute time `t` (seconds) and live gain `gain`
+    /// (`fireFlicker`: 0 off, 1 the authored amplitudes, 2 doubled).
+    ///
+    /// `t` is ABSOLUTE elapsed time, never a delta: that is what makes the result frame-rate
+    /// independent (a 30 fps and a 240 fps client show the same flame at the same instant) and what
+    /// lets the whole thing be stateless — no per-light accumulator to keep, restore or desync.
+    pub fn at(&self, t: f32, gain: f32) -> FlickerMod {
+        if gain <= 0.0 {
+            return FlickerMod::STEADY;
+        }
+        let (lo, hi) = self.kind.band();
+        let span = hi - lo;
+        // The three partials at the bottom / middle / top of the band, each JITTERED by up to ±12%
+        // of the span from its own seed word. Without the jitter every candle in the game would
+        // share the same three frequencies and differ only in phase, which beats into a visible
+        // collective rhythm across a room full of them; with it, no two flames ever repeat.
+        let f = |k: u32, frac: f32| {
+            let jitter = (unit(self.seed ^ mix(0x9e37_79b9u32.wrapping_mul(k + 1))) - 0.5) * 0.24;
+            (lo + span * (frac + jitter)).clamp(lo * 0.85, hi)
+        };
+        let phase = |k: u32| unit(mix(self.seed.wrapping_add(0x85eb_ca6b).wrapping_mul(k + 3)));
+        let s = |k: u32, frac: f32| {
+            (std::f32::consts::TAU * (f(k, frac) * t + phase(k))).sin()
+        };
+        // Three sines plus one smoothed value-noise term. The noise is what stops the sum reading
+        // as a sum of sines — a pure harmonic stack has an audible-to-the-eye periodicity at the
+        // beat of its partials, and a fire has none. It runs at the SLOW edge of the band so it
+        // contributes shape, not speed.
+        let w = W_SLOW * s(0, 0.0)
+            + W_MID * s(1, 0.5)
+            + W_FAST * s(2, 1.0)
+            + W_NOISE * value_noise(t * lo, self.seed ^ 0x1234_5678);
+        let amp = self.kind.amplitude() * gain;
+        // The blue term is independent: its own phase, its own (slower) rate. See [`BLUE_WOBBLE`].
+        let b = (std::f32::consts::TAU * (lo * BLUE_RATE * t + phase(7))).sin();
+        FlickerMod {
+            // `max(0)` is belt-and-braces: with `Σw == 1` and the cvar clamped to 2 the worst case
+            // is `1 − 0.24`, and a negative multiplier could not be committed anyway.
+            intensity: (1.0 + amp * w).max(0.0),
+            blue: (1.0 + BLUE_WOBBLE * gain * b).max(0.0),
+        }
+    }
+}
+
+/// MONKEY (flame flicker): does this light burn, and as what? The ONE rule, called by every spawn
+/// lane so a candle cannot flicker as a candle in a WMO and as a bonfire on a transport.
+///
+/// * `flame` — the light was SYNTHESISED from a model's flame particle emitter
+///   ([`benilla_assets::ModelLight::flame`]). That is a fire by construction, whatever colour it
+///   burns: `OgreWallTorchpurple` and `HumanBrazierMagic` are flames with strange chemistry, not
+///   lamps, and they flicker. **The route decides, not the hue** — which is why this arm is tested
+///   before any colour test at all.
+/// * `synthetic && !flame` — the LAMP route (`fire_light::synthesize_lamp_light`): a lamppost, a
+///   hanging lantern, a sconce, a chandelier, whose "flame" is a pane of unlit glass geometry.
+///   Behind glass a flame does not visibly flicker, and a street lamp that did would read as a
+///   fault in the city rather than as fire. **No flicker.**
+/// * An AUTHORED light block or MOLT fixture — flicker iff its colour is WARM (`r > g > b` with a
+///   real saturation). The authored fixture corpus is overwhelmingly candles and wall torches
+///   filed at that hue; the things it is NOT are the neutral-white fill lights artists park in
+///   halls and the cold blue/green magic sources, and both are exactly what the warmth test
+///   excludes. It is a heuristic, and it is why `fireFlicker 0` exists.
+///
+/// Returns the KIND on the same intensity ladder every lane already uses, so the caller only has to
+/// hand over what it is holding anyway.
+pub fn flame_kind_for(
+    flame: bool,
+    synthetic: bool,
+    color: [f32; 3],
+    intensity: f32,
+) -> Option<FlameKind> {
+    if flame {
+        return Some(FlameKind::from_intensity(intensity));
+    }
+    if synthetic {
+        return None; // the lamp/emissive route — glass, not flame
+    }
+    is_warm(color).then(|| FlameKind::from_intensity(intensity))
+}
+
+/// The warmth test for an AUTHORED source: strictly descending `r > g > b` with a saturation
+/// (`max − min`, which for a descending triple is `r − b`) over `0.2`.
+///
+/// Both halves earn their place. The ORDER alone admits `(0.9, 0.88, 0.86)` — the near-white fill
+/// light, which must not breathe. The SATURATION alone admits a cold blue fixture. Together they
+/// name the warm family and nothing else; the shipped warm fixtures clear the floor by a wide
+/// margin (a candle's authored `(1.0, 0.72, 0.40)` sits at 0.60).
+fn is_warm(c: [f32; 3]) -> bool {
+    c[0] > c[1] && c[1] > c[2] && c[0] - c[2] > 0.2
+}
+
+/// MONKEY (flame flicker): a light's phase seed from WHERE IT IS.
+///
+/// Position is the only identity a light has that is stable across a stream-out/stream-in (entity
+/// ids are not), so a torch keeps its phase when you walk out of the room and back — a re-seeded
+/// flame would visibly jump. Quantised to 1/16 yd before hashing so floating-point noise in the
+/// placement transform cannot change the seed between two spawns of the same fixture.
+pub fn flicker_seed(p: Vec3) -> u32 {
+    let q = |v: f32| (v * 16.0).round() as i32 as u32;
+    mix(q(p.x) ^ mix(q(p.y) ^ mix(q(p.z))))
+}
+
+/// A 32-bit integer finaliser (the `lowbias32` mix) — the whole "randomness" budget of this
+/// feature. Not a PRNG: a hash, so every value it produces is reproducible from its input alone,
+/// which is what makes the flicker deterministic per light rather than per session.
+fn mix(mut x: u32) -> u32 {
+    x ^= x >> 16;
+    x = x.wrapping_mul(0x7feb_352d);
+    x ^= x >> 15;
+    x = x.wrapping_mul(0x846c_a68b);
+    x ^= x >> 16;
+    x
+}
+
+/// A hash word as a `[0, 1)` float — 24 bits, the f32 mantissa, so the conversion is exact.
+fn unit(x: u32) -> f32 {
+    (mix(x) >> 8) as f32 / 16_777_216.0
+}
+
+/// Smoothed value noise in `[-1, 1]`: hash a value at each integer step of `t` and smoothstep
+/// between them.
+///
+/// Zero-mean by construction (the per-step values are uniform on `[-1, 1]` and the interpolation is
+/// a convex blend of two of them), and band-limited by construction too — its steepest slope is
+/// `1.5 × span` per unit of `t`, which is what [`FlameKind::max_rate`] budgets for. That
+/// combination is the reason it is value noise and not a random walk or a filtered PRNG: both of
+/// those drift off the mean and neither has a slope bound.
+fn value_noise(t: f32, seed: u32) -> f32 {
+    let i = t.floor();
+    let u = t - i;
+    let u = u * u * (3.0 - 2.0 * u); // smoothstep — C1 at the knots, so no slope discontinuity
+    let k = i as i64 as u32;
+    let a = unit(seed ^ mix(k)) * 2.0 - 1.0;
+    let b = unit(seed ^ mix(k.wrapping_add(1))) * 2.0 - 1.0;
+    a + (b - a) * u
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const KINDS: [FlameKind; 4] = [
+        FlameKind::Candle,
+        FlameKind::Torch,
+        FlameKind::Brazier,
+        FlameKind::Bonfire,
+    ];
+
+    /// The weight budget is the invariant everything else rests on: it makes
+    /// [`FlameKind::amplitude`] a true peak bound and the mean exactly 1.
+    #[test]
+    fn the_term_weights_sum_to_one() {
+        assert!((W_SLOW + W_MID + W_FAST + W_NOISE - 1.0).abs() < 1e-6);
+    }
+
+    /// GOLDEN — the tuned exposure must survive the feature. A flicker whose mean is not 1 is a
+    /// brightness change wearing a flicker's clothes, and it would silently retune every interior.
+    #[test]
+    fn the_mean_multiplier_is_one_over_a_long_window() {
+        for kind in KINDS {
+            for seed in [1u32, 0xdead_beef, 12345, 7] {
+                let f = FlameFlicker::new(kind, seed);
+                let n = 60_000;
+                let (mut si, mut sb) = (0.0f64, 0.0f64);
+                for k in 0..n {
+                    let m = f.at(k as f32 * 0.005, 1.0); // 300 s at 200 Hz
+                    si += f64::from(m.intensity);
+                    sb += f64::from(m.blue);
+                }
+                let (mi, mb) = (si / f64::from(n), sb / f64::from(n));
+                assert!((mi - 1.0).abs() < 0.005, "{kind:?}/{seed}: mean {mi}");
+                assert!((mb - 1.0).abs() < 0.002, "{kind:?}/{seed}: blue mean {mb}");
+            }
+        }
+    }
+
+    /// GOLDEN — the anti-strobe assertion. Excursion inside the stated amplitude, and slew inside
+    /// the stated bound: this is the test that would fail if someone widened a band or reweighted
+    /// the partials toward the fast end.
+    #[test]
+    fn the_waveform_is_bounded_in_amplitude_and_in_slew() {
+        for kind in KINDS {
+            for gain in [1.0f32, 2.0] {
+                let f = FlameFlicker::new(kind, 0xabcd_1234);
+                let dt = 0.0005;
+                let bound = kind.max_rate(gain);
+                let mut prev = f.at(0.0, gain).intensity;
+                for k in 1..40_000 {
+                    let m = f.at(k as f32 * dt, gain).intensity;
+                    let amp = kind.amplitude() * gain;
+                    assert!(
+                        (m - 1.0).abs() <= amp + 1e-4,
+                        "{kind:?} gain {gain}: excursion {} over amp {amp}",
+                        m - 1.0
+                    );
+                    let rate = (m - prev).abs() / dt;
+                    assert!(rate <= bound, "{kind:?} gain {gain}: {rate}/s over {bound}/s");
+                    prev = m;
+                }
+            }
+        }
+    }
+
+    /// A steadier fire for a bigger fire — the ordering that is the whole "plausible" claim, held
+    /// both in the authored amplitude and in the bound the waveform actually reaches.
+    #[test]
+    fn a_bigger_fire_flickers_less() {
+        let amps: Vec<f32> = KINDS.iter().map(|k| k.amplitude()).collect();
+        assert!(amps.windows(2).all(|w| w[0] > w[1]), "{amps:?}");
+        let rates: Vec<f32> = KINDS.iter().map(|k| k.max_rate(1.0)).collect();
+        assert!(rates.windows(2).all(|w| w[0] > w[1]), "{rates:?}");
+    }
+
+    /// Deterministic per seed, and DIFFERENT per seed — two candles on one table must not breathe
+    /// together, which is the failure a shared global phase would produce.
+    #[test]
+    fn the_phase_is_deterministic_and_unshared() {
+        let a = FlameFlicker::new(FlameKind::Candle, flicker_seed(Vec3::new(1.0, 2.0, 3.0)));
+        let b = FlameFlicker::new(FlameKind::Candle, flicker_seed(Vec3::new(1.5, 2.0, 3.0)));
+        assert_ne!(a.seed, b.seed);
+        let same = FlameFlicker::new(FlameKind::Candle, flicker_seed(Vec3::new(1.0, 2.0, 3.0)));
+        let mut apart = 0.0f32;
+        for k in 0..2000 {
+            let t = k as f32 * 0.01;
+            assert_eq!(a.at(t, 1.0).intensity, same.at(t, 1.0).intensity);
+            apart = apart.max((a.at(t, 1.0).intensity - b.at(t, 1.0).intensity).abs());
+        }
+        assert!(apart > 0.05, "two neighbouring candles ran in step: {apart}");
+    }
+
+    /// `fireFlicker 0` is the off switch — a hard identity, not merely a small wobble.
+    #[test]
+    fn gain_zero_is_steady_and_gain_two_is_double() {
+        let f = FlameFlicker::new(FlameKind::Torch, 99);
+        for k in 0..500 {
+            let t = k as f32 * 0.02;
+            assert_eq!(f.at(t, 0.0).intensity, 1.0);
+            assert_eq!(f.at(t, 0.0).blue, 1.0);
+            // Every term is linear in the gain, so doubling it doubles the excursion exactly.
+            let (a, b) = (f.at(t, 1.0).intensity, f.at(t, 2.0).intensity);
+            assert!(((b - 1.0) - 2.0 * (a - 1.0)).abs() < 1e-5);
+        }
+    }
+
+    /// The route rule: a purple magic flame flickers, a lamppost does not, a white fill light does
+    /// not — and the intensity ladder files each on its own rung.
+    #[test]
+    fn only_flames_flicker() {
+        // Flame route wins over any colour test: a green magic brazier is still a fire.
+        assert_eq!(
+            flame_kind_for(true, true, [0.4, 1.0, 0.45], 2.0),
+            Some(FlameKind::Brazier)
+        );
+        // Lamp route: glass, never a flicker — even at a warm hue.
+        assert_eq!(flame_kind_for(false, true, [1.0, 0.72, 0.40], 1.5), None);
+        // Authored + warm ⇒ flickers, filed by intensity.
+        assert_eq!(
+            flame_kind_for(false, false, [1.0, 0.72, 0.40], 0.6),
+            Some(FlameKind::Candle)
+        );
+        // Authored + near-white fill, and authored + cold: neither burns.
+        assert_eq!(flame_kind_for(false, false, [0.9, 0.88, 0.86], 1.5), None);
+        assert_eq!(flame_kind_for(false, false, [0.45, 0.65, 1.0], 1.5), None);
+        // The ladder itself, at the synthesiser's own rungs.
+        for (i, k) in [
+            (0.6, FlameKind::Candle),
+            (1.5, FlameKind::Torch),
+            (2.0, FlameKind::Brazier),
+            (3.0, FlameKind::Bonfire),
+        ] {
+            assert_eq!(FlameKind::from_intensity(i), k, "rung {i}");
+        }
+    }
+}
diff --git a/crates/benilla-world/src/lighting/global_light.rs b/crates/benilla-world/src/lighting/global_light.rs
index 82c0a257..b7419fb0 100644
--- a/crates/benilla-world/src/lighting/global_light.rs
+++ b/crates/benilla-world/src/lighting/global_light.rs
@@ -21,6 +21,8 @@ use bevy::render::render_resource::{Buffer, BufferDescriptor, BufferUsages};
 use bevy::render::renderer::{RenderDevice, RenderQueue};
 use bevy::render::{Render, RenderApp, RenderSystems};
 
+// MONKEY (flame flicker): the wobble's component + evaluator, folded into the packed colour below.
+use super::flicker::{FlameFlicker, FlickerMod};
 use super::prop_probes::MAX_PROP_PROBES;
 use super::{sh, WowLighting};
 use crate::dev_state::DebugState;
@@ -34,7 +36,9 @@ use crate::view::WorldCamera;
 /// per-material uniforms fed by `apply_wow_lighting` — editing this layout does NOT reach them.)
 ///   0 light_ambient (w=Mod2x 1.0) · 1 light_diffuse (w=clamp on) · 2 light_sun (w=dir/SH enable) ·
 ///   3 light_spec (w=terrain shininess 20) · 4 fog_color (w=enable) · 5 fog_params (x=start y=end w=farclip) ·
-///   6-8 sh_c10_{r,g,b} · 9-11 sh_c13_{r,g,b} · 12 sh_c16 ·
+///   6-8 sh_c10_{r,g,b} · 9-11 sh_c13_{r,g,b} · 12 sh_c16 (.w = the world-shadow flag in the
+///      integer part, MONKEY (bake floor) `interiorBakeFloor × interiorGain` in the fraction —
+///      [`BAKE_LANE_SCALE`]) ·
 ///   13-14 water river {shallow,deep} (w=alpha) · 15-16 water ocean {shallow,deep} (w=alpha) ·
 ///   17 grade — `.x` = the SIDN night fraction (`WowLighting::sidn_night`: 1 overnight, 0 all day;
 ///      `wow_model.wgsl` scales every WMO SIDN material's authored emissive by it); `.yzw` = the
@@ -43,9 +47,23 @@ use crate::view::WorldCamera;
 ///      camera-in-WMO MFOG crossfade; == the scene fog outdoors). Read only by `wow_model.wgsl`'s
 ///      interior lanes (round-6 Q-I consumer map); terrain mirrors the rows for layout only ·
 ///   20 point_count (x = live entries) · 21+ the point-light table, TWO rows per light:
-///      `[pos.xyz, range]`, `[rgb, 0]` (decision 0278 — the Gouraud point term reads this in the
+///      `[pos.xyz, range]`, `[rgb, lane]` (decision 0278 — the Gouraud point term reads this in the
 ///      VERTEX stage; bevy's own clusterable buffer is fragment-only in the view bind-group layout,
 ///      so the lights ride our buffer instead).
+///      MONKEY (light lanes): the colour row's `.w` — free until now — is the **lane discriminator
+///      AND the interior EFFECTIVE RADIUS in one float**: `0.0` = an EXTERIOR light, anything
+///      `> 0.5` = an INTERIOR fixture whose value IS its radius `R` in yards ([`interior_reach`] —
+///      the authored MOLT end × `interiorAttenScale`, always clamped ≥ 1.0, so the two cases can
+///      never be confused; the shader derives the whole soft profile from `R`, out to a `2R` fill
+///      dome). MONKEY (light lane by position): which side a light falls on is decided by WHERE IT
+///      STANDS ([`LightLane`] / [`classify_light_lanes`]), not by whether it claims a room — that
+///      is what lets Stormwind's street torches light the cobbles while the Goldshire inn's
+///      fixtures still stay off the lawn. The two consumer families are DISJOINT: the exterior
+///      `point_light_sum` / `wmo_exterior_point_sum` (terrain/wow_model/static_gx) skip `> 0.5`
+///      and the interior `interior_room_light` (wow_model/static_gx) skips `< 0.5`, which is what
+///      stops an inn's candles pooling on the grass outside its wall and an outdoor campfire
+///      lighting the floor through a closed door. `[pos.xyz, range]`'s `range` is UNTOUCHED
+///      (still the 48 yd candidacy constant), so the exterior lanes are byte-identical.
 ///
 /// The GPU buffer is LARGER than this per-frame blob: the interior-prop probe table
 /// (`lighting::prop_probes`, 7 rows per slot) lives at its tail — [`light_blob_bytes`] sizes the
@@ -113,7 +131,9 @@ pub fn pack_model_core_rows(
     rows[6][3] = ambient[0]; // the DC lanes carry ambient alone
     rows[7][3] = ambient[1];
     rows[8][3] = ambient[2];
-    rows[12][0] = sun[6].x; // 12 sh_c16 xyz — .w is a free lane (see the struct comment)
+    rows[12][0] = sun[6].x; // 12 sh_c16 xyz — .w is the shared world-shadow/bake-floor lane, written
+                            // by `build_light_data` alone (the portrait booth leaves it 0, so a
+                            // studio portrait takes neither — the frozen look is deliberate)
     rows[12][1] = sun[6].y;
     rows[12][2] = sun[6].z;
     // 17 `.yzw` — the sun's SH DC redistribution at intensity 1 (`D·(4/17)(0.375+0.9375(uₓ²+u_y²))`
@@ -142,11 +162,42 @@ pub fn commit_raw(rgb: [f32; 3]) -> [f32; 3] {
     rgb.map(|c| c.max(0.0))
 }
 
-/// Capacity of the packed point-light table (fixed-size in the WGSL mirror structs — keep in sync).
-/// 256 lights × 2 rows × 16 B = 8 KB — generous for the densest streamed village/city interior set;
-/// [`build_light_data`] packs the nearest-to-camera first when over capacity.
+/// **Slot** capacity of the packed point-light table (fixed-size in the WGSL mirror structs — keep
+/// in sync). 256 lights × 2 rows × 16 B = 8 KB — generous for the densest streamed village/city
+/// interior set; [`build_light_data`] packs the nearest-to-camera first when over capacity.
+///
+/// This is the BUFFER shape (`LightStd430` and [`RoomClaimTable`] size against it) and it must not
+/// move: the blob is 8528 B and is mirrored by three shaders plus the portrait booth. How many of
+/// those slots may actually hold a light is [`MAX_LIVE_POINT_LIGHTS`], which is one less.
 pub(super) const MAX_POINT_LIGHTS: usize = 256;
 
+/// MONKEY (ext light k8): how many of [`MAX_POINT_LIGHTS`] slots may hold a LIVE entry — **255**,
+/// one short of the buffer.
+///
+/// The three shaders publish each draw unit's chosen exterior lights from the vertex stage to the
+/// fragment stage as a packed index list (`ext_sel`). Widening that list from three lights to eight
+/// — the fix for the Darkmoon Faire "scars", where adjacent draw units kept different threes out of
+/// 15+ synthesised torch lights and the disagreement drew a straight edge across the grass — cost
+/// bits: eight ranks in two u32s is **8 bits each**, so an index runs 0..=254 and **255 is the
+/// `EXT_SEL_EMPTY` sentinel** for "this rank is unfilled". A 256th live light would pack as 255 and
+/// every shader would read it as "stop here", silently truncating that unit's whole list.
+///
+/// So the pack truncates one entry earlier. The lights are sorted nearest-camera-first before the
+/// truncation, so the one this drops is the farthest of a 256-strong set — sub-pixel and usually
+/// fogged at that density. The BUFFER keeps all 256 slots, so nothing about the layout, the 8528 B
+/// blob or the room-claim table changes.
+pub(super) const MAX_LIVE_POINT_LIGHTS: usize = MAX_POINT_LIGHTS - 1;
+
+/// MONKEY (dynamic interiors): a fixture this close to the camera (yd) is packed regardless of the
+/// portal flood — see the room term in [`build_light_data`]. Sized to a WHOLE BUILDING PLUS its
+/// approach, not just the room: at 40 yd, walking around the outside of the inn kept crossing the
+/// boundary and a fixture would evict, so an interior-classified NPC by the door brightened and
+/// dimmed as the camera moved (issue A). 90 yd keeps a building's fixtures admitted the whole time
+/// you are near it; the per-fixture 48 yd range check still gates which fragments they actually
+/// light, so the wider admit only affects table MEMBERSHIP, never reach. (256-slot cap: Goldshire's
+/// buildings stay well under it at this radius.)
+const INTERIOR_NEAR_ADMIT: f32 = 90.0;
+
 /// Pack lights only within this camera distance (yd). A point light's whole visible effect lives
 /// within its ~48 yd candidacy range (`spawn::POINT_LIGHT_RANGE`, the packed `.w`); a pool farther
 /// than ~300 yd is sub-pixel and usually fogged, and the cap keeps the per-vertex selection walk
@@ -175,6 +226,403 @@ const POINT_PACK_RADIUS: f32 = 300.0;
 #[derive(Component)]
 pub struct LightRooms(pub(crate) crate::wmo_portal::WmoGroupVis);
 
+impl LightRooms {
+    /// MONKEY (fire GO lights): claim a room for a light spawned OUTSIDE this crate — the app-side
+    /// carried lights (`benilla_app::entities::carried_light`), whose owner's room comes from the
+    /// interior classifier rather than from a WMO's own MODD/MOLR tables. Without a constructor the
+    /// tuple field's `pub(crate)` made the component unbuildable in benilla-app, so a GameObject's
+    /// torch could never carry a room — and therefore could never be promoted to a cube-map shadow
+    /// caster (`torch_shadow's candidate query is `With<WorldPointLight>, With<LightRooms>`).
+    pub fn new(rooms: crate::wmo_portal::WmoGroupVis) -> Self {
+        Self(rooms)
+    }
+}
+
+/// MONKEY (room gate): the rooms a fixture may **LIGHT** — deliberately a different question from
+/// [`LightRooms`], which answers "which rooms must be VISIBLE for this light to exist at all".
+///
+/// The gate needs a set that covers every room the fixture actually stands in the middle of, and
+/// the authored MOLR relation alone does not supply one. Measured on the shipped 1.12 corpus
+/// (`benilla-extract wmolights` + the group flags):
+///   * **Goldshire inn** — 12 groups, and only TWO author a MOLR at all (MOGP `0x200`). Nine of its
+///     ten fixtures are claimed by `g4 "upstairs"`, which is the EXTERIOR-flagged shell spanning
+///     the whole building (`z -0.2 .. 23.3`); the tenth by `g3 "entry"`. Its kitchen, common room,
+///     hall, guest rooms and basement claim NOTHING.
+///   * **NSabbey** — 42 fixtures over 14 groups, but `Main Hall`, `LftWng`, `RtWng`, `Library`,
+///     `Library2`, `Library Wing` and `Stairs2` are named by no MOLR either.
+/// Gating purely on MOLR would therefore black out most of both buildings — the abbey's look is
+/// the one the owner signed off, so that is a regression, not a fix. MOLR is authored for the
+/// reference's own purpose (register GL lights while drawing a VISIBLE group's doodads and units),
+/// not to describe which walls a fixture lights, which the reference took from the MOCV bake.
+///
+/// So the claim set is the UNION of MOLR with the interior groups whose authored MOGI **bounding
+/// box contains the fixture** — dense, authored, static, and resolved once at spawn. On the inn
+/// that gives every room its own fixtures back while leaving the basement (`z <= 0.45`, no fixture
+/// inside) and the far guest room claimed by nobody, which is exactly the reported leak; on the
+/// abbey every interior group gets at least one fixture, so its look is preserved.
+///
+/// MONKEY (portal claims): the set is now built by [`benilla_formats::room_claims`] and is the
+/// COMPLETE, ordered claim list — MOLR folded in, plus the containment above, plus the groups one
+/// open PORTAL away within the fixture's reach (the "light crosses a doorway" rule that stops a
+/// continuous floor changing brightness in a straight line at a group boundary). Because it already
+/// contains MOLR, [`RoomClaim::build`] takes it INSTEAD of the MOLR list rather than unioning the
+/// two: re-adding MOLR there would re-admit exactly the district-scale shells the rule deliberately
+/// marks exterior-lane-ineligible.
+///
+/// Each entry is `group | `[`LIT_ROOM_EXT_DENY`]: bit 15 marks a claim that gates the fixture but
+/// must not be honoured by the exterior batch lane (see the constant).
+///
+/// The WMO MOLT lane inserts this, and since MONKEY (interior prop lights) so does the WMO MODD
+/// PROP lane — a hanging lantern whose flame light we synthesise needs the same room claim an
+/// authored fixture gets, or the gate would refuse it in the very room it hangs in. A
+/// carried/GameObject light already carries the single room the interior classifier put it in,
+/// through [`LightRooms`], and needs no supplement.
+#[derive(Component)]
+// MONKEY (review fixes): the placement belongs to the lighting claims themselves. A fixture
+// contained by a room can have NO MOLR/MODR visibility membership; it still needs a GPU room key.
+pub struct LightLitRooms {
+    pub(crate) rooms: crate::wmo_portal::WmoGroupVis,
+    /// MONKEY (soft portal claims): index-parallel with `rooms.groups` — each claim's softness.
+    /// A separate array rather than more bits in the `u16` id because a fade is 4 floats and a
+    /// group id has 15 spare BITS; index-parallel rather than a map because the packer walks the
+    /// two together and the GPU record interleaves them at a fixed stride, so a length mismatch is
+    /// a claim gated by another claim's doorway. Built by the one producer
+    /// (`terrain_stream::spawn::fx`'s `pack_claims`), which is why the invariant holds by
+    /// construction; a legacy/fallback path that has no fades supplies an EMPTY slice, read as
+    /// "every claim is hard", i.e. exactly the binary gate this replaced.
+    pub(crate) fades: std::sync::Arc<[ClaimFade]>,
+}
+
+/// MONKEY (soft portal claims): the softness of ONE claim — the doorway the fixture's light came
+/// through and how far past it the light still reaches.
+///
+/// `radius == 0` is the HARD claim (containment/MOLR): weight 1 everywhere in the group, which is
+/// what the gate did for every claim before this — and it is [`ClaimFade::default`], so every path
+/// that has no fade to give (a carried light's raw MOLR rooms) gates exactly as it always did. A
+/// portal claim carries the real numbers, and the shader turns them into
+/// `w = entry * (1 − smoothstep(0, radius, max(|P − center| − slack, 0)))`.
+///
+/// **`center` is in BEVY WORLD space**, not the WMO model space `benilla_formats::room_claims`
+/// measured it in: the shader has only the fragment's world position, and converting there would
+/// need the placement's matrix per fragment. The producer holds that matrix already, so the
+/// conversion happens once, at claim time.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct ClaimFade {
+    /// The portal's centre, BEVY WORLD space.
+    pub center: Vec3,
+    /// The portal polygon's bounding-sphere radius (yd) — distance inside it counts as zero, so
+    /// the doorway itself is weight 1 on both sides of the group plane.
+    pub slack: f32,
+    /// The fade length (yd): the fixture's reach still unspent at the doorway. **0 = hard claim.**
+    pub radius: f32,
+    /// The weight the claim already carries AT `center` — 1 for a first hop, and for a second hop
+    /// whatever the first hop's fade had decayed to by that door. Multiplies the smoothstep, which
+    /// is what keeps a two-hop chain continuous (and monotone) at every threshold.
+    pub entry: f32,
+}
+
+/// MONKEY (portal claims): bit 15 of a [`LightLitRooms`] entry — "this claim gates the fixture, but
+/// the EXTERIOR batch lane must ignore it". A group index cannot reach it (the record's room key is
+/// 12 bits), so it rides for free in the id.
+///
+/// It exists for one population: a city's district-scale EXTERIOR shell, whose MOGI box swallows
+/// the interiors inside it (`Stormwind.wmo`: 470 of its 606 fixtures stand inside one). Such a
+/// claim must stay in the set, because a fixture stripped of its only claim is packed UNGATED and
+/// the ungated arm fails OPEN — one candle lighting every room of the building. But it must not
+/// reach the exterior lane, which would put that candle's pool on the cobbles outside the wall.
+/// A building-scale exterior group (the Goldshire inn's shell, `57.7 x 32.2 yd`) carries no deny
+/// bit and IS lit — that is bug B's second half.
+pub const LIT_ROOM_EXT_DENY: u16 = 0x8000;
+
+/// MONKEY (room gate): u32 per packed light in the claim table — `[instance, count, g0..g5]`,
+/// MONKEY (soft portal claims) followed by one 4-word FADE record per claim slot
+/// (`[center.x, center.y, center.z, radius|slack]`) at [`ROOM_CLAIM_FADE`].
+/// **Must equal `ROOM_CLAIM_STRIDE` in `static_gx.wgsl`** — a mismatch reads every fixture's
+/// claims out of another fixture's record, which blanks (or floods) every building at once.
+pub const ROOM_CLAIM_STRIDE: usize = 32;
+/// MONKEY (soft portal claims): the first FADE word of a claim record, i.e. `2 + ROOM_CLAIM_MAX`.
+/// Slot `k`'s fade is `[ROOM_CLAIM_FADE + 4k .. +4]`. **Must equal `ROOM_CLAIM_FADE` in
+/// `static_gx.wgsl`.**
+pub const ROOM_CLAIM_FADE: usize = 8;
+/// MONKEY (soft portal claims): the fixed-point scale of the packed radius/slack pair — both ride
+/// one u32 as `u16` yards x 256 (low half radius, high half slack). 1/256 yd is far below anything
+/// a smoothstep over 2..48 yd can show, and the range tops out at 255.99 yd, which is five times
+/// the widest reach the packer will ever hand out (`CLAIM_REACH_MAX` = 48). Fixed point rather
+/// than two f32 lanes because the alternative is a 40-word stride for two numbers that are already
+/// coarse; fixed point rather than f16 because both sides are three arithmetic ops with no
+/// bit-twiddling to get wrong. **Must equal `CLAIM_FADE_SCALE` in `static_gx.wgsl`.**
+pub const CLAIM_FADE_SCALE: f32 = 256.0;
+/// MONKEY (room gate): claims a fixture can carry before it is packed UNGATED instead (fail-open —
+/// a truncated list would black out the rooms that fell off the end). **Must equal
+/// `ROOM_CLAIM_MAX` in `static_gx.wgsl`.**
+pub const ROOM_CLAIM_MAX: usize = 6;
+
+/// MONKEY (portal claims): bit 16 of a packed GPU claim word — "the EXTERIOR batch lane may honour
+/// this claim". The CPU side of the same fact is [`LIT_ROOM_EXT_DENY`] (inverted, see
+/// [`RoomClaim::write`]). **Must equal `CLAIM_EXT_OK` in `static_gx.wgsl`**, and must stay clear of
+/// the 12-bit `+1` group id below it.
+pub const CLAIM_EXT_OK: u32 = 1 << 16;
+
+/// MONKEY (soft portal claims): bits 17..=24 of a packed GPU claim word — [`ClaimFade::entry`] as
+/// a byte (`round(entry * 255)`). It rides the id word rather than the fade record because the id
+/// word has 15 bits going spare above [`CLAIM_EXT_OK`] (a group index is 12) while the fade record
+/// is four words of exact f32 centre plus a full u16/u16 pair, and widening the stride for one
+/// byte would cost 256 x 4 more bytes of buffer for nothing. A HARD claim writes 0 here and the
+/// shader never reads it (it returns 1.0 the moment it sees `radius == 0`), so the zero padding
+/// cannot be mistaken for "contributes nothing". **Must equal `CLAIM_ENTRY_SHIFT` in
+/// `static_gx.wgsl`.**
+pub const CLAIM_ENTRY_SHIFT: u32 = 17;
+
+/// MONKEY (room gate): this frame's claim table, index-parallel with [`WowLightData`]'s point
+/// entries. Its own resource and its own GPU buffer on purpose: [`LightStd430`] is mirrored by
+/// three shaders plus the portrait booth and must never be resized, and only `static_gx` reads
+/// this. `static_gx::render` owns the buffer and the binding.
+#[derive(Resource, Clone, ExtractResource)]
+pub struct RoomClaimTable(pub Box<[u32; ROOM_CLAIM_STRIDE * MAX_POINT_LIGHTS]>);
+
+/// MONKEY (room gate): the claim table's byte size — the one place `static_gx::render` sizes its
+/// GPU buffer from, so the table cannot grow here and leave the binding short (a bound storage
+/// buffer smaller than the shader's runtime-sized array fails validation at draw time, which
+/// vanishes every building).
+pub fn room_claim_bytes() -> u64 {
+    (ROOM_CLAIM_STRIDE * MAX_POINT_LIGHTS * std::mem::size_of::<u32>()) as u64
+}
+
+impl Default for RoomClaimTable {
+    fn default() -> Self {
+        Self(Box::new([0; ROOM_CLAIM_STRIDE * MAX_POINT_LIGHTS]))
+    }
+}
+
+/// MONKEY (interior attenuation): a fixture's **authored attenuation end** in yards — the WMO
+/// MOLT record's `attenuation_end` (`+0x2c`), carried from the spawn to the packer because
+/// `PointLight` has nowhere to put it and `PointLight::range` means something else entirely (the
+/// 48 yd *candidacy* constant, which the exterior lanes still read).
+///
+/// Only [`crate::terrain_stream::spawn`]'s MOLT lane inserts it. Every other source is an **M2**
+/// light, whose authored attenuation pair is demonstrably NOT a reach in this corpus — a Karazhan
+/// BONFIRE authors `end = 0.97` yd and the whole orc brazier/firepit family `0.33/0.97`, while
+/// `2.22/5.56` is a template default stamped on half the weapons and glue models.
+/// `benilla_formats::M2Light`'s own doc says it: "the GL curve is fixed and ignores these" — the
+/// fields are parsed as a cull hint no consumer reads. So M2 sources get the bucketed
+/// [`m2_light_reach`] instead, derived in the packer from the intensity they already carry — which
+/// also means the app-side spawners (carried torches, transport props) need no change at all.
+///
+/// MOLT is the opposite case and the reason this exists: the reference really does fold a MOLT
+/// fixture through its authored window (wow-re `trace-forensics-abbey-interior-d3d` §4 fitted the
+/// fold at exactly the `+0x28/+0x2c` values), and the vanilla numbers are sane — Goldshire inn
+/// 6.97-9.53 yd over 10 fixtures, its blacksmith 6.0 over 3, NSabbey 4.17-5.56 over 42.
+#[derive(Component)]
+pub struct LightReach(pub f32);
+
+/// MONKEY (light lane by position): which consumer family a point light belongs to — decided by
+/// WHERE THE LIGHT PHYSICALLY IS, not by whether it claims a room.
+///
+/// [`build_light_data`] used `Has<LightRooms>` for this, and that conflated two different
+/// questions. `LightRooms` answers "which rooms must be visible for this light to exist" (the
+/// portal gate + the torch-shadow eligibility, decision 0689) — a MODR/MOLR *reference*. The lane
+/// answers "is this light inside a sealed room, or out on the street", which is a fact about
+/// geometry. In vanilla content the two disagree constantly, in both directions:
+///
+/// - **Stormwind.** 235 of its 606 MOLT fixtures are named ONLY by EXTERIOR-class groups (MOGP
+///   `& 0x48`) — the Trade District's street torches and hanging lanterns — and 45 more are named
+///   by no group at all. Under the old rule every one of the 235 was filed INTERIOR, so the
+///   exterior consumers skipped it and the interior consumer never runs on a street: they lit
+///   *nothing at all*. That is bug B's first cause.
+/// - **The Goldshire inn.** Its 10 MOLT fixtures claim group 4, which IS exterior-flagged, yet
+///   they physically stand inside the inn's rooms. A rule keyed on the claimed group's FLAGS would
+///   file them EXTERIOR and put a warm pool on the lawn outside the wall — precisely the leak the
+///   lane split was introduced to stop. A rule keyed on POSITION files them interior, because the
+///   classifier's down-ray from each fixture lands on the inn's own interior-class floor.
+///
+/// So the verdict is the client's own light-attach ray ([`crate::wmo_portal::indoor_verdict_at`]
+/// with `LightAttach::DownRay` — the same predicate that classifies a standing NPC), run ONCE per
+/// static light in [`classify_light_lanes`] and refreshed only when the resident WMO set changes.
+/// A CARRIED light takes its lane from its owner's already-resolved room instead
+/// (`benilla_app::entities::carried_light`): the classifier has run for the bearer, and re-raying
+/// from a swinging torch would be one ray per light per frame for an answer we already hold.
+#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)]
+pub struct LightLane {
+    /// `true` ⇒ the packer writes the interior reach into the colour row's `.w`; `false` ⇒ `0`.
+    pub interior: bool,
+    /// The [`WmoResidency`](crate::interior::WmoResidency) generation this verdict was taken at —
+    /// a light classified before its building streamed in reads `Outdoors`, and must be re-asked
+    /// once the building is there. [`SETTLED`](Self::SETTLED) means "never re-ask".
+    pub generation: u32,
+}
+
+impl LightLane {
+    /// A generation that never goes stale — the carried lane's stamp (see the type doc).
+    pub const SETTLED: u32 = u32::MAX;
+
+    /// The carried lane's constructor: interior iff the bearer is standing in a room.
+    pub fn carried(interior: bool) -> Self {
+        Self {
+            interior,
+            generation: Self::SETTLED,
+        }
+    }
+}
+
+/// MONKEY (interior attenuation): the interior reach (yd) of an **M2** point light of committed
+/// intensity `i`, bucketed on the same ladder [`benilla_formats::fire_intensity`] buckets a
+/// synthesised flame onto (candle 0.6 · torch 1.5 · brazier 2.0 · bonfire 3.0), so a synthesised
+/// source lands on its own bucket exactly and an authored one is filed by how bright it is.
+///
+/// Bucketing rather than reading the record is the finding, not a shortcut — see [`LightReach`]:
+/// the authored M2 attenuation pair does not describe a reach in this corpus. The yard figures are
+/// sized so the pool matches the flame you can see: a table candle lights its table, a wall torch
+/// its corner, a brazier the end of a hall, a bonfire the clearing around it.
+pub fn m2_light_reach(intensity: f32) -> f32 {
+    // MONKEY (portal claims): the ladder itself lives in `benilla_formats::room_claim` — the spawner
+    // needs it to size a synthesised prop light's PORTAL HOP, and the offline `wmolamps` audit needs
+    // the identical rungs to predict what the runtime will claim. One ladder, both readers.
+    benilla_formats::room_claim::m2_light_reach(intensity)
+}
+
+/// MONKEY (soft falloff): the **effective radius** packed into an interior entry's lane — the
+/// authored reach after the live `interiorAttenScale` ([`DynamicInteriors::atten_scale`], default
+/// 1.6). The shader derives its whole profile from this one number as a fraction of it (soft core
+/// at `0.26 R`, window vanishing at `R`, fill dome out to `1.5 R` — see `interior_room_light`), so
+/// the cvar is a pure zoom on every pool at once rather than three separate knobs.
+///
+/// `scale == 0` is the A/B **off** switch and maps to [`INTERIOR_LEGACY_REACH`] — the 48 yd the
+/// lane used before there was a window at all. Under the soft profile that is the widest, flattest
+/// pool the lane can make (the core alone is ~12.5 yd wide), i.e. the nearest thing left to the
+/// pre-window flat lane; it is no longer the byte-exact restore it was, because the window's SHAPE
+/// moved with the change. The `max(…, 1.0)` floor keeps the value clear of the `0.5` lane
+/// threshold at any scale.
+///
+/// MONKEY (torch caster selection): `pub` so `benilla_app::torch_shadow` can rank fixtures by the
+/// SAME effective radius the shader windows them with. Recomputing it there would be a second
+/// copy of a value the packer already owns, and a drift between them would rank a fixture the
+/// shader has already faded to black.
+pub fn interior_reach(reach: f32, scale: f32) -> f32 {
+    if scale <= 0.0 {
+        return INTERIOR_LEGACY_REACH;
+    }
+    (reach * scale).clamp(1.0, INTERIOR_LEGACY_REACH)
+}
+
+/// The reach an interior fixture had before the authored window existed: `spawn::POINT_LIGHT_RANGE`.
+/// Mirrored as a plain constant because it is now a *legacy* value — the A/B's off arm — rather
+/// than the lane's working range, and also the cap on a widened one (past it the packed table's own
+/// membership rules, not the window, decide what a fragment sees).
+const INTERIOR_LEGACY_REACH: f32 = 48.0;
+
+/// MONKEY (fire GO lights): marks a `PointLight` whose colour/intensity were SYNTHESISED from a
+/// model's flame particle emitter rather than authored ([`benilla_assets::ModelLight::synthetic`]).
+///
+/// Two lanes read it, both in [`build_light_data`]: the `fireLightGain` cvar multiplies the
+/// intensity of exactly these entries (so the dial is live — retuning it does not respawn a single
+/// prop, which is the whole point of packing it here rather than folding it in at spawn), and the
+/// `WOW_POINTS_DUMP` census counts them, so "is that light in the table one we invented?" is a
+/// number rather than a guess.
+#[derive(Component)]
+pub struct SyntheticFireLight;
+
+/// MONKEY (fire GO lights): the live gain on every SYNTHESISED fire light (`fireLightGain`, default
+/// 1.0), bridged from benilla-app's cvars the way [`DynamicInteriors`] is. `0` turns the whole
+/// invented-light lane off without touching the authored ones — the kill switch for a heuristic
+/// that, unlike everything around it, is not byte-verified against anything.
+#[derive(Resource, Clone, Copy, PartialEq, Debug)]
+pub struct FireLightGain(pub f32);
+
+impl Default for FireLightGain {
+    fn default() -> Self {
+        Self(1.0)
+    }
+}
+
+/// MONKEY (spellLightGain): marks a `PointLight` that a SPELL EFFECT invented — a kit's aura glow,
+/// a missile's core, an impact flash, a firework shell's burst. The app's own
+/// `entities::spell_fx::SpellLight` carries the envelope, the mode and the budget; this is the
+/// two-word shadow of it the PACKER needs.
+///
+/// A world-side marker rather than moving `SpellLight` down here, deliberately. `SpellLight` is a
+/// LIFECYCLE — it reads `FxDecay` off the effect root, it knows `SpellLightMode::{Kit, Missile,
+/// Burst}`, it is aged and evicted by the effect lane's own budget — and every one of those
+/// concepts belongs to benilla-app's effect layer, which benilla-world knows nothing about and must
+/// not learn. What the packer needs is one bit ("scale this row by `spellLightGain`, not by
+/// `fireLightGain`"), so one bit is what crosses the crate boundary; the app inserts it at the one
+/// spawn site that makes a spell light (`carried_light::spawn_spell_light_child`), beside the other
+/// three markers it already stamps there.
+///
+/// Every spell light also carries [`SyntheticFireLight`] (it IS an invented source, and the census
+/// counts it as one). This marker OVERRIDES that one in the gain fold — see [`build_light_data`].
+#[derive(Component)]
+pub struct SpellFxLight;
+
+/// MONKEY (spellLightGain): the live gain on every spell-effect light (`spellLightGain`, default
+/// 1.0), bridged from benilla-app's cvars exactly as [`FireLightGain`] is, and applied at the same
+/// place for the same reason (a dial that needed a respawn to retune is not a dial).
+///
+/// Separate from `fireLightGain` because the two answer different questions. The fire gain tunes a
+/// CONTENT HEURISTIC — "how bright should the light we invented for this campfire prop be" — and
+/// its `0` is the kill switch for a lane that is not byte-verified against anything. This one tunes
+/// a GAMEPLAY lane: spell lights are short, bright and numerous, they are the one light source that
+/// can strobe a room during a fight, and a player who wants combat flashes turned down must not
+/// have to put out every hearth in the world to get it.
+#[derive(Resource, Clone, Copy, PartialEq, Debug)]
+pub struct SpellLightGain(pub f32);
+
+impl Default for SpellLightGain {
+    fn default() -> Self {
+        Self(1.0)
+    }
+}
+
+/// MONKEY (torch shadows, Stage B): marks a `PointLight` that exists ONLY to render a cube shadow
+/// map (`benilla_app::torch_shadow`'s promoted fixtures). Such a proxy must NOT enter the
+/// `wow_light` light table — benilla's receivers would treat it as a real fixture and its nominal
+/// intensity (~1000, committed far over gamut) would blast light onto everything near the building,
+/// blinking as the proxy repositions. [`build_light_data`]'s gather excludes it; only its Bevy cube
+/// map + clusterable entry are wanted.
+#[derive(Component)]
+pub struct ShadowProxyLight;
+
+/// MONKEY (world shadows): whether the realtime WORLD-shadow lane is active this frame (the
+/// `worldShadows` cvar). Set by benilla-app's shadow rig; read by [`build_light_data`], which packs
+/// it into the free `sh_c16.w` light lane so `terrain.wgsl` can suppress the baked MCSH terrain
+/// shadows ONLY when the world is casting realtime — not merely because a shadow sun exists (the
+/// sun also exists for character-only shadows, which must leave MCSH alone). A dedicated resource
+/// rather than a `WowLighting` field because `update_time_lighting` wholesale-overwrites that.
+#[derive(Resource, Clone, Copy, Default)]
+pub struct WorldShadowActive(pub bool);
+
+/// MONKEY (distance slider): the realtime-shadow render distance in yards (the `shadowDistance`
+/// slider), bridged from benilla-app's shadow rig. [`build_light_data`] packs it into a free light
+/// lane so the receivers (`terrain.wgsl`/`wow_model.wgsl`) fade the realtime shadow at THIS distance
+/// rather than a fixed one — the fade must track the cascade's actual `maximum_distance`.
+#[derive(Resource, Clone, Copy)]
+pub struct ShadowDistance(pub f32);
+
+impl Default for ShadowDistance {
+    fn default() -> Self {
+        Self(80.0)
+    }
+}
+
+/// MONKEY (sun shadow perf): the live `shadowFilter` choice, bridged from benilla-app's shadow rig
+/// and extracted into the RENDER world.
+///
+/// Every other realtime-shadow receiver benilla has is a Bevy `Material` (terrain, `wow_model`), so
+/// its pipeline picks the PCF branch up automatically from the view's `ShadowFilteringMethod`. The
+/// retained `static_gx` pass is specialized BY HAND, so it has to be told: `static_gx::render`
+/// folds this into its pipeline key and pushes the matching `SHADOW_FILTER_METHOD_*` shader def.
+/// Without it the two halves of the frame would disagree — the ground filtered one way and the
+/// buildings standing on it the other.
+///
+/// `true` = Gaussian (9 taps, the default look); `false` = Hardware2x2 (1 tap).
+#[derive(Resource, Clone, Copy, PartialEq, Eq, Debug, ExtractResource)]
+pub struct ShadowFilterGaussian(pub bool);
+
+impl Default for ShadowFilterGaussian {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
 /// **An authored WoW point light source** — an M2 light, a WMO MOLT omni, a carried torch —
 /// as the packed light table reads it. This used to be Bevy's `PointLight`, kept purely as a
 /// data carrier: [`build_light_data`] was its only reader in the engine, every lit surface
@@ -223,8 +671,22 @@ pub struct SharedLightBuffer(pub Buffer);
 /// creation, and the render-world upload.
 pub(super) fn register(app: &mut App) {
     app.init_resource::<WowLightData>()
+        // MONKEY (room gate): the per-fixture room claims, packed beside the point table.
+        .init_resource::<RoomClaimTable>()
+        .init_resource::<WorldShadowActive>()
+        .init_resource::<ShadowDistance>()
+        // MONKEY (sun shadow perf): the live PCF choice, extracted for `static_gx`'s hand-rolled
+        // pipeline (every Bevy-material receiver keys off the view component instead).
+        .init_resource::<ShadowFilterGaussian>()
+        .add_plugins(ExtractResourcePlugin::<ShadowFilterGaussian>::default())
+        .init_resource::<DynamicInteriors>()
+        // MONKEY (fire GO lights): the live gain on synthesised fire lights.
+        .init_resource::<FireLightGain>()
+        // MONKEY (spellLightGain): and the one on spell-effect lights, which overrides it.
+        .init_resource::<SpellLightGain>()
         .init_resource::<super::prop_probes::PropProbeExtract>()
         .add_plugins(ExtractResourcePlugin::<WowLightData>::default())
+        .add_plugins(ExtractResourcePlugin::<RoomClaimTable>::default())
         .add_plugins(ExtractResourcePlugin::<SharedLightBuffer>::default())
         .add_plugins(ExtractResourcePlugin::<super::prop_probes::PropProbeExtract>::default())
         // PostUpdate, **after transform propagation**: the point table is packed from each light's
@@ -235,7 +697,12 @@ pub(super) fn register(app: &mut App) {
         // never moves, which is why this was invisible until entities started carrying lights.
         .add_systems(
             PostUpdate,
-            build_light_data
+            // MONKEY (light lane by position): the lane classifier is chained BEFORE the packer, so
+            // a light that has stood for a frame is packed on this frame's verdict. Its writes go
+            // through `Commands`, so a NEWLY spawned light is still packed on the fail-safe
+            // fallback for one frame — see that fallback's note in `build_light_data`.
+            (classify_light_lanes, build_light_data)
+                .chain()
                 .after(bevy::transform::TransformSystems::Propagate)
                 .after(super::update_time_lighting),
         )
@@ -291,23 +758,461 @@ pub(super) fn per_frame_blob_bytes() -> u64 {
 /// std430 blob. The `.w` lanes carry the faithful invariants the shaders expect (Mod2x 1.0, clamp on,
 /// terrain shininess 20, fog-enable, farclip wall); the model SH coeffs and both water swatches are
 /// derived here once per frame (they used to be recomputed + pushed per-material in `apply_wow_lighting`).
+/// MONKEY (night fade): realtime-shadow day strength from the celestial sun's height
+/// (`sin(elevation)`): 0 at or below the horizon, ramping to 1 by ~12° so shadows fade out at dusk
+/// and in at dawn. A smoothstep for a soft knee rather than a hard switch at the horizon.
+fn sun_shadow_strength(sun_height: f32) -> f32 {
+    let t = (sun_height / 0.208).clamp(0.0, 1.0); // 0.208 ≈ sin(12°)
+    t * t * (3.0 - 2.0 * t)
+}
+
+/// MONKEY (enclosed day floor): how [`DynamicInteriors::daylight`] rides to the shader — as the
+/// FRACTIONAL part of the packed `wmo_fog_params.w` lane, `w = 1 + debug + daylight * this`.
+///
+/// **There was no free f32 left.** [`LightStd430`] is 8528 B, mirrored by three shaders plus the
+/// portrait booth, and must not grow; every `.w` in rows 0..=20 is spoken for (the Mod2x/clamp/SH
+/// enables, terrain shininess, fog enable, farclip, the ambient DC lanes, `sh_c13_*.w` which the
+/// SH `dot(row, quad)` reads as a real band, the world-shadow flag, the shadow distance, the
+/// exposure). The tail regions are declared only by `wow_model.wgsl`, so `static_gx` — the one
+/// consumer that needs this number — cannot reach them at all.
+///
+/// So it rides a lane that has spare RANGE rather than a spare slot. `wmo_fog_params.w` is packed
+/// as `0` (interior lane off) or `1 + interiorDebug` (0..=4), and every one of its four decodes
+/// across the three shaders is insensitive to a fraction below 0.5:
+///   * `w > 0.5` — the on/off test (`static_gx` x2, `wow_model`): adding to `1 + debug` cannot
+///     reach it from below, and cannot leave it from above.
+///   * `u32(max(w - 1, 0) + 0.5)` — the debug decode (`static_gx` x3, `wow_model`, `terrain`):
+///     `debug + f + 0.5` truncates to `debug` for every `f` in `[0, 0.5)`.
+/// **0.49** keeps a clear margin under that 0.5 cliff while spending the whole of the rest of the
+/// range on the value. `1 + debug` is an exact integer in f32, so the shader's `fract(w)` returns
+/// `daylight * 0.49` bit-for-bit up to the f32 ulp at `w <= 5.49` (~5e-7 — four orders of magnitude
+/// below anything the eye can see in an ambient floor). **Keep in sync with `static_gx.wgsl`'s
+/// `DAYLIGHT_LANE_SCALE`.**
+///
+/// **The default (0.12) is calibrated, not chosen.** At the owner's live cvars (`interiorExposure 4`,
+/// `interiorAmbient 0.02`, `interiorGain 0.7`) the room law's floor is `0.02 x 0.7 = 0.014`, so an
+/// unlit interior fragment renders `1 - exp(-0.014 x 4) = 0.055`. Elwynn at 11:28 renders its
+/// sunlit threshold at luminance **0.831** (`ambient (103,129,154)/255 + diffuse (255,133,0)/255 x
+/// N.L 0.5805`, clamped). With the floor: `1 - exp(-(0.014 + 0.12) x 4) = 0.415`, i.e. **50 % of
+/// the threshold** — a soft step across a doorway instead of a black hole. (0.10 reads 44 %, 0.14
+/// reads 55 %; the 0.35 the brief suggested reads **92 %**, which is a room with no walls.)
+pub const DAYLIGHT_LANE_SCALE: f32 = 0.49;
+
+/// MONKEY (bake floor): how [`DynamicInteriors::bake_floor`] rides to the shader — as the
+/// FRACTIONAL part of the packed `sh_c16.w` lane, `w = world_shadow_flag + bake × this`.
+///
+/// **There is still no free f32.** [`LightStd430`] is 8528 B and mirrored by three shaders plus the
+/// portrait booth (see [`DAYLIGHT_LANE_SCALE`] for the full accounting of why it must not grow).
+/// `wmo_fog_params.w` — the lane the daylight floor rides — is now spent: its integer part is
+/// `1 + interiorDebug` and its fraction is `interiorDaylight × 0.49`, and two fractions cannot
+/// share one lane without a second quantisation. So this one takes the OTHER lane with spare range.
+///
+/// `sh_c16.w` is the world-shadow flag: packed as exactly `0.0` or `1.0`, and it has precisely ONE
+/// decode in the whole shader set — `terrain.wgsl`'s `wow_light.sh_c16.w > 0.5` (the MCSH
+/// suppression gate). `sh_c16.xyz` is a real SH band that `wow_model`/`static_gx` read; neither
+/// read `.w` at all before this, and both now read only its FRACTION. A fraction strictly below
+/// 0.5 therefore cannot move terrain’s decode in either direction: `0 + f` stays below the
+/// threshold, `1 + f` stays above it.
+///
+/// **0.49** keeps the same clear margin under the 0.5 cliff that the daylight lane keeps, and the
+/// packed value is CLAMPED to `[0, 1]` before scaling — `bake_floor` is 0..1 but `interior_gain`
+/// reaches 1.5, so the product alone could reach 1.5 and push the fraction past the cliff (0.735),
+/// which would switch MCSH terrain shadows on for anyone running `interiorBakeFloor 1` with the
+/// Bright preset. The clamp costs nothing real: the slider's useful range is 0..0.3.
+///
+/// `world_shadow_flag` is an exact integer in f32, so the shader's `fract(w)` returns
+/// `bake × 0.49` bit-for-bit up to the f32 ulp at `w <= 1.49` (~6e-8). **Keep in sync with
+/// `static_gx.wgsl` / `wow_model.wgsl`'s `BAKE_LANE_SCALE`.**
+pub const BAKE_LANE_SCALE: f32 = 0.49;
+
+/// MONKEY (bake floor): the CPU half of the `sh_c16.w` pack — the lane word for a world-shadow
+/// flag and a bake floor. Split out so the round-trip test below exercises the SAME arithmetic the
+/// packer runs, not a transcription of it.
+pub fn pack_bake_lane(world_shadow: bool, bake_floor: f32, interior_gain: f32) -> f32 {
+    let flag = if world_shadow { 1.0 } else { 0.0 };
+    flag + (bake_floor * interior_gain).clamp(0.0, 1.0) * BAKE_LANE_SCALE
+}
+
+/// MONKEY (bake floor): the SHADER's decode, transcribed — `fract(w) / BAKE_LANE_SCALE`. Only
+/// exists for the round-trip test; the real decode lives in the two WGSL files.
+#[cfg(test)]
+fn unpack_bake_lane(w: f32) -> f32 {
+    (w - w.floor()) / BAKE_LANE_SCALE
+}
+
+/// MONKEY (dynamic interiors): the live knobs of the interior lane — WMO interior surfaces AND
+/// interior props light from the room's live fixtures (`static_gx.wgsl` `interior_room_light`)
+/// instead of the MOCV bake / the baked prop probe. Bridged every frame from the app-side cvars
+/// (`interiorLight`, `interiorAmbient`, `interiorFill`, `interiorExposure` — benilla-app's
+/// `dynamic_interior` module) the way [`ShadowDistance`] is, so the look is tunable in-game.
+/// `enabled == false` → the faithful baked path. Packed into the free `wmo_fog_params.w` (on/off)
+/// and `point_count.yzw` (the three knobs) lanes.
+#[derive(Resource, Clone, Copy, PartialEq, Debug)]
+pub struct DynamicInteriors {
+    /// The lane on/off (`interiorLight`).
+    pub enabled: bool,
+    /// Base ambient every interior fragment gets, so a fixture-less nook never goes black.
+    pub ambient: f32,
+    /// Bounce gain per fixture — the normal-free "lamps everywhere" glow the bake carried.
+    pub fill: f32,
+    /// Multiplier on the whole light budget before the soft rolloff — the room's brightness.
+    pub exposure: f32,
+    /// MONKEY (soft falloff): live scale on every interior fixture's authored attenuation window
+    /// (`interiorAttenScale`) — the fixture's EFFECTIVE RADIUS is `authored end × this`. Default
+    /// **2.5**: the artists' end is where FULL brightness stops, not where light does, so `1` drew
+    /// a hard-edged disc at exactly that radius. `>2.5` widens the pools, `<2.5` tightens them,
+    /// **`0` disables the window** ([`interior_reach`]). Folded into the packed lane rather than a header lane: the
+    /// window is per-fixture anyway, the header's 21 rows are fully claimed, and the fold keeps the
+    /// shader from carrying a second knob it would have to combine per light.
+    pub atten_scale: f32,
+    /// MONKEY (room gate): the per-room fixture gate (`interiorRoomGate`). `false` packs every
+    /// fixture UNGATED, i.e. the pre-gate behaviour where every INT fixture lights every interior
+    /// surface in range — the live A/B for "is the gate what darkened this room?".
+    pub room_gate: bool,
+    /// MONKEY (interior debug): diagnostic overlay for the interior lane (`interiorDebug`). 0 = off
+    /// (normal shading). 1 = CLASSIFICATION: interior-lit fragments render solid green, so a wrongly
+    /// interior-classified OUTDOOR entity shows up. 2 = SHADOW: the torch-shadow factor as greyscale
+    /// (black = shadowed, white = lit) — shows whether cast shadows are computed at all. 3 = CASTER
+    /// COUNT: how many shadow-casting proxies the fragment sees in `clusterable_objects` (red = 0 —
+    /// the proxies never reached the shader; green = 1; blue = 2; white = 3+).
+    /// MONKEY (ext-class night law): 4 = WMO LANE MAP — every WMO fragment painted by the lighting
+    /// law its GROUP falls under (green interior-class, blue exterior-class at building scale, red
+    /// exterior-class shell/district), terrain and models untouched. The instrument for "is this
+    /// seam a LAW mismatch (two colours) or a CLAIM mismatch (one colour)?".
+    /// Packed with the on/off flag into `wmo_fog_params.w` as `1 + debug` (so `>0.5` still means
+    /// "on").
+    pub debug: u32,
+    /// MONKEY (flame flicker): live gain on every flame's brightness wobble (`fireFlicker`, 0..2).
+    /// `1` = the authored per-kind amplitudes ([`FlameKind::amplitude`]), `0` = steady constants
+    /// (the pre-feature look, and the escape hatch if a flicker ever reads wrong), `2` = doubled.
+    ///
+    /// It rides THIS resource rather than a header lane because it is consumed entirely on the CPU:
+    /// [`build_light_data`] folds the multiplier into the packed colour, so the shader never learns
+    /// the feature exists and `LightStd430` gains no lane. Also why it is not on
+    /// [`FireLightGain`]: that one scales the SYNTHESISED lane only, while a flicker belongs to
+    /// authored wall torches just as much.
+    pub flicker: f32,
+    /// MONKEY (darkness gains): the live dim on the EXTERIOR day/night law (`nightGain`, 0.2..1.5,
+    /// default **0.8** = nights 20 % darker). Folded into the packed ambient/diffuse/specular rows
+    /// by `mix(1, gain, night_w)`, `night_w = 1 - sun_shadow_strength(celestial_dir.y)` — so it is
+    /// EXACTLY inert while the sun is up and full strength after dark.
+    ///
+    /// It rides THIS resource despite being an exterior knob because the bridge is the same one
+    /// (a live video cvar → a resource the light packer folds at pack time), and a second resource
+    /// plus a second plugin to carry one `f32` buys nothing. `enabled` does NOT gate it: the night
+    /// law lights terrain and models whether or not the interior lane is on.
+    pub night_gain: f32,
+    /// MONKEY (darkness gains): the live dim on the whole INTERIOR room lane (`interiorGain`,
+    /// 0.2..1.5, default **0.7** = interiors 30 % darker). Scales the lane's three INPUTS — the
+    /// packed [`Self::ambient`], [`Self::fill`], and every interior fixture's committed colour —
+    /// and deliberately not [`Self::exposure`], which is the user's own live dial; a gain on the
+    /// inputs composes with whatever exposure they have settled on.
+    pub interior_gain: f32,
+    /// MONKEY (enclosed day floor): the DAYLIGHT a room in a building gets through the doorways
+    /// this renderer cannot locate (`interiorDaylight`, 0..1, default **0** — the director wants daylight ONLY at doorways/windows, i.e. from the daylight fixtures; the room-wide floor stays available as a dial).
+    ///
+    /// It is an ADDITIVE ambient in exactly [`Self::ambient`]'s units — the room law's pre-exposure
+    /// illumination — scaled by the sun's own day envelope and tinted by the sky's ambient band, so
+    /// it is 0 all night and full at midday. Three seeds now find a building's authored openings
+    /// (`lighting::daylight`), but the shipped corpus also contains rooms whose doorway is in NO
+    /// table: the Goldshire inn's entry group `g3` has no portal, no EXT-class batch, no vertex
+    /// stitched to the shell that owns its threshold planks, and no localized spot in its own MOCV
+    /// bake. For those there is nothing to stand a fixture in, and the honest fallback is to say
+    /// what IS known — the room is inside a building, the sun is up, so it is not pitch dark.
+    ///
+    /// Rides the free FRACTION of the packed `wmo_fog_params.w` lane (see
+    /// [`DAYLIGHT_LANE_SCALE`]); `0` restores the pre-feature look exactly.
+    pub daylight: f32,
+    /// MONKEY (bake floor): the share of a WMO interior batch's OWN MOCV bake that every
+    /// interior-lane fragment keeps, whether or not a fixture reaches it (`interiorBakeFloor`,
+    /// 0..1, default **0.12**).
+    ///
+    /// The lane's premise — "the live fixtures decide, the bake's LEVEL is wrong" — has one hole
+    /// in it: a room the fixture table cannot reach renders at the bare [`Self::ambient`] floor,
+    /// i.e. black. The Lion's Pride Inn's east vestibule (group `g0`, box x 14.1..20.5) is the case
+    /// that forced it — MOLR 0, ZERO fixture claims (nearest L2 ≈ 16 yd against R 11.2, L3 ≈ 17.6
+    /// against R 14.7), one faded portal hop, so the whole budget collapses to `0.0075` and the
+    /// door band renders 0.019 × tex between a sky-lit porch and a candle-lit hall. The reference
+    /// client has no such hole: it draws every interior batch at its authored MOCV regardless of
+    /// fixtures, so a fixture-starved room is DIM there, never black.
+    ///
+    /// So the honest floor is the bake ITSELF, at a fraction: `vc.rgb × this`, added to the room's
+    /// pre-exposure budget INSIDE the `1 − exp(−x·exposure)` rolloff, so it saturates with the
+    /// fixtures instead of stacking on top of them (a candle-lit surface barely moves — measured
+    /// +7 % at the inn's `g3` floor under `L9`, +9 % at a `g5` wall 3 yd from `L0`) while an unlit
+    /// one goes from black to the bake's own relative statement about the room. A FRACTION, not the
+    /// bake, precisely because the LEVEL is what this lane rejects: an UNCAPPED bake share on this
+    /// same band measured 15-18 × its neighbour and read as a flat grey slab (see the
+    /// `static_gx.wgsl` portal-bleed comment); 0.12 restores about an eighth of it.
+    ///
+    /// Scaled by [`Self::interior_gain`] at PACK time (so the Dim preset dims it with everything
+    /// else and the shader carries no second knob), and NOT by `fireLightGain`, NOT flickered — it
+    /// is not a fire, it is the room's own authored light. `0` restores the pre-feature look
+    /// exactly. Rides the free FRACTION of the packed `sh_c16.w` lane — see [`BAKE_LANE_SCALE`].
+    pub bake_floor: f32,
+}
+
+impl Default for DynamicInteriors {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            ambient: 0.015,
+            fill: 0.08,
+            exposure: 2.5,
+            // MONKEY (soft falloff): 1.6, matching the `interiorAttenScale` cvar default (2.5 read oversaturated — the soft core `0.26·R` widens with it too).
+            atten_scale: 1.6,
+            // MONKEY (room gate): on by default — without it a building's fixtures light through
+            // its own floors and walls.
+            room_gate: true,
+            debug: 0,
+            // MONKEY (flame flicker): on at the authored amplitudes.
+            flicker: 1.0,
+            // MONKEY (darkness gains): the director's call — nights 20 % darker, interiors 30 %.
+            night_gain: 0.45,
+            interior_gain: 0.5,
+            // MONKEY (enclosed day floor): calibrated, not chosen — see [`DAYLIGHT_LANE_SCALE`]
+            // for the arithmetic that lands the Goldshire inn's entry floor at ~half the sunlit
+            // threshold beside it instead of at the near-black `interiorAmbient`.
+            daylight: 0.0,
+            // MONKEY (bake floor): an eighth of the authored bake — see the field doc for the
+            // measurement this is calibrated against (the inn's `g0` door band, and the
+            // candle-lit surfaces it must NOT move).
+            bake_floor: 0.12,
+        }
+    }
+}
+
+/// MONKEY (room gate): one packed fixture's room claim — the CPU form of the eight u32
+/// `static_gx.wgsl` reads (`[instance, count, g0..g5]`). `count == 0` is the UNGATED head every
+/// fail-open arm packs: an exterior-lane light, a fixture that names no room, and every light
+/// while `interiorRoomGate` is off. MONKEY (GO room claims): an OVERFLOWING list no longer fails
+/// open — it keeps its [`ROOM_CLAIM_MAX`] highest-priority claims (the spawner orders them
+/// tightest-containment → MOLR → nearest portal hop, so the dropped tail is the outermost shells /
+/// farthest rooms). Failing open here lit every room of the building through its walls, and a
+/// carried light inside nested MOGI shells can now reach the cap where a MOLT fixture never did.
+#[derive(Clone, Copy)]
+struct RoomClaim {
+    instance: u32,
+    n: u8,
+    groups: [u16; ROOM_CLAIM_MAX],
+    /// MONKEY (soft portal claims): index-parallel with `groups`. A default (`radius == 0`) is the
+    /// HARD claim every pre-fade path produces, so a fixture whose claims arrived without fades
+    /// gates exactly as it did before.
+    fades: [ClaimFade; ROOM_CLAIM_MAX],
+}
+
+impl Default for ClaimFade {
+    /// The HARD claim: no doorway, no fade, full weight. Spelled out rather than derived because
+    /// `entry` must default to **1**, not 0 — a derived zero would mean "this claim contributes
+    /// nothing", i.e. every fallback path would silently black out its rooms.
+    fn default() -> Self {
+        Self {
+            center: Vec3::ZERO,
+            slack: 0.0,
+            radius: 0.0,
+            entry: 1.0,
+        }
+    }
+}
+
+impl RoomClaim {
+    const UNGATED: Self = Self {
+        instance: 0,
+        n: 0,
+        groups: [0; ROOM_CLAIM_MAX],
+        fades: [ClaimFade {
+            center: Vec3::ZERO,
+            slack: 0.0,
+            radius: 0.0,
+            entry: 1.0,
+        }; ROOM_CLAIM_MAX],
+    };
+
+    /// The fixture's claim list. MONKEY (portal claims): when the spawner built one
+    /// ([`LightLitRooms`]) it IS the answer — it already folds the MOLR rooms in, in priority order,
+    /// with each claim's exterior-lane eligibility resolved. Only a light that carries no such list
+    /// (a carried torch, a transport prop) falls back to its raw MOLR rooms. MONKEY (review fixes):
+    /// each list carries its own placement, independently of whether MOLR names the fixture.
+    fn build(rooms: Option<&LightRooms>, lit: Option<&LightLitRooms>) -> Self {
+        // MONKEY (soft portal claims): the fades ride the SAME arm the groups came from — the
+        // MOLR fallback has none, and reading them off `lit` while the groups came off `rooms`
+        // would fade one room by another room's doorway.
+        let lit = lit.filter(|l| !l.rooms.groups.is_empty());
+        let fades: &[ClaimFade] = lit.map_or(&[], |l| &l.fades[..]);
+        let Some(claims) = lit.map(|l| &l.rooms).or_else(|| rooms.map(|r| &r.0)) else {
+            return Self::UNGATED; // nothing claims this light: it lights everything, as before
+        };
+        let instance = claims.instance.index().index();
+        // The identity travels to the shader through an f32 lane (`static_gx::render`'s cell
+        // uniform), which is exact only below 2^24 — and index 0 is the "terrain cell / no
+        // building" sentinel there. Outside that range the receiving side packs no key at all, so
+        // this side must not gate either, or the building would go black.
+        if instance == 0 || instance >= (1 << 24) {
+            return Self::UNGATED;
+        }
+        let mut out = Self {
+            instance,
+            ..Self::UNGATED
+        };
+        for (i, &g) in claims.groups.iter().enumerate() {
+            if out.groups[..usize::from(out.n)].contains(&g) {
+                continue;
+            }
+            if usize::from(out.n) == ROOM_CLAIM_MAX {
+                break; // overflow keeps the six highest-priority claims (see the struct doc)
+            }
+            out.groups[usize::from(out.n)] = g;
+            // A missing fade is a HARD claim, not a dropped one: the fallback paths (a carried
+            // light's raw MOLR rooms) legitimately have none, and the pre-fade behaviour is
+            // exactly "weight 1 wherever the group matches".
+            out.fades[usize::from(out.n)] = fades.get(i).copied().unwrap_or_default();
+            out.n += 1;
+        }
+        out
+    }
+
+    /// Write the eight-u32 GPU form. Groups are stored `+ 1` so the shader can keep 0 for "empty"
+    /// (and for "this fragment names no room") — group 0 is a real, common group id.
+    ///
+    /// MONKEY (portal claims): [`LIT_ROOM_EXT_DENY`] (bit 15 of the CPU id) is re-encoded as
+    /// [`CLAIM_EXT_OK`] (bit 16 of the GPU word), positively: the exterior batch lane takes a claim
+    /// only with that bit set, so every legacy/fallback path that never learned about the flag
+    /// (a carried light's raw MOLR rooms) reads as "not eligible" rather than as a leak.
+    fn write(&self, dst: &mut [u32]) {
+        dst[0] = self.instance;
+        dst[1] = u32::from(self.n);
+        for (i, slot) in dst[2..2 + ROOM_CLAIM_MAX].iter_mut().enumerate() {
+            // Past the count the shader never looks, but a `+1` on a padding zero would read as a
+            // claim on group 0 to anything that ever did — so the padding stays literally empty.
+            *slot = match self.groups.get(i).filter(|_| i < usize::from(self.n)) {
+                Some(g) => {
+                    // MONKEY (soft portal claims): the entry weight rides the spare high bits.
+                    let entry = self.fades[i].entry.clamp(0.0, 1.0);
+                    u32::from(*g & !LIT_ROOM_EXT_DENY) + 1
+                        | if *g & LIT_ROOM_EXT_DENY == 0 {
+                            CLAIM_EXT_OK
+                        } else {
+                            0
+                        }
+                        | ((entry * 255.0).round() as u32) << CLAIM_ENTRY_SHIFT
+                }
+                None => 0,
+            };
+        }
+        // MONKEY (soft portal claims): the fade records. Centre as raw f32 bits (the shader
+        // `bitcast`s them straight back — a world coordinate reaches +-17000 yd, which no fixed
+        // point or f16 lane could carry); radius and slack as `u16` yards x `CLAIM_FADE_SCALE` in
+        // one word. A padded slot writes zeros, and `radius == 0` IS the hard claim, so the padding
+        // can never be read as a fade even by a reader that ignores the count.
+        let q = |v: f32| ((v.max(0.0) * CLAIM_FADE_SCALE).round() as u32).min(0xffff);
+        for i in 0..ROOM_CLAIM_MAX {
+            let f = &mut dst[ROOM_CLAIM_FADE + 4 * i..][..4];
+            let Some(fade) = self.fades.get(i).filter(|_| i < usize::from(self.n)) else {
+                f.fill(0);
+                continue;
+            };
+            f[0] = fade.center.x.to_bits();
+            f[1] = fade.center.y.to_bits();
+            f[2] = fade.center.z.to_bits();
+            f[3] = q(fade.radius) | (q(fade.slack) << 16);
+        }
+    }
+}
+
+impl std::fmt::Display for RoomClaim {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.n == 0 {
+            return write!(f, "UNGATED");
+        }
+        write!(f, "inst {} g", self.instance)?;
+        for (i, g) in self.groups[..usize::from(self.n)].iter().enumerate() {
+            write!(f, "{}{g}", if i == 0 { "" } else { "," })?;
+        }
+        Ok(())
+    }
+}
+
 #[allow(clippy::type_complexity)]
 fn build_light_data(
     light: Res<WowLighting>,
     debug: Res<DebugState>,
     view: Res<ViewDistance>,
     cam: Query<&GlobalTransform, With<WorldCamera>>,
-    lights_q: Query<(&WorldPointLight, &GlobalTransform, Option<&LightRooms>)>,
+    // `Without<ShadowProxyLight>`: the torch-shadow proxies are `WorldPointLight`s too, but they
+    // exist only to cast a cube map — never to light benilla's receivers (see [`ShadowProxyLight`]).
+    // MONKEY (fire GO lights): `Has<SyntheticFireLight>` rides along so the live `fireLightGain`
+    // can scale exactly the invented sources at PACK time — no respawn, no per-spawn bake.
+    // MONKEY (interior attenuation): `Option<&LightReach>` too — a MOLT fixture's authored
+    // attenuation end, `None` on every M2 source (which is bucketed below instead).
+    // MONKEY (light lane by position): `Option<&LightLane>` decides the interior/exterior split —
+    // `LightRooms` stays in the tuple, but only for the portal ROOM gate below (and as the
+    // fail-safe lane for the frame or two before the classifier has answered).
+    lights_q: Query<
+        (
+            &WorldPointLight,
+            &GlobalTransform,
+            Option<&LightRooms>,
+            Has<SyntheticFireLight>,
+            Option<&LightReach>,
+            Option<&LightLane>,
+            // MONKEY (room gate): the bbox-derived supplement to the MOLR claim set.
+            Option<&LightLitRooms>,
+            // MONKEY (flame flicker): present iff this light BURNS ([`flame_kind_for`] decided so
+            // at spawn). Read-only, never written — the wobble is a pure function of it plus the
+            // clock, so it adds no `Changed` traffic and no archetype churn to the frame.
+            Option<&FlameFlicker>,
+            // MONKEY (darkness gains): the daylight-fixture marker — an interior-lane entry that
+            // is the SUN standing in a doorway, not a candle, so `interiorGain` must skip it.
+            Has<super::DaylightFixture>,
+            // MONKEY (spellLightGain): the spell-effect marker ([`SpellFxLight`]). Last in the
+            // tuple so every positional destructuring below keeps its index — and read for one
+            // thing only: WHICH live gain owns this row.
+            Has<SpellFxLight>,
+        ),
+        Without<ShadowProxyLight>,
+    >,
     // The per-frame portal PVS, for the room term below ([`LightRooms`]).
     portals: Query<&crate::wmo_portal::WmoPortalInstance>,
     mut data: ResMut<WowLightData>,
+    // MONKEY (room gate): packed in the same walk as the point table, so the two can never
+    // disagree about which entry is which.
+    mut claims: ResMut<RoomClaimTable>,
     time: Res<Time>,
+    // MONKEY (world shadows): the `worldShadows` lane flag, packed into `sh_c16.w` for the MCSH gate.
+    world_shadow: Res<WorldShadowActive>,
+    // MONKEY (distance slider): the realtime-shadow render distance, packed for the edge fade.
+    shadow_distance: Res<ShadowDistance>,
+    // MONKEY (dynamic interiors): the interior lane's on/off + live knobs, packed for `static_gx.wgsl`.
+    dynamic_interiors: Res<DynamicInteriors>,
+    // MONKEY (fire GO lights): the live gain on synthesised fire lights (0 = the lane off).
+    fire_gain: Res<FireLightGain>,
+    // MONKEY (spellLightGain): and the spell lane's own, which overrides it on a spell row.
+    spell_gain: Res<SpellLightGain>,
     mut last_dump: Local<f64>,
     mut last_rows_dump: Local<f64>,
 ) {
     let l = &*light;
     let fog_enable = if debug.lighting.disable_fog { 0.0 } else { 1.0 };
     let farclip = view.farclip;
+    // MONKEY (darkness gains): `nightGain` — one live dim over everything the EXTERIOR law lights
+    // (terrain, models, WMO exteriors, and the ext-class night blend, all of which derive from the
+    // ambient/diffuse/specular rows below). Folded CPU-side into those packed rows rather than
+    // added as a shader uniform because `LightStd430` has no free lane left (8528 B, mirrored by
+    // three WGSL structs) — and a pack-time fold costs the GPU exactly nothing anyway.
+    //
+    // The ramp is the DUSK CLOCK every other night feature already fades on: `sun_w` is
+    // `sun_shadow_strength(celestial_dir.y)` — 1 in daylight, smoothstepping to 0 as the celestial
+    // sun reaches the horizon — so `night_w = 1 - sun_w` is 0 all day and 1 after dark. Written as
+    // `1 + (g - 1)·night_w` (== `mix(1, g, night_w)`) so daylight multiplies by an EXACT 1.0 and
+    // every daytime frame stays bit-identical to before the feature: a gain that perturbed the day
+    // in the last ulp would move the `WOW_LIGHT_DUMP` row hash, which is the instrument three
+    // rounds of shading forensics are denominated in.
+    //
+    // POINT lights are deliberately NOT scaled by it. Dimming the sky law alone is the whole point:
+    // a campfire should read BRIGHTER against a darker night, not equally dim.
+    let sun_w = sun_shadow_strength(l.celestial_dir.y);
+    let night_k = 1.0 + (dynamic_interiors.night_gain - 1.0) * (1.0 - sun_w);
+    let night_dim = |c: [f32; 3]| c.map(|v| v * night_k);
     // Per-kind water swatches (shallow/deep rgb + alpha). River/lake use the non-ocean path.
     let (rs, rd, rsa, rda) = l.water_colors(LiquidKind::Still);
     let (os, od, osa, oda) = l.water_colors(LiquidKind::Ocean);
@@ -316,7 +1221,13 @@ fn build_light_data(
     let mut fresh = data.0;
     fresh.rows = [[0.0; 4]; LIGHT_HEADER_ROWS];
     let rows = &mut fresh.rows;
-    rows[3] = [l.spec[0], l.spec[1], l.spec[2], 20.0]; // 3 light_spec (w=terrain shininess 20)
+    // MONKEY (darkness gains): the specular row takes the night dim because it IS the sun — the
+    // DBC sun-halo colour driving the terrain sheen. The FOG rows below do not (fog colour is the
+    // horizon backdrop the world is seen AGAINST, and dimming it would paint a dark world under a
+    // bright skyline), and neither does the sky dome (`resolve::apply_sky_backdrop`, which never
+    // reads this blob) or the water swatches.
+    let spec = night_dim(l.spec);
+    rows[3] = [spec[0], spec[1], spec[2], 20.0]; // 3 light_spec (w=terrain shininess 20)
     rows[4] = [l.fog_color[0], l.fog_color[1], l.fog_color[2], fog_enable]; // 4 fog_color (w=enable)
     rows[5] = [l.fog_start, l.fog_end, 0.0, farclip]; // 5 fog_params (z unused; w=farclip)
     rows[13] = [rs[0], rs[1], rs[2], rsa]; // 13 water river shallow (w=alpha)
@@ -339,7 +1250,49 @@ fn build_light_data(
     rows[19] = [l.wmo_fog_start, l.wmo_fog_end, 0.0, 0.0];
     // Rows 0-2, the SH block 6-12.xyz, and the sun DC (17.yzw) — the shared model-light core
     // (also the portrait booth's packer). Row 20 (point_count) is the point-table pack's below.
-    pack_model_core_rows(rows, l.ambient, l.diffuse, l.sun_dir);
+    // MONKEY (darkness gains): the night dim goes in HERE, on the (ambient, diffuse) triple the
+    // whole model core is derived from, rather than onto the packed rows afterwards — every row
+    // this packs (rows 0/1, the SH block, the sun's DC redistribution) is LINEAR in that triple, so
+    // one multiply at the input dims all of them consistently and no derived row can be missed.
+    pack_model_core_rows(rows, night_dim(l.ambient), night_dim(l.diffuse), l.sun_dir);
+    // MONKEY (world shadows): pack the world-shadow lane flag into the free `sh_c16.w` lane. The
+    // MCSH terrain-shadow suppression in `terrain.wgsl` keys on THIS — not on the mere presence of
+    // a shadow sun — so character-only shadows (sun present, world lane off) keep the baked MCSH.
+    // MONKEY (bake floor): ...and `interiorBakeFloor` rides the free FRACTION of that same lane,
+    // with `interiorGain` already folded in (the shader must not carry a second knob, and the room
+    // lane's other two inputs — the base ambient and the per-fixture fill — take the gain at pack
+    // time in exactly this way, three rows down). See [`BAKE_LANE_SCALE`] for why a fraction is
+    // invisible to the one `> 0.5` decode this lane has, and why the product is clamped first.
+    rows[12][3] = pack_bake_lane(
+        world_shadow.0,
+        dynamic_interiors.bake_floor,
+        dynamic_interiors.interior_gain,
+    );
+    // MONKEY (night fade): realtime-shadow strength by the REAL celestial sun height, packed into
+    // the free `fog_params.z` lane. The receivers (terrain/model) lighten their shadow term by it,
+    // so shadows soften and vanish at night; the shadow basis is separately clamped to 18° so a low
+    // sun still casts the right DIRECTION.
+    // MONKEY (darkness gains): computed once above — `nightGain` rides this exact same curve, so
+    // the dim and the shadow fade can never drift onto two different dusk clocks.
+    rows[5][2] = sun_w;
+    // MONKEY (distance slider): the realtime-shadow render distance (yd), packed into the free
+    // `_wmo_fog[1].z` / `wmo_fog_params.z` lane (row 19). The receivers' edge fade reads it so the
+    // shadow fades at the cascade's actual `maximum_distance`, whatever the slider is set to.
+    rows[19][2] = shadow_distance.0;
+    // MONKEY (dynamic interiors): the lane's on/off into the free `wmo_fog_params.w` lane (1 = WMO
+    // interior surfaces + props light from the room's live fixtures, 0 = the faithful baked path).
+    // Its three knobs ride `point_count.yzw`, packed with the table below.
+    // On/off in the integer part, the debug mode added on top: 0 = off, 1 = on, 1+n = on + debug n.
+    // MONKEY (enclosed day floor): …and `interiorDaylight` rides the same lane's FRACTION (see
+    // [`DAYLIGHT_LANE_SCALE`] for why there was nowhere else to put it and why every existing
+    // decode survives it). Zero when the lane is off, so the packed word is byte-identical to
+    // before the feature in that arm.
+    rows[19][3] = if dynamic_interiors.enabled {
+        1.0 + dynamic_interiors.debug as f32
+            + dynamic_interiors.daylight.clamp(0.0, 1.0) * DAYLIGHT_LANE_SCALE
+    } else {
+        0.0
+    };
     // The dynamic point-light table (decision 0278): every spawned point light within
     // [`POINT_PACK_RADIUS`] of the camera, nearest-first when over capacity — the VERTEX stages of
     // `terrain.wgsl`/`wow_model.wgsl` walk it for the Gouraud point term (bevy's clusterable buffer
@@ -350,35 +1303,166 @@ fn build_light_data(
     // identity, over-gamut preserved). Entries past `count` stay stale in the blob — the count row
     // guards every reader.
     let cam_pos = cam.single().map(|t| t.translation()).unwrap_or(Vec3::ZERO);
-    let mut pts: Vec<(f32, Vec3, f32, [f32; 3])> = lights_q
+    // MONKEY (flame flicker): the one clock read for the whole table — every flame's phase is a
+    // function of this absolute second and its own seed, so the frame is internally consistent and
+    // the result does not depend on how long the frame took.
+    let now_secs = time.elapsed_secs();
+    // MONKEY (fire GO lights): `(…, synthetic)` rides the tuple so the census below can count the
+    // invented entries without a second query.
+    // MONKEY (light lanes): the tuple's last member is the packed COLOUR-ROW `.w` — 0 for an
+    // exterior light, the interior reach in yards for a fixture that claims a room (see the layout
+    // doc). It is resolved here, in the one place that already knows both the rooms and the
+    // recovered intensity, so neither shader has to reconstruct either.
+    // MONKEY (GO room claims): the trailing `usize` is the RAW `LightLitRooms` claim count —
+    // what the spawner (or the app's carried-light claimer) built, before the lane/`room_gate`
+    // filter below decides whether it is packed at all. Printed by `WOW_POINTS_DUMP` so an
+    // EXTERIOR-lane entry that HAS claims is visible as such: the shader reads claims only on
+    // the interior lane, so `claims 4` beside `EXT` is the readout of exactly that trade.
+    let mut pts: Vec<(f32, Vec3, f32, [f32; 3], bool, f32, RoomClaim, usize)> = lights_q
         .iter()
-        .filter(|(_, _, rooms)| {
+        .filter(|(_, gt, rooms, _, _, _, _, _, _, _)| {
             // The ROOM term (decision 0689's law, fourth lane — see [`LightRooms`]). Not a
             // visibility test bolted onto a faithful gather: the reference's register walk has no
             // such term either, it simply never has a culled room's torch to register. Ungated for
             // every light that names no rooms, which is every light outside a building.
+            //
+            // MONKEY (dynamic interiors): a fixture NEAR the camera is admitted regardless of the
+            // flood. The PVS follows the camera, so a room's torches dropped out of the table with
+            // camera angle — outside its door, or from the next room — and a fixture-LIT interior
+            // went dark where the bake never could (the dump flipped 18↔9 packed walking the inn).
+            // The wall leak this allows is the reference's own: a drawn room's torches register.
             crate::wmo_portal::room_admits(
                 rooms.map(|r| &r.0),
                 rooms.and_then(|r| portals.get(r.0.instance).ok()),
-            )
+            ) || (dynamic_interiors.enabled
+                && gt.translation().distance_squared(cam_pos)
+                    < INTERIOR_NEAR_ADMIT * INTERIOR_NEAR_ADMIT)
         })
-        .filter_map(|(pl, gt, _)| {
+        .filter_map(|(pl, gt, rooms, synthetic, reach, lane_of, lit_rooms, flicker, daylight, spell)| {
             let p = gt.translation();
             let d2 = p.distance_squared(cam_pos);
             (d2 < POINT_PACK_RADIUS * POINT_PACK_RADIUS).then(|| {
+                // MONKEY (merge): `WorldPointLight::color` is already linear RGB.
                 let c = pl.color;
-                let s = pl.intensity / (4.0 * std::f32::consts::PI);
-                let rgb = commit_raw([c[0] * s, c[1] * s, c[2] * s]);
-                (d2, p, pl.range, rgb)
+                // The authored intensity, BEFORE the fire gain: the pool's geometry must not move
+                // when the user dims the invented lights, only its brightness.
+                let base = pl.intensity / (4.0 * std::f32::consts::PI);
+                // MONKEY (fire GO lights): the live `fireLightGain` folds in HERE, over the
+                // recovered colour×intensity, and only for a synthesised source. At spawn it
+                // would need a world respawn to retune; here the dial moves the frame it changes.
+                // MONKEY (spellLightGain): …and the spell lane's own gain INSTEAD of it on a
+                // spell row. Every spell light is also tagged synthetic (it is an invented source
+                // and the census counts it as one), so the arms must be ordered, not summed: a
+                // fireball scaled by both dials would darken when the player turned the hearths
+                // down, which is precisely the coupling the second cvar exists to cut.
+                let s = base
+                    * if spell {
+                        spell_gain.0.max(0.0)
+                    } else if synthetic {
+                        fire_gain.0.max(0.0)
+                    } else {
+                        1.0
+                    };
+                // MONKEY (flame flicker): the fire wobble, folded in at the very last moment — over
+                // the committed colour and NOWHERE else. Deliberately downstream of `base`, which
+                // still feeds the reach/lane below unmodulated: a breathing REACH would move the
+                // interior window, re-decide the room gate's portal hop and re-rank the torch
+                // shadow casters every frame, i.e. exactly the frame-rate thrash this feature
+                // exists to avoid. Only the brightness moves; the pool's geometry is frozen.
+                //
+                // `elapsed_secs` (absolute, never a delta) is what makes it frame-rate independent:
+                // the same instant gives the same brightness whatever the frame took.
+                let fm = flicker.map_or(FlickerMod::STEADY, |f| {
+                    f.at(now_secs, dynamic_interiors.flicker)
+                });
+                let s = s * fm.intensity;
+                let rgb = commit_raw([c[0] * s, c[1] * s, c[2] * s * fm.blue]);
+                // MONKEY (light lane by position): a light is INTERIOR iff it PHYSICALLY STANDS in
+                // an interior-class WMO group — the verdict [`classify_light_lanes`] (static) or
+                // the carried-light claim (entities) wrote onto it. Claiming a room is no longer
+                // the test: Stormwind's street torches claim exterior-class groups and must light
+                // the cobbles, while the Goldshire inn's fixtures claim an exterior-flagged group
+                // from inside the building and must NOT light the lawn (see [`LightLane`]).
+                //
+                // No lane yet ⇒ fall back to the OLD `LightRooms` rule rather than to "exterior".
+                // A light lives one or two frames before the classifier's first pass (it spawns in
+                // the stream stage, the classifier runs the frame after), and the conservative
+                // arm of that gap is the pre-change behaviour: a MOLT fixture starts interior and
+                // is corrected outward, never the reverse — so the gap can never flash a pool onto
+                // an inn's lawn.
+                let interior = lane_of.map_or_else(|| rooms.is_some(), |l| l.interior);
+                // MONKEY (darkness gains): `interiorGain` dims the room lane's third input — every
+                // INTERIOR fixture's committed colour — downstream of the fire gain and the
+                // flicker, so those two keep their own meanings ("how bright is this invented
+                // source" / "how hard does it breathe") and this one reads purely as "how dark is
+                // the room". The EXTERIOR half of the table is untouched on purpose: an outdoor
+                // campfire belongs to the night law, which dims the sky around it and not it.
+                //
+                // And so is the DAYLIGHT FIXTURE ([`super::DaylightFixture`]) — an interior-lane
+                // entry that IS the sun standing in a doorway. A sunlit opening must not dim with
+                // the room's candles: this dial means "how dark is the CANDLELIGHT". Nor does
+                // `nightGain` claim it instead — that one dims the night, and a daylight fixture is
+                // already scaled to nothing by its own day envelope (`daylight_target`'s `sun_w`,
+                // the same curve) by the time the night dim is at full strength.
+                let rgb = if interior && !daylight {
+                    rgb.map(|c| c * dynamic_interiors.interior_gain)
+                } else {
+                    rgb
+                };
+                // A fixture's reach is its authored MOLT end where there is one and the M2 bucket
+                // otherwise, with a fail-open default for a MOLT record whose end is absent or
+                // degenerate (a few author 0 with `useAtten` clear).
+                let lane = if interior {
+                    let r = reach
+                        .map(|r| r.0)
+                        .filter(|r| *r > 0.5)
+                        .unwrap_or_else(|| m2_light_reach(base));
+                    interior_reach(r, dynamic_interiors.atten_scale)
+                } else {
+                    0.0
+                };
+                // MONKEY (room gate): the fixture's claim set, resolved HERE because this is the
+                // one place that already knows both the rooms and the interior verdict. An
+                // EXTERIOR-lane light is never read by the gate, so it packs the ungated head.
+                let claim = if interior && dynamic_interiors.room_gate {
+                    RoomClaim::build(rooms, lit_rooms)
+                } else {
+                    RoomClaim::UNGATED
+                };
+                let lit_n = lit_rooms.map_or(0, |l| l.rooms.groups.len());
+                (d2, p, pl.range, rgb, synthetic, lane, claim, lit_n)
             })
         })
         .collect();
     pts.sort_by(|a, b| a.0.total_cmp(&b.0));
-    pts.truncate(MAX_POINT_LIGHTS);
-    fresh.rows[20] = [pts.len() as f32, 0.0, 0.0, 0.0];
-    for (i, (_, p, range, rgb)) in pts.iter().enumerate() {
+    // MONKEY (ext light k8): 255, not 256 — index 255 is the shaders' `EXT_SEL_EMPTY` sentinel now
+    // that a draw unit's selection packs eight 8-bit ranks. See [`MAX_LIVE_POINT_LIGHTS`]. The sort
+    // above is nearest-camera-first, so the entry this drops is the farthest of the set.
+    pts.truncate(MAX_LIVE_POINT_LIGHTS);
+    // `.x` = the live entry count; MONKEY (dynamic interiors): `.yzw` = the interior lane's live
+    // knobs (base ambient, per-fixture fill gain, exposure) — free lanes until now.
+    // MONKEY (darkness gains): `interiorGain` scales two of the room lane's three inputs here (the
+    // base ambient floor and the per-fixture fill gain; the fixtures' own colours took it above)
+    // and pointedly leaves EXPOSURE alone — that one is the user's live dial (their config sits at
+    // 4), and folding a dim into it would have the two knobs fight over the same number. A gain on
+    // the INPUTS composes with whatever exposure is set to. The strict exterior-batch `ext_room`
+    // term and the ext-class night blend read these same packed lanes, so they follow for free.
+    fresh.rows[20] = [
+        pts.len() as f32,
+        dynamic_interiors.ambient * dynamic_interiors.interior_gain,
+        dynamic_interiors.fill * dynamic_interiors.interior_gain,
+        dynamic_interiors.exposure,
+    ];
+    for (i, (_, p, range, rgb, _, lane, claim, _)) in pts.iter().enumerate() {
         fresh.points[2 * i] = [p.x, p.y, p.z, *range];
-        fresh.points[2 * i + 1] = [rgb[0], rgb[1], rgb[2], 0.0];
+        fresh.points[2 * i + 1] = [rgb[0], rgb[1], rgb[2], *lane];
+        claim.write(&mut claims.0[i * ROOM_CLAIM_STRIDE..][..ROOM_CLAIM_STRIDE]);
+    }
+    // Entries past the count are stale in the point table by design (the count row guards every
+    // reader) — but the claim table is read at the SAME index, so a stale head there would gate a
+    // live light with a dead building's identity. Clear the tail instead of trusting the count.
+    for slot in claims.0[pts.len() * ROOM_CLAIM_STRIDE..].iter_mut() {
+        *slot = 0;
     }
     // `WOW_POINTS_DUMP=1`: print the committed point table once a second — the numeric probe for
     // "what is actually lighting this ground". A pool that reads wrong is one of a small set of
@@ -411,26 +1495,78 @@ fn build_light_data(
             let snap = |v: f32| (((half + v) / cell).floor() + 0.5) * cell - half;
             let anchor = Vec3::new(snap(cam_pos.x), cam_pos.y, snap(cam_pos.z));
             let (mut boxed, mut sphere) = (0usize, 0usize);
-            for (_, p, _, _) in &pts {
+            for (_, p, _, _, _, _, _, _) in &pts {
                 let dv = *p - anchor;
                 boxed += usize::from(dv.x.abs().max(dv.z.abs()) <= 33.570_166);
                 sphere += usize::from(dv.length() <= 48.0);
             }
+            // MONKEY (fire GO lights): how many of the packed entries we INVENTED. The whole
+            // feature is a heuristic over content, so "the inn is too bright" has to be separable
+            // into "too many synthetic sources" and "the authored ones changed" without a rebuild.
+            let synth = pts.iter().filter(|(.., s, _, _, _)| *s).count();
+            // MONKEY (flame flicker): how many of the nearby sources BURN — the census that answers
+            // "did the route rule file this room's fixtures as flames at all?" without a rebuild.
+            // Counted over the same radius the pack gathers from rather than off `pts`, so it does
+            // not have to ride the packing tuple through five destructurings for a diagnostic.
+            let flames = lights_q
+                .iter()
+                .filter(|(_, gt, ..)| {
+                    gt.translation().distance_squared(cam_pos)
+                        < POINT_PACK_RADIUS * POINT_PACK_RADIUS
+                })
+                .filter(|t| t.7.is_some())
+                .count();
+            // MONKEY (light lanes): how the table splits between the two now-disjoint consumer
+            // families. "The inn's candles are lighting the lawn" is an INT count on a row the
+            // exterior lane should never have seen — a number, printed per row below as INT/EXT.
+            let interior = pts.iter().filter(|(.., lane, _, _)| *lane > 0.5).count();
             eprintln!(
-                "[points] {} packed, cam {cam_pos:.1?} — this chunk's candidates: {boxed} (was {sphere} at the 48 yd sphere), 3 slots",
-                pts.len()
+                "[points] {} packed ({interior} INT / {} EXT, {synth} synthetic, {flames} flickering, gain {:.2}, atten x{:.2}, flicker x{:.2}, night x{:.2}, interior x{:.2}, spell x{:.2}), cam {cam_pos:.1?} — this chunk's candidates: {boxed} (was {sphere} at the 48 yd sphere), 3 slots",
+                pts.len(),
+                pts.len() - interior,
+                fire_gain.0,
+                dynamic_interiors.atten_scale,
+                dynamic_interiors.flicker,
+                // MONKEY (darkness gains): the two dim dials, beside the gains they compose with —
+                // "is this room dark because the gain is 0.2 or because no fixture claims it" is
+                // the question this line exists to answer without a rebuild.
+                dynamic_interiors.night_gain,
+                dynamic_interiors.interior_gain,
+                // MONKEY (spellLightGain): beside them for the same reason — "is that fireball
+                // dark because the dial is 0 or because its model synthesised no light at all" is
+                // one number away, and the two causes look identical on screen.
+                spell_gain.0,
             );
-            for (d2, p, _, rgb) in pts.iter().take(8) {
+            for (d2, p, _, rgb, synthetic, lane, claim, lit_n) in pts.iter().take(8) {
                 eprintln!(
-                    "  d {:6.2}  at [{:8.2},{:7.2},{:8.2}]  rgb [{:.3},{:.3},{:.3}]",
+                    "  d {:6.2}  at [{:8.2},{:7.2},{:8.2}]  rgb [{:.3},{:.3},{:.3}]  {}{}",
                     d2.sqrt(),
                     p.x,
                     p.y,
                     p.z,
                     rgb[0],
                     rgb[1],
-                    rgb[2]
+                    rgb[2],
+                    if *lane > 0.5 {
+                        format!("INT reach {lane:5.2}")
+                    } else {
+                        "EXT".to_string()
+                    },
+                    if *synthetic { "  SYNTH" } else { "" },
                 );
+                // MONKEY (GO room claims): how many rooms this entry CLAIMS, whether or not the
+                // lane lets the shader read them. A carried light (a brazier GameObject) now builds
+                // its claims from its own world position through the placed lanes' rule, so "why is
+                // the shop next door still dark" is `claims 1` vs `claims 3` here rather than a
+                // guess — and on an `EXT` row it says the claims exist but are not being read.
+                if *lit_n > 0 {
+                    eprintln!("      claims {lit_n}");
+                }
+                // MONKEY (room gate): which rooms this entry is allowed to light — the number
+                // behind "why is this room dark" / "why does that wall still glow".
+                if *lane > 0.5 {
+                    eprintln!("      rooms {claim}");
+                }
             }
         }
     }
@@ -452,8 +1588,7 @@ fn build_light_data(
         let now = time.elapsed_secs_f64();
         if now - *last_rows_dump >= every {
             *last_rows_dump = now;
-            let hash = data
-                .0
+            let hash = fresh
                 .rows
                 .iter()
                 .flatten()
@@ -481,6 +1616,102 @@ fn build_light_data(
     }
 }
 
+/// MONKEY (light lane by position): decide each STATIC point light's [`LightLane`] from where it
+/// physically stands, using the client's own light-attach down-ray
+/// ([`crate::wmo_portal::indoor_verdict_at`], `LightAttach::DownRay` — the predicate that
+/// classifies a standing NPC). See [`LightLane`] for WHY the lane cannot be read off `LightRooms`.
+///
+/// The verdict maps straight across:
+/// - [`IndoorVerdict::DayNight`] / [`IndoorVerdict::Baked`] — the nearest face under the light is
+///   an interior-class one (MOGP `& 0x48 == 0`). INTERIOR. This is what keeps the Goldshire inn's
+///   ten fixtures interior even though the group that NAMES them is exterior-flagged: the ray from
+///   each fixture lands on the inn's own room floor, one storey down at most, and the answer is a
+///   fact about that floor rather than about the MOLR list.
+/// - [`IndoorVerdict::OutdoorsOnWmo`] — a definite claim by an EXTERIOR-class face: a street, a
+///   courtyard, a porch, a deck. EXTERIOR. Stormwind's 235 street fixtures land here.
+/// - MONKEY (review fixes): [`IndoorVerdict::Outdoors`] with a terrain hit is resolved EXTERIOR,
+///   even if MOLR/MODR names the fixture — a courtyard torch must still light its ground. Only
+///   an empty ray (no WMO and no terrain) keeps the old `LightRooms` fallback: a streaming gap
+///   supplies no evidence that a previously interior fixture should move outdoors.
+///
+/// **Cost.** One ray per static light per [`WmoResidency`](crate::interior::WmoResidency)
+/// generation, and nothing at all once a neighbourhood is settled: a world-baked light never
+/// moves, so the verdict is stable, and the generation only ticks when a building streams in or
+/// out. `Without<ChildOf>` keeps the carried lights out — they are children of a bone joint and
+/// take their lane from their bearer's already-resolved room instead.
+#[allow(clippy::type_complexity)]
+pub fn classify_light_lanes(
+    mut commands: Commands,
+    residency: Res<crate::interior::WmoResidency>,
+    wmos: Res<Assets<benilla_assets::WmoModel>>,
+    instances: Query<&crate::wmo_portal::WmoPortalInstance>,
+    streamer: Res<crate::terrain_stream::TerrainStreamer>,
+    adt_tiles: Res<Assets<benilla_assets::AdtTile>>,
+    lights: Query<
+        (Entity, &GlobalTransform, Option<&LightRooms>, Option<&LightLane>),
+        (
+            With<WorldPointLight>,
+            Without<ShadowProxyLight>,
+            Without<ChildOf>,
+        ),
+    >,
+) {
+    let generation = residency.generation();
+    // Collected once per frame that has work; the ray walk borrows it per light. An empty world
+    // (no placement yet) still short-circuits below on the `settled` check for every light.
+    let mut instance_list: Option<Vec<&crate::wmo_portal::WmoPortalInstance>> = None;
+    for (light, gt, rooms, lane) in &lights {
+        if lane.is_some_and(|l| l.generation == generation || l.generation == LightLane::SETTLED) {
+            continue; // settled — no ray, no archetype write
+        }
+        let instances = instance_list.get_or_insert_with(|| instances.iter().collect());
+        let (verdict, _) = crate::wmo_portal::indoor_verdict_at(
+            &wmos,
+            instances.iter().map(|i| ((), *i)),
+            &streamer,
+            &adt_tiles,
+            gt.translation(),
+            crate::wmo_portal::LightAttach::DownRay,
+        );
+        // MONKEY (review fixes): `Outdoors` alone conflates terrain winning the ray with no
+        // resident surface at all. Reuse its terrain probe only on that ambiguous arm; the
+        // winning WMO verdicts already carry all the information the lane needs. Terrain above
+        // the anchor is not a DOWN-ray hit (the same buried-terrain rule as down_ray_claim).
+        let probe = gt.translation() + Vec3::Y * crate::wmo_portal::POSITION_PROBE_LIFT;
+        let terrain_hit = matches!(verdict, crate::wmo_portal::IndoorVerdict::Outdoors)
+            && crate::terrain_stream::terrain_height_under(
+                &streamer,
+                &adt_tiles,
+                probe,
+            ).is_some_and(|height| height <= probe.y);
+        let interior = light_verdict_interior(&verdict, terrain_hit, rooms.is_some());
+        let want = LightLane {
+            interior,
+            generation,
+        };
+        // Always re-stamped when the generation moved, even if the verdict didn't — the stamp is
+        // what stops the next frame re-raying the same light.
+        if lane != Some(&want) {
+            commands.entity(light).insert(want);
+        }
+    }
+}
+
+// MONKEY (review fixes): room references are a fallback for an unresolved ray, never a veto on
+// resolved outdoor geometry. Keep this decision explicit so both outdoor arms stay covered.
+fn light_verdict_interior(
+    verdict: &crate::wmo_portal::IndoorVerdict,
+    terrain_hit: bool,
+    has_rooms: bool,
+) -> bool {
+    use crate::wmo_portal::IndoorVerdict;
+    match verdict {
+        IndoorVerdict::DayNight | IndoorVerdict::Baked { .. } => true,
+        IndoorVerdict::OutdoorsOnWmo => false,
+        IndoorVerdict::Outdoors => !terrain_hit && has_rooms,
+    }
+}
+
 /// Render-world: write the packed light into the shared buffer in place, before any draw reads it
 /// (`RenderSystems::PrepareResources`). One small upload per frame, independent of material count.
 fn upload_light(
@@ -498,6 +1729,22 @@ fn upload_light(
 mod tests {
     use super::*;
 
+    // MONKEY (review fixes): a reference cannot override resolved terrain or an outdoor WMO
+    // face. An empty ray still preserves the old rule until residency supplies real evidence.
+    #[test]
+    fn light_lanes_distinguish_resolved_outdoors_from_an_empty_ray() {
+        use crate::wmo_portal::IndoorVerdict;
+        for has_rooms in [false, true] {
+            assert!(!light_verdict_interior(&IndoorVerdict::Outdoors, true, has_rooms));
+            assert!(!light_verdict_interior(&IndoorVerdict::OutdoorsOnWmo, false, has_rooms));
+            assert!(light_verdict_interior(&IndoorVerdict::DayNight, true, has_rooms));
+            assert!(light_verdict_interior(
+                &IndoorVerdict::Baked { mocv: [0; 3], lobes: Vec::new() }, false, has_rooms,
+            ));
+            assert_eq!(light_verdict_interior(&IndoorVerdict::Outdoors, false, has_rooms), has_rooms);
+        }
+    }
+
     /// GOLDEN — the **live exterior M2 response** (0803): `wow_model.wgsl`'s doodad/entity lane must
     /// reproduce `E = A + I·D·(4/17)(0.375 + 2μ + 1.875μ²)` off the rows [`pack_model_core_rows`]
     /// writes, with `A` NOT scaling by the per-instance intensity and every sun band scaling by it
@@ -595,15 +1842,7 @@ mod tests {
     /// reference and the ground pool read white instead of flame-orange.
     #[test]
     fn the_torch_commits_the_raw_authored_product() {
-        let mut app = App::new();
-        app.init_resource::<WowLighting>()
-            .init_resource::<crate::dev_state::DebugState>()
-            .init_resource::<crate::view::ViewDistance>()
-            .init_resource::<WowLightData>()
-            .init_resource::<Time>()
-            .add_systems(Update, build_light_data);
-        app.world_mut()
-            .spawn((crate::view::WorldCamera, GlobalTransform::IDENTITY));
+        let mut app = packer_app();
         // The real authored torch light, through the real spawn recipe.
         app.world_mut().spawn((
             crate::terrain_stream::point_light([0.466_666_7, 0.290_196_1, 0.133_333_34], 3.0),
@@ -630,6 +1869,522 @@ mod tests {
         assert!((rgb[2] - 0.4).abs() < 1e-4, "blue commits raw: {rgb:?}");
     }
 
+    /// A minimal app around the real [`build_light_data`]: every resource the system takes, plus a
+    /// world camera at the origin. Was inline in the torch golden and short three resources — the
+    /// system had grown `WorldShadowActive`/`ShadowDistance`/`DynamicInteriors` params since, and
+    /// the test had been failing param validation rather than asserting anything. One builder now,
+    /// so a fourth param can't silently red the same way twice.
+    fn packer_app() -> App {
+        let mut app = App::new();
+        app.init_resource::<WowLighting>()
+            .init_resource::<crate::dev_state::DebugState>()
+            .init_resource::<crate::view::ViewDistance>()
+            .init_resource::<WowLightData>()
+            // MONKEY (room gate): the packer writes the claim table in the same walk.
+            .init_resource::<RoomClaimTable>()
+            .init_resource::<Time>()
+            .init_resource::<WorldShadowActive>()
+            .init_resource::<ShadowDistance>()
+            .init_resource::<DynamicInteriors>()
+            .init_resource::<FireLightGain>()
+            .init_resource::<SpellLightGain>()
+            .add_systems(Update, build_light_data);
+        app.world_mut()
+            .spawn((crate::view::WorldCamera, GlobalTransform::IDENTITY));
+        app
+    }
+
+    /// MONKEY (room gate): the claim a fixture is packed with is the SPAWNER'S OWN claim list when
+    /// it built one, and it fails OPEN on every ambiguous arm.
+    ///
+    /// That the set is wider than MOLR is a data fact rather than a preference: the shipped
+    /// Goldshire inn authors a MOLR on 2 of its 12 groups (nine of its ten fixtures claimed by the
+    /// exterior-flagged whole-building shell) and NSabbey leaves seven of its rooms unnamed, so a
+    /// MOLR-only claim set would black most of both buildings out.
+    ///
+    /// MONKEY (portal claims): the list REPLACES the MOLR union rather than being merged with it —
+    /// `benilla_formats::room_claims` already folds MOLR in, in priority order, and re-adding it
+    /// here would re-admit the district-scale shells that rule deliberately marks
+    /// exterior-lane-ineligible. Only a light with no list (a carried torch) falls back to MOLR.
+    #[test]
+    fn the_room_claim_takes_the_spawners_list_and_falls_back_to_molr() {
+        let mut world = World::new();
+        // Entity index 0 is the "terrain cell / no building" sentinel in the shader's identity
+        // lane, so the packer fails OPEN on it — burn it, then take a real index.
+        let zeroth = world.spawn_empty().id();
+        assert_eq!(zeroth.index().index(), 0, "the first index really is the sentinel");
+        let inst = world.spawn_empty().id();
+        let rooms = LightRooms(crate::wmo_portal::WmoGroupVis {
+            instance: inst,
+            groups: std::sync::Arc::from([4u16]),
+        });
+        // The spawner's list: the room it stands in (g5), the MOLR group it re-found (g4), and one
+        // more its box holds (g7) — its own order, which the packer must not reshuffle.
+        let lit = LightLitRooms {
+            rooms: crate::wmo_portal::WmoGroupVis {
+            instance: inst,
+                groups: std::sync::Arc::from([5u16, 4, 7]),
+            },
+            // MONKEY (soft portal claims): no fades — every claim is HARD, which is the packer's
+            // pre-fade behaviour and what every fallback path still produces.
+            fades: std::sync::Arc::from([]),
+        };
+
+        let claim = RoomClaim::build(Some(&rooms), Some(&lit));
+        assert_eq!(claim.instance, inst.index().index(), "keyed to the placement");
+        assert_eq!(claim.n, 3, "the spawner's list, verbatim: {claim}");
+        assert_eq!(&claim.groups[..3], &[5, 4, 7], "in the spawner's priority order");
+
+        let mut gpu = [0u32; ROOM_CLAIM_STRIDE];
+        claim.write(&mut gpu);
+        assert_eq!(gpu[1], 3, "the count the shader loops to");
+        assert_eq!(ROOM_CLAIM_FADE, 2 + ROOM_CLAIM_MAX, "the fades start after the id block");
+        // `group + 1`, so the shader can keep 0 for "empty" / "this fragment names no room" —
+        // group 0 is a real, common group id and could not be its own sentinel. MONKEY (portal
+        // claims): plus the positive exterior-lane bit, since none of these carries the deny flag.
+        assert_eq!(
+            &gpu[2..5],
+            &[
+                6 | CLAIM_EXT_OK | (255 << CLAIM_ENTRY_SHIFT),
+                5 | CLAIM_EXT_OK | (255 << CLAIM_ENTRY_SHIFT),
+                8 | CLAIM_EXT_OK | (255 << CLAIM_ENTRY_SHIFT),
+            ],
+            "claims stored + 1, exterior-lane eligible, at full entry weight"
+        );
+        assert_eq!(&gpu[5..ROOM_CLAIM_FADE], &[0, 0, 0], "padding stays empty, not a claim on g0");
+        // MONKEY (soft portal claims): no fades supplied ⇒ every record is zero, and `radius == 0`
+        // is the HARD claim the shader reads as weight 1 everywhere.
+        assert!(gpu[ROOM_CLAIM_FADE..].iter().all(|w| *w == 0), "hard claims write no fade");
+
+        // MONKEY (review fixes): containment claims must pack identically with NO MOLR. This
+        // used to discard the whole list and let one fixture light every room in the building.
+        let mut no_molr_gpu = [0u32; ROOM_CLAIM_STRIDE];
+        RoomClaim::build(None, Some(&lit)).write(&mut no_molr_gpu);
+        assert_eq!(no_molr_gpu, gpu);
+
+        // MONKEY (portal claims): a district-scale shell still gates the fixture (it is in the
+        // count, so the fixture is NOT ungated) but reaches the exterior lane with no eligibility
+        // bit — the one thing that keeps a tavern candle off the street outside.
+        let shell = LightLitRooms {
+            rooms: crate::wmo_portal::WmoGroupVis {
+            instance: inst,
+                groups: std::sync::Arc::from([5u16, 9 | LIT_ROOM_EXT_DENY]),
+            },
+            fades: std::sync::Arc::from([]),
+        };
+        let mut gpu = [0u32; ROOM_CLAIM_STRIDE];
+        RoomClaim::build(Some(&rooms), Some(&shell)).write(&mut gpu);
+        assert_eq!(gpu[1], 2);
+        assert_eq!(
+            &gpu[2..4],
+            &[
+                6 | CLAIM_EXT_OK | (255 << CLAIM_ENTRY_SHIFT),
+                10 | (255 << CLAIM_ENTRY_SHIFT),
+            ],
+            "the shell claims, but not outdoors"
+        );
+
+        // No list at all (a carried torch): the MOLR rooms, as before.
+        assert_eq!(
+            RoomClaim::build(Some(&rooms), None).groups[0],
+            4,
+            "the fallback is the authored relation"
+        );
+
+        // The sentinel index fails OPEN rather than gating against a key no region can carry.
+        assert_eq!(
+            RoomClaim::build(
+                Some(&LightRooms(crate::wmo_portal::WmoGroupVis {
+                    instance: zeroth,
+                    groups: std::sync::Arc::from([4u16]),
+                })),
+                None,
+            )
+            .n,
+            0,
+            "an instance the identity lane cannot express packs UNGATED"
+        );
+
+        // A light nothing claims lights everything, exactly as before the gate existed.
+        assert_eq!(RoomClaim::build(None, None).n, 0, "unclaimed = ungated");
+
+        // MONKEY (GO room claims): an overflow keeps the six highest-priority claims, in order —
+        // never ungated (that lit the whole building through its walls).
+        let many: Vec<u16> = (0..ROOM_CLAIM_MAX as u16 + 1).collect();
+        let big = LightLitRooms {
+            rooms: crate::wmo_portal::WmoGroupVis {
+            instance: inst,
+                groups: std::sync::Arc::from(&many[..]),
+            },
+            fades: std::sync::Arc::from([]),
+        };
+        let packed = RoomClaim::build(Some(&rooms), Some(&big));
+        assert_eq!(usize::from(packed.n), ROOM_CLAIM_MAX, "overflow truncates to the cap");
+        assert_eq!(&packed.groups[..], &many[..ROOM_CLAIM_MAX], "keeps the head, drops the tail");
+    }
+
+    /// GOLDEN — MONKEY (soft portal claims): the fade half of the GPU record, by byte offset.
+    ///
+    /// The layout is the one contract the CPU and `static_gx.wgsl` cannot negotiate at runtime: a
+    /// stride or offset that disagrees reads every fixture's claims out of a neighbour's record,
+    /// which blanks or floods every building at once. So it is asserted as literal indices here,
+    /// beside the constants the shader mirrors.
+    #[test]
+    fn the_fade_record_packs_at_a_fixed_offset_per_claim() {
+        let mut world = World::new();
+        world.spawn_empty(); // burn the 0 sentinel
+        let inst = world.spawn_empty().id();
+        // Claim 0 HARD (the room the fixture stands in), claim 1 SOFT (one doorway away).
+        let lit = LightLitRooms {
+            rooms: crate::wmo_portal::WmoGroupVis {
+                instance: inst,
+                groups: std::sync::Arc::from([5u16, 6]),
+            },
+            fades: std::sync::Arc::from([
+                ClaimFade::default(),
+                ClaimFade {
+                    center: Vec3::new(-1234.5, 60.25, 7000.0),
+                    slack: 1.5,
+                    radius: 6.25,
+                    entry: 0.4,
+                },
+            ]),
+        };
+        let mut gpu = [0u32; ROOM_CLAIM_STRIDE];
+        RoomClaim::build(None, Some(&lit)).write(&mut gpu);
+        assert_eq!(gpu[1], 2);
+        // Slot 0: hard ⇒ all four words zero, so `radius == 0` and the shader weights it 1.
+        assert_eq!(&gpu[ROOM_CLAIM_FADE..ROOM_CLAIM_FADE + 4], &[0, 0, 0, 0]);
+        // Slot 1: centre as raw f32 bits (world coordinates reach +-17000 yd — nothing narrower
+        // carries them), radius and slack as u16 yards x 256 in one word, radius in the low half.
+        let f = ROOM_CLAIM_FADE + 4;
+        assert_eq!(f32::from_bits(gpu[f]), -1234.5);
+        assert_eq!(f32::from_bits(gpu[f + 1]), 60.25);
+        assert_eq!(f32::from_bits(gpu[f + 2]), 7000.0);
+        assert_eq!(gpu[f + 3] & 0xffff, (6.25 * CLAIM_FADE_SCALE) as u32, "radius, low half");
+        assert_eq!(gpu[f + 3] >> 16, (1.5 * CLAIM_FADE_SCALE) as u32, "slack, high half");
+        // The entry weight rides the ID word's spare bits, not the fade record.
+        assert_eq!((gpu[3] >> CLAIM_ENTRY_SHIFT) & 0xff, 102, "0.4 x 255, on the soft claim");
+        assert_eq!((gpu[2] >> CLAIM_ENTRY_SHIFT) & 0xff, 255, "full, on the hard one");
+        // Every slot past the count is literally empty — a stale fade would follow a live light.
+        assert!(gpu[ROOM_CLAIM_FADE + 8..].iter().all(|w| *w == 0));
+        assert_eq!(gpu.len(), ROOM_CLAIM_STRIDE, "2 head + 6 ids + 6 x 4 fade");
+    }
+
+    /// GOLDEN — MONKEY (fire GO lights): `fireLightGain` scales SYNTHESISED sources and **only**
+    /// them, at pack time.
+    ///
+    /// Pack time is the whole design: the dial has to be live (`/script SetCVar("fireLightGain",
+    /// 0)` must darken the invented lights on the next frame, with no world respawn), and it has
+    /// to be a kill switch for a heuristic that — unlike every mechanism around it — is derived
+    /// from content rather than byte-verified. Both properties are exactly this assertion: the
+    /// tagged light moves with the gain, the authored one beside it does not.
+    #[test]
+    fn the_fire_gain_scales_only_synthesised_lights() {
+        let mut app = packer_app();
+        // Same colour and intensity for both, so the only thing that can separate them is the tag.
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.5, 0.25], 2.0);
+        app.world_mut()
+            .spawn((recipe(), GlobalTransform::from_translation(Vec3::X)));
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            SyntheticFireLight,
+        ));
+        app.world_mut().insert_resource(FireLightGain(0.5));
+        app.update();
+
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.rows[20][0], 2.0, "both packed");
+        // Nearest-first: the authored one at x=1 is entry 0, the synthetic at x=2 is entry 1.
+        let authored = data.points[1];
+        let synthetic = data.points[3];
+        assert!(
+            (authored[0] - 2.0).abs() < 1e-4,
+            "the authored light is untouched by the fire gain: {authored:?}"
+        );
+        assert!(
+            (synthetic[0] - 1.0).abs() < 1e-4,
+            "the synthesised light takes the gain: {synthetic:?}"
+        );
+
+        // Zero is the kill switch: the invented light commits black, the authored one is unmoved.
+        app.world_mut().insert_resource(FireLightGain(0.0));
+        app.update();
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.points[3], [0.0, 0.0, 0.0, 0.0], "gain 0 = lane off");
+        assert!((data.points[1][0] - 2.0).abs() < 1e-4, "authored unaffected");
+    }
+
+    /// GOLDEN — MONKEY (spellLightGain): a SPELL light takes `spellLightGain` **instead of**
+    /// `fireLightGain`, not as well as it.
+    ///
+    /// Every spell light is tagged [`SyntheticFireLight`] too — it IS an invented source, and the
+    /// census must keep counting it as one — so the two arms overlap on every row this dial exists
+    /// for. If they composed, turning the world's hearths down would darken every fireball in the
+    /// game, and `spellLightGain 0` would still leave combat flashes on wherever a player had
+    /// raised `fireLightGain`. Both halves are asserted: the spell row moves with ONE dial and is
+    /// deaf to the other, and the plain synthetic row beside it is unmoved by the new one.
+    #[test]
+    fn the_spell_gain_overrides_the_fire_gain_on_a_spell_light() {
+        let mut app = packer_app();
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.5, 0.25], 2.0);
+        // A campfire's invented light…
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::X),
+            SyntheticFireLight,
+        ));
+        // …and a fireball's, which carries BOTH tags exactly as the spawn site stamps them.
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            SyntheticFireLight,
+            SpellFxLight,
+        ));
+        app.world_mut().insert_resource(FireLightGain(0.5));
+        app.world_mut().insert_resource(SpellLightGain(2.0));
+        app.update();
+
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.rows[20][0], 2.0, "both packed");
+        let fire = data.points[1];
+        let spell = data.points[3];
+        assert!(
+            (fire[0] - 1.0).abs() < 1e-4,
+            "the campfire takes the fire gain alone: {fire:?}"
+        );
+        assert!(
+            (spell[0] - 4.0).abs() < 1e-4,
+            "the spell light takes 2x, NOT 2x0.5: {spell:?}"
+        );
+
+        // Zero is this lane's own kill switch, and it reaches nothing else.
+        app.world_mut().insert_resource(SpellLightGain(0.0));
+        app.update();
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.points[3], [0.0, 0.0, 0.0, 0.0], "spell gain 0 = spell lights off");
+        assert!(
+            (data.points[1][0] - 1.0).abs() < 1e-4,
+            "the campfire still burns at its own gain"
+        );
+    }
+
+    /// GOLDEN — MONKEY (flame flicker): the wobble reaches the packed COLOUR and nothing else.
+    ///
+    /// Three properties, and each one is a bug if it inverts. (1) A flame's committed colour MOVES
+    /// with the clock while an identical light without the component beside it does not — the
+    /// feature exists at all. (2) The move stays inside the kind's authored amplitude, which is the
+    /// anti-strobe guarantee measured where it actually lands (after the `4π` round trip and
+    /// `commit_raw`), not just in the waveform's own unit test. (3) The colour row's `.w` — the
+    /// interior REACH — is byte-identical across those frames. That is the one thing that must not
+    /// breathe: a moving reach would re-window the interior pool, re-decide the room gate's portal
+    /// hop and re-rank the torch-shadow casters every single frame, which is the frame-rate thrash
+    /// ("the epileptic imp") this feature is built to stay clear of.
+    #[test]
+    fn the_flicker_moves_the_packed_colour_and_never_the_reach() {
+        use super::super::flicker::FlameKind;
+        let at = |app: &mut App, ms: u64| {
+            let mut t = Time::<()>::default();
+            t.advance_by(std::time::Duration::from_millis(ms));
+            app.world_mut().insert_resource(t);
+            app.update();
+            app.world().resource::<WowLightData>().0
+        };
+        let mut app = packer_app();
+        // Same recipe, same lane, same intensity: only the component can separate them.
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.5, 0.25], 1.5);
+        let lane = LightLane { interior: true, generation: LightLane::SETTLED };
+        app.world_mut()
+            .spawn((recipe(), GlobalTransform::from_translation(Vec3::X), lane));
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            lane,
+            FlameFlicker::new(FlameKind::Torch, 0x51ee_d105),
+        ));
+
+        let (mut moved, mut steady_moved) = (0.0f32, 0.0f32);
+        let first = at(&mut app, 0);
+        let (base_steady, base_flame, reach) = (first.points[1][0], first.points[3][0], first.points[3][3]);
+        assert!(reach > 0.5, "the flame is on the interior lane, so `.w` carries its reach");
+        for ms in (40..4000).step_by(37) {
+            let d = at(&mut app, ms);
+            steady_moved = steady_moved.max((d.points[1][0] - base_steady).abs());
+            moved = moved.max((d.points[3][0] - base_flame).abs() / base_flame.max(1e-6));
+            assert_eq!(d.points[3][3], reach, "the packed reach never moves with the flicker");
+            assert_eq!(d.points[2], first.points[2], "nor does the position/range row");
+        }
+        assert_eq!(steady_moved, 0.0, "a light with no FlameFlicker is a constant, as before");
+        assert!(moved > 0.02, "the flame barely moved at all: {moved}");
+        // Both endpoints of the excursion are inside the torch rung's authored +-10%, doubled by
+        // the two-sided base sample (the reference frame is t=0, itself off the mean).
+        assert!(moved < 2.0 * FlameKind::Torch.amplitude(), "over amplitude: {moved}");
+
+        // `fireFlicker 0` is the off switch: the flame commits the same bytes on every frame.
+        app.world_mut().insert_resource(DynamicInteriors {
+            flicker: 0.0,
+            ..DynamicInteriors::default()
+        });
+        let off = at(&mut app, 5000).points[3];
+        for ms in [5100u64, 5250, 5600] {
+            assert_eq!(at(&mut app, ms).points[3], off, "gain 0 = the pre-feature constant");
+        }
+    }
+
+    /// GOLDEN — MONKEY (light lanes / interior attenuation): the colour row's `.w` separates the
+    /// two consumer families AND carries the interior reach, and `[pos.xyz, range]` is untouched.
+    ///
+    /// Three properties, one assertion each, because each is a bug that shipped or nearly did:
+    /// a light that claims NO room packs lane `0` (so the exterior shaders keep reading it and the
+    /// outdoor-fire lane is unchanged); a light that DOES packs its reach (so an inn's candles stop
+    /// pooling on the lawn — the exterior loops skip `> 0.5`); and the reach is always ≥ 1 yd, so
+    /// the "0 means exterior" test can never be confused by a degenerate authored end.
+    ///
+    /// MONKEY (light lane by position): none of these lights carries a [`LightLane`], so what this
+    /// pins is the packer's **fail-safe fallback** — the pre-classifier rule, which is what a
+    /// freshly spawned light is packed on for its first frame. The lane override itself is pinned
+    /// by [`the_position_lane_overrides_the_room_claim`].
+    ///
+    /// `pos_range.w` is asserted at 48 on BOTH: the exterior lanes rank and cut on it, so packing
+    /// the (much smaller) authored reach there instead — the obvious first design — would have
+    /// silently shrunk every outdoor fire's candidacy radius by 5-7x.
+    #[test]
+    fn the_lane_flag_splits_interior_from_exterior_and_carries_the_reach() {
+        let mut app = packer_app();
+        // Same recipe both times: only the room claim can separate them.
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.8, 0.5], 1.0);
+        app.world_mut()
+            .spawn((recipe(), GlobalTransform::from_translation(Vec3::X)));
+        let instance = app.world_mut().spawn(()).id();
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            LightRooms::new(crate::wmo_portal::WmoGroupVis::single(instance, 4)),
+            LightReach(6.972), // the Goldshire inn's own authored MOLT end
+        ));
+        app.update();
+
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.rows[20][0], 2.0, "both packed");
+        // Nearest-first: the roomless light at x=1 is entry 0, the fixture at x=2 is entry 1.
+        assert_eq!(data.points[1][3], 0.0, "no rooms ⇒ the EXTERIOR lane");
+        // MONKEY (soft falloff): the packed value is the EFFECTIVE RADIUS — the authored end times
+        // the default `interiorAttenScale` (1.6), which is where the pool's soft profile now ends.
+        assert!(
+            (data.points[3][3] - 6.972 * 1.6).abs() < 1e-3,
+            "a fixture packs its authored reach × the default scale: {:?}",
+            data.points[3],
+        );
+        // The candidacy radius the exterior shaders rank on is untouched on both entries.
+        assert_eq!(data.points[0][3], 48.0);
+        assert_eq!(data.points[2][3], 48.0);
+
+        // `interiorAttenScale` is live and folds in at pack time; 0 restores the legacy reach so
+        // the window can be A/B'd from chat without a rebuild.
+        for (scale, want) in [(2.0f32, 13.944f32), (0.0, INTERIOR_LEGACY_REACH)] {
+            let mut di = *app.world().resource::<DynamicInteriors>();
+            di.atten_scale = scale;
+            app.world_mut().insert_resource(di);
+            app.update();
+            let data = app.world().resource::<WowLightData>().0;
+            assert!(
+                (data.points[3][3] - want).abs() < 1e-3,
+                "scale {scale}: got {} want {want}",
+                data.points[3][3],
+            );
+            assert_eq!(data.points[1][3], 0.0, "scale {scale}: exterior stays 0");
+        }
+
+        // A degenerate authored end must never land near the 0.5 lane threshold — it would read as
+        // an EXTERIOR light and start lighting the hillside the fixture is inside.
+        let e = app
+            .world_mut()
+            .spawn((
+                recipe(),
+                GlobalTransform::from_translation(Vec3::new(3.0, 0.0, 0.0)),
+                LightRooms::new(crate::wmo_portal::WmoGroupVis::single(instance, 4)),
+                LightReach(0.001),
+            ))
+            .id();
+        let mut di = *app.world().resource::<DynamicInteriors>();
+        di.atten_scale = 1.0;
+        app.world_mut().insert_resource(di);
+        app.update();
+        let data = app.world().resource::<WowLightData>().0;
+        assert!(
+            data.points[5][3] >= 1.0,
+            "a degenerate reach still packs as INTERIOR: {:?}",
+            data.points[5],
+        );
+        app.world_mut().despawn(e);
+    }
+
+    /// GOLDEN — MONKEY (light lane by position): a [`LightLane`] OVERRIDES the room claim, in both
+    /// directions. This is the whole of bug B's first cause and its regression guard in one test.
+    ///
+    /// - A fixture that CLAIMS a room but stands outdoors packs lane `0` — Stormwind's 235
+    ///   street-only MOLT fixtures, which the old `Has<LightRooms>` rule filed interior and which
+    ///   therefore lit nothing at all (no exterior consumer would read them, and the interior
+    ///   consumer never runs on a street).
+    /// - A light that claims NO room but stands indoors packs a reach — a GM-placed brazier in the
+    ///   Lion's Pride Inn, and the M2 bucket (12 yd at intensity 1) × the default scale.
+    ///
+    /// The room claim itself is untouched by either: it still gates the portal PVS and the
+    /// torch-shadow promotion, which is why the two facts have to be separate components.
+    #[test]
+    fn the_position_lane_overrides_the_room_claim() {
+        let mut app = packer_app();
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.8, 0.5], 1.0);
+        let instance = app.world_mut().spawn(()).id();
+        // A street torch: named by an exterior-class group, so it has rooms — and stands outdoors.
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::X),
+            LightRooms::new(crate::wmo_portal::WmoGroupVis::single(instance, 4)),
+            LightReach(9.889),
+            LightLane {
+                interior: false,
+                generation: 0,
+            },
+        ));
+        // A brazier carried into a room: no MOLT/MODR claim at all, but physically inside one.
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            LightLane::carried(true),
+        ));
+        app.update();
+
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.rows[20][0], 2.0, "both packed");
+        assert_eq!(
+            data.points[1][3], 0.0,
+            "a room-claiming fixture that stands OUTDOORS is exterior: {:?}",
+            data.points[1],
+        );
+        assert!(
+            (data.points[3][3] - 12.0 * 1.6).abs() < 1e-3,
+            "a roomless light that stands INDOORS is interior, at the M2 bucket × scale: {:?}",
+            data.points[3],
+        );
+    }
+
+    /// GOLDEN — MONKEY (interior attenuation): the M2 reach ladder lands each SYNTHESISED bucket on
+    /// its own rung. The four intensities are `fire_light::fire_intensity`'s exact outputs, so a
+    /// change to either ladder that desynchronises them fails here rather than in a dark tavern.
+    #[test]
+    fn the_m2_reach_ladder_matches_the_fire_intensity_buckets() {
+        assert_eq!(m2_light_reach(0.6), 6.0, "candle");
+        assert_eq!(m2_light_reach(1.5), 12.0, "torch / campfire");
+        assert_eq!(m2_light_reach(2.0), 16.0, "brazier");
+        assert_eq!(m2_light_reach(3.0), 24.0, "bonfire / forge");
+        // The authored corpus rides the same ladder: a lantern (1.0) reads as a torch, the held
+        // Club_1H_Torch (3.0, committed 1.4 red) as a bonfire.
+        assert_eq!(m2_light_reach(1.0), 12.0);
+        assert_eq!(m2_light_reach(16.0), 24.0, "the ladder has no upper hole");
+    }
+
     /// GOLDEN — the PACKER's SH block: evaluating the rows this packer writes (DC lane +
     /// grade.yzw × I + I × (linear + quad + x²−y²)) must reproduce the disassembled `Model2.bls`
     /// closed form `clamp01(ambient + D·I·(3 + 16μ + 15μ²)/34)` at every intensity rung (2.5 lit /
@@ -709,4 +2464,242 @@ mod tests {
             );
         }
     }
+
+    /// MONKEY (ext light k8): the LIVE cap is one short of the SLOT cap, and the blob did not grow.
+    ///
+    /// The two numbers are easy to confuse and the failure mode of confusing them is invisible: a
+    /// light seated at index 255 packs identically to `EXT_SEL_EMPTY` in all three shaders, so the
+    /// draw units that selected it would read "end of list" and quietly drop every rank after it —
+    /// a dark patch with nothing in any log. The second assertion is the other half of the deal
+    /// that bought those bits: widening the selection had to cost the buffer NOTHING, because
+    /// `LightStd430` is mirrored by three shaders plus the portrait booth's frozen studio blob.
+    #[test]
+    fn the_live_point_cap_leaves_the_sentinel_index_free() {
+        assert_eq!(MAX_LIVE_POINT_LIGHTS, 255, "255 is EXT_SEL_EMPTY in the three shaders");
+        assert_eq!(MAX_LIVE_POINT_LIGHTS, MAX_POINT_LIGHTS - 1);
+        // 21 header rows + 2 x 256 point rows, 16 B each.
+        assert_eq!(per_frame_blob_bytes(), 8528, "the mirrored blob must not change size");
+    }
+
+    /// MONKEY (enclosed day floor): `interiorDaylight` rides the FRACTION of the interior lane's
+    /// on/off word, and every existing decode of that word must be blind to it.
+    ///
+    /// This is the test the feature stands on: there was no free `f32` left in an 8528-byte layout
+    /// three shaders mirror, so the value shares a lane with two other facts. If the fraction ever
+    /// grew past 0.5 — a wider `DAYLIGHT_LANE_SCALE`, a `daylight` that escaped its clamp — the
+    /// debug decode `u32(max(w - 1, 0) + 0.5)` would round UP and every building in the frame would
+    /// silently switch to a diagnostic overlay. Asserting the two decodes, not just the value, is
+    /// what makes that impossible to introduce quietly.
+    #[test]
+    fn the_daylight_lane_rides_the_fraction_without_disturbing_its_neighbours() {
+        // The shader's own two decodes of `wmo_fog_params.w`, transcribed.
+        let interiors_on = |w: f32| w > 0.5;
+        let idbg = |w: f32| (0.0f32.max(w - 1.0) + 0.5) as u32;
+        let daylight_of = |w: f32| (w - w.floor()) / DAYLIGHT_LANE_SCALE;
+        for debug in 0..=4u32 {
+            for daylight in [0.0f32, 0.01, 0.12, 0.5, 0.999, 1.0] {
+                let w = 1.0 + debug as f32 + daylight * DAYLIGHT_LANE_SCALE;
+                assert!(interiors_on(w), "lane off at debug {debug} daylight {daylight}");
+                assert_eq!(idbg(w), debug, "debug decode moved (w {w})");
+                assert!(
+                    (daylight_of(w) - daylight).abs() < 1e-4,
+                    "daylight {daylight} round-tripped as {} (w {w})",
+                    daylight_of(w),
+                );
+            }
+        }
+        // The OFF arm is untouched — byte-identical to before the feature, whatever the cvar says.
+        assert!(!interiors_on(0.0));
+        assert_eq!(daylight_of(0.0), 0.0);
+        // …and the packer really writes it. `1 + debug + d*scale`, clamped at both ends.
+        let pack = |enabled: bool, debug: u32, d: f32| {
+            if enabled {
+                1.0 + debug as f32 + d.clamp(0.0, 1.0) * DAYLIGHT_LANE_SCALE
+            } else {
+                0.0
+            }
+        };
+        assert_eq!(pack(false, 3, 0.5), 0.0);
+        assert_eq!(idbg(pack(true, 3, 5.0)), 3, "an out-of-range cvar must still clamp under 0.5");
+        assert!((daylight_of(pack(true, 3, 5.0)) - 1.0).abs() < 1e-4);
+        assert!((daylight_of(pack(true, 0, -1.0))).abs() < 1e-4);
+    }
+
+    /// MONKEY (bake floor): `interiorBakeFloor` rides the FRACTION of the world-shadow lane
+    /// (`sh_c16.w`), and that lane's one existing decode must be blind to it.
+    ///
+    /// Same shape as the daylight-lane test above and load-bearing for the same reason: the layout
+    /// has no free `f32`, so the value shares a row with a boolean. The failure this forbids is
+    /// quiet and remote — a fraction that reached 0.5 would make `terrain.wgsl` read
+    /// `sh_c16.w > 0.5` as TRUE with `worldShadows` OFF, i.e. every ADT in the world would drop its
+    /// baked MCSH shadows because someone moved an interior slider. Hence the clamp inside
+    /// [`pack_bake_lane`] (the product `bake_floor × interior_gain` reaches 1.5 at the knobs' own
+    /// limits, which × 0.49 is 0.735 — over the cliff) and hence asserting the DECODE, not the value.
+    #[test]
+    fn the_bake_floor_rides_the_fraction_without_disturbing_the_world_shadow_flag() {
+        // `terrain.wgsl`'s only decode of this lane, transcribed.
+        let world_shadow_lane = |w: f32| w > 0.5;
+        for &flag in &[false, true] {
+            for &bake in &[0.0f32, 0.01, 0.08, 0.12, 0.2, 0.5, 1.0] {
+                for &gain in &[0.2f32, 0.5, 1.0, 1.5] {
+                    let w = pack_bake_lane(flag, bake, gain);
+                    assert_eq!(
+                        world_shadow_lane(w),
+                        flag,
+                        "world-shadow decode moved (w {w}, bake {bake}, gain {gain})",
+                    );
+                    let want = (bake * gain).clamp(0.0, 1.0);
+                    assert!(
+                        (unpack_bake_lane(w) - want).abs() < 1e-4,
+                        "bake {bake} x gain {gain} round-tripped as {} (w {w})",
+                        unpack_bake_lane(w),
+                    );
+                }
+            }
+        }
+        // `0` restores the pre-feature look EXACTLY: the packed word is the bare flag, bit for bit.
+        assert_eq!(pack_bake_lane(false, 0.0, 0.5), 0.0);
+        assert_eq!(pack_bake_lane(true, 0.0, 0.5), 1.0);
+        // An out-of-range cvar still clamps under the cliff rather than flipping the flag.
+        assert!(!world_shadow_lane(pack_bake_lane(false, 9.0, 1.5)));
+        assert!((unpack_bake_lane(pack_bake_lane(false, 9.0, 1.5)) - 1.0).abs() < 1e-4);
+        // The gain really is the dimmer: the Dim preset's floor is under the Default's.
+        assert!(pack_bake_lane(false, 0.08, 0.5) < pack_bake_lane(false, 0.12, 0.5));
+    }
+
+    /// GOLDEN — MONKEY (darkness gains): `nightGain` is EXACTLY inert while the sun is up and
+    /// exactly the gain after dark, and it never touches a flame.
+    ///
+    /// The daylight half is the load-bearing one. The dial folds into rows the entire exterior look
+    /// is derived from (ambient, diffuse, the SH block, the sun halo), so a ramp that missed 1.0 by
+    /// an ulp at noon would perturb every daytime frame of a renderer whose fidelity work is
+    /// measured against bit-exact row hashes — the bug would be invisible on screen and expensive
+    /// in the log. `1 + (g - 1)·night_w` is written the way it is to make that endpoint exact.
+    ///
+    /// The point-table half is the FEATURE, not a detail: dimming the sky law while leaving the
+    /// fires alone is what makes a torch read brighter against a darker night. A gain that reached
+    /// the point entries would dim the flame by the same 20 % and net out to no change at all.
+    #[test]
+    fn the_night_gain_is_inert_by_day_and_exact_after_dark() {
+        let base = WowLighting {
+            ambient: [0.30, 0.32, 0.38],
+            diffuse: [0.85, 0.70, 0.45],
+            spec: [0.60, 0.55, 0.50],
+            sun_dir: Vec3::new(0.3, -0.8, 0.52).normalize(),
+            ..default()
+        };
+        // `sun_shadow_strength` saturates at `sin(12°)`: y = 1 is broad daylight, y = 0 the horizon.
+        let pack = |celestial_y: f32| {
+            let mut app = packer_app();
+            app.world_mut().insert_resource(WowLighting {
+                celestial_dir: Vec3::new(0.0, celestial_y, 0.0),
+                ..base
+            });
+            // An EXTERIOR fire, to prove the dial stops at the sky law.
+            app.world_mut().spawn((
+                crate::terrain_stream::point_light([1.0, 0.5, 0.25], 2.0),
+                GlobalTransform::from_translation(Vec3::X),
+            ));
+            app.update();
+            app.world().resource::<WowLightData>().0
+        };
+
+        let day = pack(1.0);
+        assert_eq!(day.rows[5][2], 1.0, "the sun is up: night_w is 0");
+        assert_eq!([day.rows[0][0], day.rows[0][1], day.rows[0][2]], base.ambient);
+        assert_eq!([day.rows[1][0], day.rows[1][1], day.rows[1][2]], base.diffuse);
+        assert_eq!([day.rows[3][0], day.rows[3][1], day.rows[3][2]], base.spec);
+        // The SH block is derived from the same triple — its DC lanes carry ambient verbatim.
+        assert_eq!(day.rows[6][3], base.ambient[0], "the SH DC is undimmed by day too");
+
+        let night = pack(0.0);
+        assert_eq!(night.rows[5][2], 0.0, "below the horizon: night_w is 1");
+        let g = DynamicInteriors::default().night_gain;
+        assert_eq!(g, 0.45, "the shipped default is the director's pick (2026-09-11: 0.45)");
+        for c in 0..3 {
+            assert_eq!(night.rows[0][c], base.ambient[c] * g, "ambient takes the gain");
+            assert_eq!(night.rows[1][c], base.diffuse[c] * g, "diffuse takes the gain");
+            assert_eq!(night.rows[3][c], base.spec[c] * g, "the sun halo follows its sun");
+        }
+        assert_eq!(night.rows[6][3], base.ambient[0] * g, "the SH DC follows the triple");
+        // The fire is the same brightness on both frames — which is the point of the feature.
+        assert_eq!(day.points[1], night.points[1], "a point light never takes the night dim");
+        assert!((night.points[1][0] - 2.0).abs() < 1e-4, "…at its authored value");
+    }
+
+    /// GOLDEN — MONKEY (darkness gains): `interiorGain` scales all THREE of the room lane's inputs
+    /// and nothing on the exterior lane.
+    ///
+    /// Three inputs make a room's brightness (`static_gx.wgsl`'s `interior_room_light`): the base
+    /// ambient floor, the per-fixture fill gain, and the fixtures' own colours. Scaling two of the
+    /// three would change the room's COLOUR BALANCE rather than dim it — a 30 % cut that left the
+    /// ambient floor standing reads as a washed-out room, not a darker one. `interiorExposure` is
+    /// pointedly NOT in the set: it is the dial the user tunes live, and this must compose with it.
+    ///
+    /// The exterior assertion is the seam that matters. The two lanes share one packed table, so a
+    /// gain applied before the lane verdict would dim every campfire and street torch in the world
+    /// with the candles.
+    #[test]
+    fn the_interior_gain_scales_the_room_lane_and_never_the_exterior_one() {
+        let mut app = packer_app();
+        // One recipe, one lane component apart: nothing else can separate the two entries.
+        let recipe = || crate::terrain_stream::point_light([1.0, 0.5, 0.25], 2.0);
+        let lane = |interior| LightLane { interior, generation: LightLane::SETTLED };
+        app.world_mut()
+            .spawn((recipe(), GlobalTransform::from_translation(Vec3::X), lane(true)));
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(2.0, 0.0, 0.0)),
+            lane(false),
+        ));
+        // MONKEY (darkness gains): a DAYLIGHT fixture — an interior-lane entry that is the sun in
+        // a doorway. It rides the room lane but belongs to the exterior law, so the candle dial
+        // must step over it; without the marker check it would dim a sunlit doorway by 30 %.
+        app.world_mut().spawn((
+            recipe(),
+            GlobalTransform::from_translation(Vec3::new(3.0, 0.0, 0.0)),
+            lane(true),
+            crate::lighting::DaylightFixture {
+                instance: Entity::PLACEHOLDER,
+                group: 0,
+                portal: None,
+                how: crate::lighting::DaylightHow::Portal,
+                reach: 8.0,
+                cal_d: 4.0,
+                cal_ndl: 0.5,
+            },
+        ));
+        let g = 0.7;
+        app.world_mut().insert_resource(DynamicInteriors {
+            ambient: 0.2,
+            fill: 0.5,
+            exposure: 3.0,
+            interior_gain: g,
+            ..default()
+        });
+        app.update();
+
+        let data = app.world().resource::<WowLightData>().0;
+        assert_eq!(data.rows[20][0], 3.0, "all three packed");
+        assert_eq!(data.rows[20][1], 0.2 * g, "the base ambient floor takes the gain");
+        assert_eq!(data.rows[20][2], 0.5 * g, "the per-fixture fill takes the gain");
+        assert_eq!(data.rows[20][3], 3.0, "exposure stays the user's own dial");
+        // Nearest-first: the interior fixture at x=1 is entry 0, the exterior one at x=2 entry 1.
+        let (int, ext) = (data.points[1], data.points[3]);
+        assert!(int[3] > 0.5 && ext[3] == 0.0, "the lanes packed as expected: {int:?} {ext:?}");
+        assert!(
+            (int[0] - 2.0 * g).abs() < 1e-4,
+            "the interior fixture's colour takes the gain: {int:?}"
+        );
+        assert!(
+            (ext[0] - 2.0).abs() < 1e-4,
+            "the exterior light is untouched by it: {ext:?}"
+        );
+        let sun = data.points[5];
+        assert!(sun[3] > 0.5, "the daylight fixture packed on the interior lane: {sun:?}");
+        assert!(
+            (sun[0] - 2.0).abs() < 1e-4,
+            "…and a sunlit doorway does not dim with the candles: {sun:?}"
+        );
+    }
 }
diff --git a/crates/benilla-world/src/lighting/mod.rs b/crates/benilla-world/src/lighting/mod.rs
index ec58fd22..75d39559 100644
--- a/crates/benilla-world/src/lighting/mod.rs
+++ b/crates/benilla-world/src/lighting/mod.rs
@@ -11,13 +11,44 @@ use benilla_assets::AssetSet;
 use benilla_formats::{LightCatalog, LiquidKind};
 
 mod blob; // the off-world light-blob builder (booth studio, body pane, glue scene)
+mod daylight; // MONKEY (daylight fixtures): the sun as an interior-lane light in a doorway
 mod daynight; // the two sun directions + day/night interp + the dawn/dusk warp curve
+mod flicker; // MONKEY (flame flicker): the per-light fire wobble folded in at pack time
 mod global_light; // the one shared global-light storage buffer (replaces the per-material push)
 mod prop_probes; // the per-instance interior-prop SH probe table (slot ↔ MeshTag payload)
 mod resolve; // the per-frame time-of-day sample into WowLighting + the WMO interior-fog crossfade
 mod sh; // the model SH light-probe coefficient math
 pub use blob::LightBlob;
-pub use global_light::{new_shared_light_buffer, LightRooms, SharedLightBuffer, WorldPointLight};
+// MONKEY (daylight fixtures): the marker (torch_shadow excludes it), the selection rule and the
+// spawn-side helpers the placement lane calls.
+// MONKEY (portal bleed): `placement_openings` is the ONE selection entry point the placement lane
+// calls now -- daylight seeds and interior<->interior doorway seeds share the per-placement budget,
+// so neither can be ranked without the other. `BleedFixture`/`BleedSeed` are the doorway lane's own
+// two types; the fixture itself still wears `DaylightFixture`.
+pub use daylight::{
+    daylight_claims, daylight_intensity, daylight_lane, daylight_point_light, daylight_reach,
+    daylight_rooms, daylight_seeds, daylight_target, bleed_seeds, placement_openings, BleedFixture,
+    BleedSeed,
+    DaylightFixture, DaylightHow, DaylightSeed, BLEED_K, MAX_DAYLIGHT_PER_PLACEMENT,
+};
+// MONKEY (flame flicker): the component + the one route rule, so every spawn lane files a flame
+// the same way and the packer has a single function to evaluate.
+pub use flicker::{flame_kind_for, flicker_seed, FlameFlicker, FlameKind, FlickerMod};
+pub use global_light::{
+    interior_reach, m2_light_reach, new_shared_light_buffer, DynamicInteriors, FireLightGain,
+    ClaimFade, LightLane, LightLitRooms, LightReach, LightRooms, RoomClaimTable,
+    SharedLightBuffer,
+    ShadowDistance, ShadowFilterGaussian, ShadowProxyLight, SyntheticFireLight,
+    WorldShadowActive,
+};
+// MONKEY (merge 2026-09-17): upstream's world-light component, adopted as THE world light.
+pub use global_light::WorldPointLight;
+// MONKEY (spellLightGain): the spell lane's marker + its live gain — the two-word world-side
+// shadow of benilla-app's own `SpellLight` lifecycle, and the dial the packer folds over it.
+pub use global_light::{SpellFxLight, SpellLightGain};
+pub use global_light::{
+    room_claim_bytes, CLAIM_EXT_OK, LIT_ROOM_EXT_DENY, ROOM_CLAIM_MAX, ROOM_CLAIM_STRIDE,
+};
 pub use prop_probes::{PropProbeSlot, PropProbes, MAX_PROP_PROBES};
 // The std430 layout itself — row indices, byte sizes, region offsets and the folds that fill them
 // — stays in the crate. Off-world producers state values through `LightBlob` and never a row index
@@ -166,6 +197,13 @@ pub struct WowLighting {
 }
 
 impl WowLighting {
+    /// The visible **celestial sun** direction (camera→sun, Bevy space) — the body that genuinely
+    /// rises and sets over the day. Exposed for the shadow rig, which aims its basis at this MOVING
+    /// sun (with an elevation clamp) rather than the near-fixed lighting `sun_dir`.
+    pub fn celestial_dir(&self) -> Vec3 {
+        self.celestial_dir
+    }
+
     /// Per-kind **water swatch endpoints**: `(shallow_rgb, deep_rgb, shallow_alpha, deep_alpha)`. These
     /// are the ENDPOINTS; the ramp between them is a 64-row byte-space accumulator that `liquid.wgsl`
     /// reproduces (`swatch_row`), not the plain lerp this doc used to describe — it stops one row short
@@ -363,6 +401,8 @@ impl Plugin for LightingPlugin {
         // The shared global-light buffer (build_light_data after the resolve above; the extract +
         // render-world upload). Materials read this instead of carrying their own light copy.
         global_light::register(app);
+        // MONKEY (daylight fixtures): the per-frame re-aim, ordered before the packer's own set.
+        daylight::register(app);
     }
 }
 
@@ -449,6 +489,12 @@ mod ordering_tests {
                 "the celestial follows: PostUpdate, BillboardPlace",
             ),
             ("weather/precip/mod.rs", "push_precip: PostUpdate"),
+            // MONKEY (daylight fixtures / portal bleed): both systems are PostUpdate,
+            // chained before `global_light::classify_light_lanes`.
+            (
+                "lighting/daylight.rs",
+                "update_daylight_fixtures + update_bleed_fixtures: PostUpdate",
+            ),
         ];
         let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
         let mut offenders = Vec::new();
diff --git a/crates/benilla-world/src/mesh_tag.rs b/crates/benilla-world/src/mesh_tag.rs
index df4c2bb9..5a9ac3bd 100644
--- a/crates/benilla-world/src/mesh_tag.rs
+++ b/crates/benilla-world/src/mesh_tag.rs
@@ -50,7 +50,16 @@
 //!   `255` = fully MCSH-shadowed): the per-instance mix from the batch's lit sun level toward the
 //!   shaded one (`wow_model.wgsl`). Entities (units/players/GameObjects) ramp it per frame
 //!   ([`crate::entity_shade`]); statics (doodads/props) leave it `0` — their shade is the
-//!   per-material selector (`sun_scale.x`). Bits 14..=18 are reserved (0).
+//!   per-material selector (`sun_scale.x`). Bit 14 is the **MATTE-INDOOR flag**
+//!   ([`MATTE_INDOOR_BIT`], MONKEY torch shadows Phase 3A): the classifier's `Matte` law — an
+//!   entity standing INDOORS whose material nonetheless stays in exterior mode (day/night, no
+//!   bake). `wow_model.wgsl` routes such a part to the dynamic-interior lane on it, so a unit
+//!   whose verdict flickers `Bake`↔`Matte` at one spot keeps its lane. Bits 15..=18 are the
+//!   **lane weight** ([`LANE_MASK`], MONKEY portal lane fade): a 4-bit crossfade from the
+//!   exterior result (`0`) to the room result (`15`), so an entity walking through a portal
+//!   blends between the two lanes over the anchor's ramp instead of popping in one frame. It is
+//!   meaningful only alongside bit 14 — [`with_matte_indoor`] writes the pair, and the shader
+//!   mixes by it.
 //! - **Interior probe slot** (interior M2 props/entities — material in interior mode,
 //!   `model_flags.z` set, not a WMO): bits 6..=18 carry the SH-probe TABLE SLOT (see
 //!   [`crate::lighting::PropProbes`]; 8192 slots = 13 bits), alpha and rig ride their fixed
@@ -169,6 +178,24 @@ const ALPHA_MAX: f32 = 63.0;
 /// Bits 6..=13 of the exterior payload: the ground-shade byte.
 const SHADE_MASK: u32 = 0x0000_3fc0;
 const SHADE_SHIFT: u32 = 6;
+/// Bit 14 of the exterior payload (MONKEY, torch shadows Phase 3A): the part's anchor classified
+/// INDOORS under the `Matte` law — exterior material mode, but the room's dynamic light applies.
+/// Sits in the exterior payload's reserved bits, so [`with_shade`]/[`with_alpha`]/[`with_rig`]
+/// carry it through and the shader's 8-bit shade decode never sees it.
+pub(crate) const MATTE_INDOOR_BIT: u32 = 0x0000_4000;
+/// Bits 15..=18 of the exterior payload (MONKEY, portal lane fade): the **lane weight**, a 4-bit
+/// crossfade `0` (fully exterior-lit) … [`LANE_MAX`] (fully room-lit) that the shader mixes the
+/// two lanes by. It rides beside [`MATTE_INDOOR_BIT`] — the bit says "this part is on the room
+/// lane at all", the field says how far — and like it, sits above the shade byte so
+/// [`with_shade`]/[`with_alpha`]/[`with_rig`]/[`with_interior_fog`] carry it through and
+/// [`with_exterior_reset`] clears it. 16 steps is past perceptual for a half-second ramp (the
+/// same reasoning as the 6-bit alpha), and the four bits are exactly what the exterior payload
+/// had left over.
+const LANE_MASK: u32 = 0x0007_8000;
+const LANE_SHIFT: u32 = 15;
+/// The saturated lane weight — the quantization step count the ramp's owner
+/// (`crate::interior::InteriorAnchor`) rounds its `0..=1` fraction onto.
+pub(crate) const LANE_MAX: u8 = 15;
 /// Bits 6..=18 of the interior payload: the SH-probe table slot (13 bits ⇔ 8192 slots).
 const PROBE_MASK: u32 = 0x0007_ffc0;
 const PROBE_SHIFT: u32 = 6;
@@ -230,6 +257,26 @@ pub(crate) fn with_exterior_reset(tag: u32) -> u32 {
     (tag & RIG_MASK) | carried_alpha(tag)
 }
 
+/// Rewrite a tag as a fresh exterior payload flagged MATTE-INDOOR ([`MATTE_INDOOR_BIT`]) at lane
+/// weight `lane`, preserving the rig and alpha fields: the classifier's `Matte`-law write (MONKEY,
+/// torch shadows Phase 3A) and — since the portal lane fade — every write of a part whose anchor's
+/// crossfade is still in motion, whichever indoor law it is heading for. The shade writer
+/// re-asserts its byte the same frame and carries both the bit and the field through.
+///
+/// The two travel together on purpose: the shader reads the field ONLY under the bit, so a lane
+/// weight can never be mistaken for the reserved zeros of a plain exterior payload. `lane` is
+/// clamped to [`LANE_MAX`] rather than masked — a caller's rounding overshoot must saturate at
+/// "fully room-lit", not wrap to "fully exterior".
+pub(crate) fn with_matte_indoor(tag: u32, lane: u8) -> u32 {
+    with_exterior_reset(tag) | MATTE_INDOOR_BIT | (u32::from(lane.min(LANE_MAX)) << LANE_SHIFT)
+}
+
+/// Read back the lane weight of an exterior-payload tag (`0`..=[`LANE_MAX`]) — the probe readout
+/// and the tests. Meaningless on an interior payload, where these bits are part of the probe slot.
+pub(crate) fn lane_of(tag: u32) -> u8 {
+    ((tag & LANE_MASK) >> LANE_SHIFT) as u8
+}
+
 /// **A spawned part's initial `MeshTag`** — its rig slot and its starting render alpha, the two
 /// fields every spawner sets and the only two it may.
 ///
@@ -396,10 +443,14 @@ pub fn describe(tag: u32) -> String {
     // Both readings come off the RAW masks, deliberately: this is the one caller that has no
     // material context and wants none — printing the ambiguity IS its job, so it is the one place
     // that must not take an [`ExteriorPayload`] witness (it could not honestly produce one).
+    // MONKEY (portal lane fade): the lane weight is printed with the exterior reading (`shade`),
+    // because it shares the same law -- on an interior payload these bits are inside the `slot`
+    // beside it, exactly as the shade byte is.
     format!(
-        "{tag:#010x}{flags} α {:.3} shade {} / slot {} rig {}",
+        "{tag:#010x}{flags} α {:.3} shade {} lane {} / slot {} rig {}",
         alpha_of(tag),
         (tag & SHADE_MASK) >> SHADE_SHIFT,
+        lane_of(tag),
         (tag & PROBE_MASK) >> PROBE_SHIFT,
         rig_of(tag),
     )
@@ -538,6 +589,49 @@ mod tests {
         assert_eq!((probe_bits(6660) & PROBE_MASK) >> PROBE_SHIFT, 6660);
     }
 
+    /// MONKEY (torch shadows Phase 3A + portal lane fade): the Matte-law indoor flag rides the
+    /// exterior payload's reserved bit 14 and the lane weight bits 15..=18 — the per-frame
+    /// shade/alpha/rig/fog writers carry BOTH, the shade decode never sees either, and the
+    /// exterior reclaim clears both. The lane field is what makes the flag a crossfade instead of
+    /// a switch, so anything that carried the bit and dropped the field would silently snap an
+    /// entity to fully room-lit the first frame `entity_shade` re-asserted its byte.
+    #[test]
+    fn matte_indoor_bit_survives_the_field_writers_and_clears_on_exterior() {
+        let t = with_matte_indoor(rig_bits(9) | alpha_bits(0.5), 6);
+        assert_eq!(t & MATTE_INDOOR_BIT, MATTE_INDOOR_BIT);
+        assert_eq!(lane_of(t), 6);
+        assert_eq!(rig_of(t), 9);
+        assert_eq!(t & ALPHA_MASK, alpha_bits(0.5));
+        assert_eq!(with_shade(t, 255, ext()) & MATTE_INDOOR_BIT, MATTE_INDOOR_BIT);
+        assert_eq!(lane_of(with_shade(t, 255, ext())), 6);
+        assert_eq!(shade_of(with_shade(t, 255, ext()), ext()), 255);
+        assert_eq!(with_alpha(t, 0.25) & MATTE_INDOOR_BIT, MATTE_INDOOR_BIT);
+        assert_eq!(lane_of(with_alpha(t, 0.25)), 6);
+        assert_eq!(with_rig(t, 3) & MATTE_INDOOR_BIT, MATTE_INDOOR_BIT);
+        assert_eq!(lane_of(with_rig(t, 3)), 6);
+        assert_eq!(with_interior_fog(t, true) & MATTE_INDOOR_BIT, MATTE_INDOOR_BIT);
+        assert_eq!(lane_of(with_interior_fog(t, true)), 6);
+        assert_eq!(with_exterior_reset(t) & MATTE_INDOOR_BIT, 0);
+        assert_eq!(lane_of(with_exterior_reset(t)), 0);
+        assert_eq!(shade_of(t, ext()), 0, "the flag is outside the shade byte");
+        // …and the lane is outside it too, at BOTH ends of its range: a saturated lane must not
+        // read back as a shade byte of 240 (the failure the pair of decodes is here to catch).
+        let full = with_matte_indoor(alpha_bits(1.0), LANE_MAX);
+        assert_eq!(lane_of(full), LANE_MAX);
+        assert_eq!(shade_of(full, ext()), 0);
+        assert_eq!(shade_of(with_shade(full, 128, ext()), ext()), 128);
+        assert_eq!(lane_of(with_shade(full, 128, ext())), LANE_MAX);
+        // An overshooting caller SATURATES rather than wrapping into the probe/rig neighbourhood.
+        let over = with_matte_indoor(alpha_bits(1.0), 200);
+        assert_eq!(lane_of(over), LANE_MAX);
+        assert_eq!(over & (RIG_MASK | SHADE_MASK), 0, "no spill into its neighbours");
+        // Lane 0 under the flag is legal (the first tick of a ramp) and is NOT the exterior reset:
+        // the bit is what routes the shader into the mix, the field is only its weight.
+        let zero = with_matte_indoor(alpha_bits(1.0), 0);
+        assert_eq!(lane_of(zero), 0);
+        assert_ne!(zero & MATTE_INDOOR_BIT, 0);
+    }
+
     /// Decision 0755: the classifier's whole-payload rewrites carry the tag's ALPHA field, which
     /// is what lets a part change light law while a fade owns its ramp. Before this they wrote
     /// `alpha_bits(1.0)`, so the classifier had to be locked out of fading parts entirely — and a
diff --git a/crates/benilla-world/src/model_render.rs b/crates/benilla-world/src/model_render.rs
index 69c96e51..08beb794 100644
--- a/crates/benilla-world/src/model_render.rs
+++ b/crates/benilla-world/src/model_render.rs
@@ -10,7 +10,7 @@ use bevy::pbr::ExtendedMaterial;
 use bevy::prelude::*;
 use bevy::render::render_resource::{Buffer, Face};
 
-use benilla_assets::materials::{WowModelExt, WowModelMaterial, VANILLA_ALPHA_KEY_REF};
+use benilla_assets::materials::{TorchBinds, WowModelExt, WowModelMaterial, VANILLA_ALPHA_KEY_REF};
 
 mod batch;
 pub mod lazy;
@@ -254,6 +254,9 @@ pub fn model_material(
     // and the skybox sort rung instead of the ordinary batch-order eps. See [`MatKey::sky_depth`].
     sky_depth: bool,
     light: &Buffer,
+    // MONKEY (torch shadows Phase 3A): the shared torch depth image + table buffer, cloned into the
+    // material beside `light` (not a key axis — one pair for the whole scene, like the light).
+    torch: &TorchBinds,
     // The ONE placement this material belongs to, or `None` for the shared batch material every
     // instance of the model reuses. `Some` only for a batch whose animated UV/tint loop depends on
     // the sequence its instance is playing (decision 1408): the animated-material registries are
@@ -505,6 +508,9 @@ pub fn model_material(
                 // table slot is baked in exactly once.
                 anim_slots: Vec4::ZERO,
                 light_buf: light.clone(),
+                // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
+                torch_depth: torch.depth.clone(),
+                torch_buf: torch.table.clone(),
             },
         },
     );
@@ -598,6 +604,7 @@ pub fn zfill_material(
     two_sided: bool,
     cutout: bool,
     light: &Buffer,
+    torch: &TorchBinds,
 ) -> Handle<WowModelMaterial> {
     let key = MatKey {
         light: light.id(),
@@ -669,6 +676,9 @@ pub fn zfill_material(
                 sidn: Vec4::ZERO,
                 anim_slots: Vec4::ZERO,
                 light_buf: light.clone(),
+                // MONKEY (torch shadows Phase 3A): the shared torch receiver bindings.
+                torch_depth: torch.depth.clone(),
+                torch_buf: torch.table.clone(),
             },
         },
     );
@@ -1285,11 +1295,29 @@ pub enum ModelKind {
 /// Tags every spawned model submesh with the metadata the panel toggles on: its subsystem and its
 /// blend mode (the "layer" — opaque trunk vs alpha-cut canopy).
 #[derive(Component, Clone, Copy)]
+#[require(ShadowOccluder)]
 pub struct ModelPart {
     pub kind: ModelKind,
     pub blend: ModelBlend,
 }
 
+/// The camera-INDEPENDENT half of [`visibility::apply_model_visibility`]'s verdict: does this
+/// submesh exist as world content this frame (toggles, far clip, distance fade, material alpha)?
+///
+/// `Visibility` cannot answer that for a shadow caster: it also folds the exterior window gate,
+/// the portal PVS and the exterior-scene cull — all functions of where the camera LOOKS — and a
+/// wall behind the camera still blocks the sun. Gating the caster proxy on `InheritedVisibility`
+/// made every entity-lane shadow swing with view direction. Defaults to occluding so a part casts
+/// correctly from its spawn frame; the walk corrects a toggled-off part one frame later.
+#[derive(Component, Clone, Copy)]
+pub struct ShadowOccluder(pub bool);
+
+impl Default for ShadowOccluder {
+    fn default() -> Self {
+        Self(true)
+    }
+}
+
 /// **Why this submesh is an entity at all** — the world streamer's answer, one static label per
 /// batch, for the census (`VIS_CENSUS … why …`). A city keeps thousands of hidden model
 /// submeshes resident on the entity path while the retained pass draws the world (5.6k ADT
diff --git a/crates/benilla-world/src/model_render/batch.rs b/crates/benilla-world/src/model_render/batch.rs
index 93cc786b..817bc060 100644
--- a/crates/benilla-world/src/model_render/batch.rs
+++ b/crates/benilla-world/src/model_render/batch.rs
@@ -20,7 +20,7 @@
 //! two lanes that build the same batch the same way get the same handle — which is the whole
 //! reason the cache exists, and was true of four separate caches only by luck.
 
-use benilla_assets::materials::WowModelMaterial;
+use benilla_assets::materials::{TorchBinds, WowModelMaterial};
 use benilla_assets::ModelSubmesh;
 use benilla_formats::ModelBlend;
 use bevy::ecs::system::SystemParam;
@@ -29,6 +29,7 @@ use bevy::render::render_resource::Buffer;
 
 use super::{model_material, zfill_material, MaterialCache, ShadeSel};
 use crate::lighting::SharedLightBuffer;
+use crate::static_gx::TorchShared;
 
 /// The engine's one `WowModelMaterial` dedup cache. Swept by distance like every other art cache
 /// (`art_scope`) and cleared whole on a map change; an evicted entry costs one rebuild, never a
@@ -95,12 +96,16 @@ pub struct M2BatchMaterials<'w> {
     cache: ResMut<'w, ModelMaterials>,
     materials: ResMut<'w, Assets<WowModelMaterial>>,
     light: Option<Res<'w, SharedLightBuffer>>,
+    /// MONKEY (torch shadows Phase 3A): the shared torch bindings every built material takes —
+    /// created in the same startup system as the light buffer, so the same "retry" contract.
+    torch: TorchShared<'w>,
 }
 
 impl M2BatchMaterials<'_> {
-    /// Is the shared light buffer resident? A spawner that has other work to skip asks first.
+    /// Is the shared light buffer (and the torch pair) resident? A spawner that has other work to
+    /// skip asks first.
     pub fn ready(&self) -> bool {
-        self.light.is_some()
+        self.light.is_some() && self.torch.binds().is_some()
     }
 
     /// The material store this param already holds — for a spawner that builds a batch's world
@@ -124,6 +129,7 @@ impl M2BatchMaterials<'_> {
         order: u16,
     ) -> Option<Handle<WowModelMaterial>> {
         let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
         Some(self.build(
             sub,
             texture,
@@ -133,6 +139,7 @@ impl M2BatchMaterials<'_> {
             false,
             false,
             &light,
+            &torch,
         ))
     }
 
@@ -177,6 +184,7 @@ impl M2BatchMaterials<'_> {
         order: u16,
     ) -> Option<SkyboxBatch> {
         let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
         let mut mk = |fade: bool| {
             model_material(
                 &mut self.cache.0,
@@ -208,6 +216,7 @@ impl M2BatchMaterials<'_> {
                 false,
                 true, // the sky lane
                 &light,
+                &torch,
                 None, // one shared sky material — no per-sequence channel to key on
             )
         };
@@ -250,7 +259,18 @@ impl M2BatchMaterials<'_> {
         rig: bool,
     ) -> Handle<WowModelMaterial> {
         let shade = if rig { ShadeSel::Rig } else { ShadeSel::Lit };
-        self.build(sub, texture, order, shade, false, false, rig, light)
+        // MONKEY (torch shadows Phase 3A): the torch pair is global (one image, one table for the
+        // whole process), so an off-world lane takes it from the shared resources even though its
+        // LIGHT is its own. Both are inserted by `assets::open_world_assets` at `Startup`, before
+        // any booth or glue system can run, so this cannot fire in a real app; it is an `expect`
+        // rather than an `Option` return because both callers build `BoothPart`s inside `.map()`
+        // closures that want a handle, not a retry. (An off-world scene never lights by the
+        // interior room lane, so the bindings are only ever read as "no torches".)
+        let torch = self.torch.binds().expect(
+            "TorchShared: the torch depth image + table are created at Startup \
+             (assets::open_world_assets) before any off-world material is built",
+        );
+        self.build(sub, texture, order, shade, false, false, rig, light, &torch)
     }
 
     /// The full variant set an **entity** part needs: every M2 entity — unit, player, GameObject,
@@ -279,6 +299,7 @@ impl M2BatchMaterials<'_> {
         uv: &mut EntityUvLane<'_>,
     ) -> Option<BatchVariants> {
         let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
         let steady = self.build(
             sub,
             texture.clone(),
@@ -288,6 +309,7 @@ impl M2BatchMaterials<'_> {
             false,
             true,
             &light,
+            &torch,
         );
         let interior = self.build(
             sub,
@@ -298,6 +320,7 @@ impl M2BatchMaterials<'_> {
             false,
             true,
             &light,
+            &torch,
         );
         let interior_bake = self.build(
             sub,
@@ -308,6 +331,7 @@ impl M2BatchMaterials<'_> {
             false,
             true,
             &light,
+            &torch,
         );
         // A multiply batch (Mod/Mod2x) and an authored-Blend batch are their own twin: the first
         // because its blend equation reads no alpha at all — the fade rides the shader's
@@ -331,6 +355,7 @@ impl M2BatchMaterials<'_> {
                 true,
                 true,
                 &light,
+                &torch,
             )
         };
         let interior_bake_blend = if own_twin {
@@ -345,6 +370,7 @@ impl M2BatchMaterials<'_> {
                 true,
                 true,
                 &light,
+                &torch,
             )
         };
         // On the lane, now, in the same call that built and seeded them. `register_entity_uv` is
@@ -374,7 +400,7 @@ impl M2BatchMaterials<'_> {
             interior_bake,
             interior_bake_blend,
             fade_blend,
-            zfill: self.zfill_for(sub, texture, &light),
+            zfill: self.zfill_for(sub, texture, &light, &torch),
         })
     }
 
@@ -392,6 +418,7 @@ impl M2BatchMaterials<'_> {
         two_sided: bool,
     ) -> Option<BatchVariants> {
         let light = self.light.as_ref()?.0.clone();
+        let torch = self.torch.binds()?;
         let mut mk = |shade: ShadeSel, probe: bool, fade: bool| {
             model_material(
                 &mut self.cache.0,
@@ -422,6 +449,7 @@ impl M2BatchMaterials<'_> {
                 false, // …nor the WINDOW flag
                 false, // a character composite is never a skybox
                 &light,
+                &torch,
                 None, // a composite sheet carries no animated UV/tint channel at all
             )
         };
@@ -441,6 +469,7 @@ impl M2BatchMaterials<'_> {
                 two_sided,
                 blend == ModelBlend::AlphaTest,
                 &light,
+                &torch,
             )),
         })
     }
@@ -456,9 +485,15 @@ impl M2BatchMaterials<'_> {
     /// this facade to a lane it does not serve.
     pub fn pieces(
         &mut self,
-    ) -> Option<(&mut MaterialCache, &mut Assets<WowModelMaterial>, Buffer)> {
+    ) -> Option<(
+        &mut MaterialCache,
+        &mut Assets<WowModelMaterial>,
+        Buffer,
+        TorchBinds,
+    )> {
         let light = self.light.as_ref()?.0.clone();
-        Some((&mut self.cache.0, &mut self.materials, light))
+        let torch = self.torch.binds()?;
+        Some((&mut self.cache.0, &mut self.materials, light, torch))
     }
 
     /// The depth-prime twin, or `None` for a batch that primes nothing: one that disables depth
@@ -469,6 +504,7 @@ impl M2BatchMaterials<'_> {
         sub: &ModelSubmesh,
         texture: Option<Handle<Image>>,
         light: &Buffer,
+        torch: &TorchBinds,
     ) -> Option<Handle<WowModelMaterial>> {
         if sub.no_depth_write || sub.no_depth_test {
             return None;
@@ -482,6 +518,7 @@ impl M2BatchMaterials<'_> {
                 sub.two_sided,
                 b == ModelBlend::AlphaTest,
                 light,
+                torch,
             )),
         }
     }
@@ -498,6 +535,7 @@ impl M2BatchMaterials<'_> {
         fade: bool,
         play_uv: bool,
         light: &Buffer,
+        torch: &TorchBinds,
     ) -> Handle<WowModelMaterial> {
         model_material(
             &mut self.cache.0,
@@ -530,6 +568,7 @@ impl M2BatchMaterials<'_> {
             // asks for, so it cannot be one more variant built from `sub` here.
             false,
             light,
+            torch,
             // The ENTITY lane's batches (units, GameObjects, held items): shared per batch, as
             // ever. The per-placement lane is the world streamer's alone (decision 1408) — every
             // affected model is a placed `World\…` prop, and an entity already resolves its
diff --git a/crates/benilla-world/src/model_render/visibility.rs b/crates/benilla-world/src/model_render/visibility.rs
index f952f24e..46b2f346 100644
--- a/crates/benilla-world/src/model_render/visibility.rs
+++ b/crates/benilla-world/src/model_render/visibility.rs
@@ -76,6 +76,7 @@ pub(super) fn apply_model_visibility(
         &ModelPart,
         Ref<GlobalTransform>,
         &mut Visibility,
+        &mut super::ShadowOccluder,
         Option<&DoodadFade>,
         Option<&mut MeshTag>,
         Option<&mut MeshMaterial3d<WowModelMaterial>>,
@@ -144,6 +145,7 @@ pub(super) fn apply_model_visibility(
             part,
             xf,
             mut vis,
+            mut occluder,
             fade,
             tag,
             mat,
@@ -290,6 +292,15 @@ pub(super) fn apply_model_visibility(
                 *vis = desired;
             }
 
+            // The shadow-caster verdict: the CONTENT terms only. `portal_visible`, `exterior_ok`
+            // and `owner_hidden` are all functions of where the camera looks, and geometry the
+            // camera cannot see still blocks the sun — folding them in made entity-lane shadows
+            // swing with view direction. Change-gated like every write in this walk.
+            let occludes = toggled_on && in_range && fade_alpha > 0.0 && mat_factor > 0.0;
+            if occluder.0 != occludes {
+                occluder.0 = occludes;
+            }
+
             // Push the fade alpha to the shader (per-instance `MeshTag` alpha field — `wow_model.wgsl`
             // multiplies the cutout alpha by it) and swap to the blend material variant while feathering,
             // back to the cutout once opaque. Write only on change so steady doodads (`fade == 1.0`,
diff --git a/crates/benilla-world/src/particles/model.rs b/crates/benilla-world/src/particles/model.rs
index 4ff81a48..162c9045 100644
--- a/crates/benilla-world/src/particles/model.rs
+++ b/crates/benilla-world/src/particles/model.rs
@@ -48,6 +48,8 @@ pub(super) fn update_model_particles(
     mut mesh_assets: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<WowModelMaterial>>,
     light: Res<crate::lighting::SharedLightBuffer>,
+    // MONKEY (torch shadows Phase 3A): the shared torch bindings every instance material takes.
+    torch: crate::static_gx::TorchShared,
     mut emitters: Query<&mut ParticleEmitter>,
     mut draws: Query<
         (
@@ -59,6 +61,11 @@ pub(super) fn update_model_particles(
         With<ChildDraw>,
     >,
 ) {
+    // Created in the same startup system as the light buffer; absent only before it ran, when
+    // there is nothing to build a material against yet.
+    let Some(torch) = torch.binds() else {
+        return;
+    };
     for mut emitter in &mut emitters {
         let Some(geometry) = emitter.geometry.clone() else {
             continue;
@@ -117,6 +124,7 @@ pub(super) fn update_model_particles(
                         false,
                         false, // an effect model is never a skybox
                         &light.0,
+                        &torch,
                         None, // a shard's material is shared by the whole emitter
                     );
                     // Realized at once: the over-life ramp writes this material through
diff --git a/crates/benilla-world/src/shaders.rs b/crates/benilla-world/src/shaders.rs
index 1c031f64..434813ac 100644
--- a/crates/benilla-world/src/shaders.rs
+++ b/crates/benilla-world/src/shaders.rs
@@ -38,6 +38,8 @@ pub(crate) fn plugin(app: &mut App) {
     bevy::asset::embedded_asset!(app, "shaders/ffx_glow.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/wow_effect.wgsl");
     bevy::asset::embedded_asset!(app, "shaders/static_gx.wgsl");
+    // MONKEY (torch shadows Phase 1): the vertex-only depth-map shader for the interior-fixture pass.
+    bevy::asset::embedded_asset!(app, "shaders/torch_depth.wgsl");
 }
 
 #[cfg(test)]
@@ -81,7 +83,8 @@ mod tests {
         // 6 since decision 1264 retired `skybox.wgsl` (a WMO skybox draws on the shared
         // model lane, whose forced-far-depth branch lives in `benilla_assets`'
         // `wow_model.wgsl`); 7 since 1429 added `static_gx.wgsl` (the B1 retained pass);
-        // 8 since 2016 added `sky_vertex.wgsl` (the sky's shared far-depth vertex stage).
-        assert_eq!(found, 8, "the engine's shader set changed size");
+        // 8 since 2016 added `sky_vertex.wgsl` (the sky's shared far-depth vertex stage);
+        // 9 since the torch-shadow Phase 1 added `torch_depth.wgsl` (the interior depth map).
+        assert_eq!(found, 9, "the engine's shader set changed size");
     }
 }
diff --git a/crates/benilla-world/src/shaders/static_gx.wgsl b/crates/benilla-world/src/shaders/static_gx.wgsl
index 45d8984a..3908854f 100644
--- a/crates/benilla-world/src/shaders/static_gx.wgsl
+++ b/crates/benilla-world/src/shaders/static_gx.wgsl
@@ -27,9 +27,16 @@
 // `Matte`). Output alpha is pinned 1.0 — every draw here is opaque-intent by admission
 // (wow_model.wgsl's bit-3 armor, as a constant).
 
-#import bevy_render::view::View
+#import bevy_pbr::{
+    mesh_view_bindings::{lights, view},
+    shadows,
+}
+// MONKEY (shadow hook): the realtime directional-shadow term (fetch + edge/night fade) lives here.
+#import benilla::shadow_hook
 
-@group(0) @binding(0) var<uniform> view: View;
+// Group 0 is Bevy's standard mesh-view bind group (view matrices, directional-light records and
+// the shadow textures the retained pass reads).
+const SHADOW_SUN_FLOOR: f32 = 0.45;
 
 // The shared global light's per-frame PREFIX (lighting::global_light; the full layout lives in
 // wow_model.wgsl — keep field order in sync with BOTH).
@@ -51,6 +58,10 @@ struct WowLight {
     grade: vec4<f32>,
     wmo_fog_color: vec4<f32>,
     wmo_fog_params: vec4<f32>,
+    // MONKEY (light lanes): each light is TWO rows — `[pos.xyz, range]`, `[rgb, lane]`. `lane` is
+    // `0` for an EXTERIOR light (read only by `point_light_sum`) and `> 0.5` for an INTERIOR
+    // fixture (read only by `interior_room_light`), where the value IS that fixture's reach in
+    // yards. wow_model.wgsl owns the full note.
     point_count: vec4<f32>,
     points: array<vec4<f32>, 512>,
     // The interior-prop SH probe table (B4 — lighting::prop_probes, 7 rows per slot, 8192
@@ -59,11 +70,32 @@ struct WowLight {
     // rig/tint/mat-anim regions beyond it stay unmirrored (statics never read them).
     prop_probes: array<vec4<f32>, 57344>,
 }
-@group(0) @binding(1) var<storage, read> wow_light: WowLight;
+@group(2) @binding(0) var<storage, read> wow_light: WowLight;
+// MONKEY (room gate): the per-fixture ROOM CLAIM table — which WMO groups each packed INTERIOR
+// fixture is allowed to light. Packed by `lighting::global_light`'s `build_light_data` into its own
+// storage buffer (NEVER into `WowLight`: that struct is mirrored three ways and must not resize),
+// and bound here beside it. `ROOM_CLAIM_STRIDE` u32 per packed light, index-parallel with the
+// point table:
+//   [0] the claiming WMO placement's ENTITY INDEX   [1] claim count (**0 = UNGATED**)
+//   [2 .. 2+ROOM_CLAIM_MAX) the claimed group ids, stored as `group + 1` so 0 stays "empty"
+// MONKEY (soft portal claims): then one 4-word FADE record per claim slot, at `ROOM_CLAIM_FADE`:
+//   [+0..+3] the doorway's WORLD-space centre, raw f32 bits (a world coordinate reaches ~17000 yd,
+//            so nothing narrower carries it; the CPU side converts out of WMO model space once, at
+//            spawn, because this side has only a fragment position and no placement matrix)
+//   [+3]     `radius | slack << 16`, both u16 yards x CLAIM_FADE_SCALE. **radius 0 = a HARD claim**
+//            (containment/MOLR: weight 1 everywhere), which is also what the zero padding reads as
+// Every claim of one fixture shares one instance, because a fixture belongs to exactly one
+// building (`LightRooms`/`WmoGroupVis` carries one instance and a group list) — which is what lets
+// the instance sit in the head word instead of once per claim.
+@group(2) @binding(1) var<storage, read> room_claims: array<u32>;
 
 // Per-cell state (static_gx/render.rs `cell_layout`).
 struct GxCell {
-    origin: vec4<f32>, // xyz = the bake's recentring origin (0974): world = vertex + origin
+    // xyz = the bake's recentring origin (0974): world = vertex + origin.
+    // MONKEY (room gate): `.w` is this REGION's identity — the WMO placement instance's entity
+    // index, `bitcast` out of the float lane (the uniform's declared size is 16 bytes and must not
+    // move; the lane was a hard 0.0 pad). 0 on terrain cells, which name no building.
+    origin: vec4<f32>,
 }
 @group(1) @binding(0) var<uniform> cell: GxCell;
 // The per-ITEM record table, indexed by the vertex word's low bits:
@@ -98,9 +130,401 @@ const WORD_HAS_VC: u32 = 134217728u;   // 1 << 27 — the batch AUTHORED vertex
 // point lights.
 const WORD_MATTE: u32 = 268435456u;    // 1 << 28 — EITHER doodad class (ADT MDDF or exterior MODD prop): intensity FIXED 1.0 (2050)
 
+// MONKEY (room gate): record column `w` bits 15..=26 — this item's ROOM KEY, packed as
+// `group + 1`, so **0 means the item names no room** and takes every fixture (a terrain-cell item,
+// or a WMO prop whose referrer set is not exactly one group). Bit 0 is the exile kill bit, bits
+// 1..=13 the interior-prop probe slot and bit 14 the interior fog lane, so 15 is the first free
+// bit; 12 bits covers every shipped WMO's group count (the largest, Stratholme, has 92).
+const RECORD_ROOM_SHIFT: u32 = 15u;
+const RECORD_ROOM_MASK: u32 = 4095u;
+
+// MONKEY (ext-class night law): record column `w`, bit 27 — this batch's group is EXTERIOR-class
+// (MOGP `& 0x48`) but at BUILDING scale, `benilla_formats::room_claim::ext_building_scale`. The
+// room key ends at bit 26, so 27 is the first free one. Keep in sync with `static_gx/render.rs`'s
+// `RECORD_EXT_NIGHT_BIT`.
+const RECORD_EXT_NIGHT: u32 = 134217728u; // 1 << 27
+
+// MONKEY (enclosed day floor): record column `w`, bit 28 — this batch's group is an INTERIOR room
+// whose box centre sits inside a BUILDING-SCALE exterior shell of the same WMO
+// (`benilla_formats::room_claim::enclosed_by_building_shell`). Bit 27 is the night law, so 28 is
+// the first free one; 29..=31 stay free. Keep in sync with `static_gx/render.rs`'s
+// `RECORD_ENCLOSED_BIT`.
+const RECORD_ENCLOSED: u32 = 268435456u; // 1 << 28
+
+// MONKEY (enclosed day floor): the fraction of `wmo_fog_params.w` that carries `interiorDaylight`
+// (`w = 1 + interiorDebug + interiorDaylight * this`). Keep in sync with
+// `benilla_world::lighting::DAYLIGHT_LANE_SCALE`, which carries the whole argument for why the
+// value rides a lane's spare RANGE rather than a spare slot, and why every existing decode of this
+// lane (`> 0.5`, `u32(max(w - 1, 0) + 0.5)`) is insensitive to a fraction below 0.5.
+const DAYLIGHT_LANE_SCALE: f32 = 0.49;
+
+// MONKEY (bake floor): the fraction of `sh_c16.w` that carries `interiorBakeFloor`, with
+// `interiorGain` ALREADY FOLDED IN by the packer (`w = worldShadows + bakeFloor * gain * this`).
+// Keep in sync with `benilla_world::lighting::BAKE_LANE_SCALE` and with `wow_model.wgsl`'s copy.
+// `sh_c16.w` has exactly ONE other decode in the whole shader set — `terrain.wgsl`'s
+// `sh_c16.w > 0.5` world-shadow gate — and a fraction strictly below 0.5 cannot move it from
+// either side; the packer clamps the product to 1 so the fraction can never reach the cliff.
+const BAKE_LANE_SCALE: f32 = 0.49;
+
+// MONKEY (bake floor): the SHARE OF ITS OWN MOCV BAKE that an interior-lane fragment keeps even
+// when no fixture reaches it.
+//
+// The room lane's premise is that the bake's LEVEL is wrong — authored for a different global
+// exposure, and the live fixtures decide instead. True, and it leaves a hole: a room the fixture
+// table cannot reach has NO budget at all beyond `interiorAmbient`, so it renders black. The
+// Lion's Pride Inn's east vestibule `g0` (the door band, box x 14.1..20.5, between the ext-class
+// porch `g11` and the INT room `g1`) is the measured case — MOLR 0, ZERO fixture claims (the
+// nearest fixtures are L2 at 16 yd against R 11.2 and L3 at 17.6 against R 14.7), one faded portal
+// hop worth ~0.0003, so the whole budget is the bare ambient floor and the band reads 0.0194 x tex
+// at the owner's cvars. The reference client has no such hole: every interior batch draws at its
+// authored MOCV whether or not a light is registered, so a fixture-starved vestibule is DIM there,
+// never black.
+//
+// What survives the lane's premise is the bake's RELATIVE statement about the room, so the floor
+// is a FRACTION of it (`vc.rgb * k`), not the bake. It is added INSIDE the rolloff next to
+// `enclosed_day_floor`, for the same reason that one is: it saturates with the fixtures rather
+// than stacking on a lit room, so a candle-lit surface barely moves while an unlit one comes up
+// off the floor. The previous attempt put the UNCAPPED bake share on the TRANS batches alone and
+// produced the flat grey band this file's portal-bleed comment records (15-18 x its INT
+// neighbour); a small fraction of the bake on EVERY interior batch is the other end of that trade.
+//
+// SCOPE — zero on an EXT-class batch of an interior group (`!class_int && !class_trans`, the
+// cellar stair). The loader forces that population's MOCV alpha to 1.0 and its `vc.rgb` is the
+// flat white the EXT batches carry (the extract prints `mocv rgb (255,255,255)` for every one of
+// them), so a bake term there would be a full-strength WHITE lift on exactly the geometry the
+// verified green-stair fix rebuilt — and there is no authored bake to restore anyway. That
+// predicate is written as the two class bits rather than as `trans_a >= 1.0` because the class
+// bits are what the loader actually sets; `trans_a` being 1 is a consequence. Zero as well on a
+// batch with NO authored MOCV at all (`has_vc`), where `vc` is the synthetic `vec4(1.0)` default:
+// there is no bake to keep a share of, and a full white `k` there would be an invention.
+//
+// NOT scaled by `fireLightGain` and NOT flickered: this is not a fire, it is the room's own
+// authored light. The `interiorGain` scale IS applied, folded in at pack time exactly as the
+// lane's other two inputs (base ambient, per-fixture fill) are — so the Dim preset dims it too and
+// the shader carries no second knob.
+//
+// MEASURED at the owner's live cvars (`interiorGain 0.5`, `interiorAmbient 0.015`,
+// `interiorFill 0.08`, `interiorExposure 2.5`, `interiorAttenScale 1.6`, `interiorDaylight 0`) at
+// `interiorBakeFloor 0.12` (so `k` = 0.06), at NIGHT:
+//   * `g0` one yard inside p1 (TRANS, MOCV (165,160,146) => bake 0.0377):
+//       room law 0.0194 -> **0.1075** x tex; the existing 1.5x TRANS floor then displays it at
+//       **0.1613** (the floor follows the raised room — it was 0.0291 before).
+//   * `g1` one yard the other side (INT, MOCV (119,106,77) => bake 0.0251):
+//       0.0215 -> **0.0810** x tex. Room-law ratio across the doorway 1.33x (was 1.11x); the
+//       DISPLAYED ratio is 1.99x because the pre-existing TRANS floor still lifts `g0` by 1.5x.
+//   * `g3`'s entry floor directly under L9 (1.52 yd, MOCV (250,164,83)): 0.5668 -> 0.6078, **+7.2 %**.
+//   * a `g5` hall wall 3 yd from L0 (MOCV (146,113,78)): 0.4192 -> 0.4578, **+9.2 %**.
+// i.e. both fixture-lit references move by well under the 15 % bar, and the black band does not.
+// (The floor is NOT sun-gated, unlike `enclosed_day_floor`: a bake floor that vanished by day
+// would black the same vestibule out at noon. Daylight therefore lifts by the same ~7-9 % on
+// fixture-lit interiors, and the `g0` band by ~+20 % through the TRANS blend.)
+fn interior_bake_floor(
+    vc_rgb: vec3<f32>,
+    has_vc: bool,
+    class_int: bool,
+    class_trans: bool,
+) -> vec3<f32> {
+    // `has_vc` too: with no MOCV authored, `vc` is the synthetic `vec4(1.0)` default, and lifting
+    // by a full white `k` would be inventing a bake rather than restoring a share of one.
+    if (!has_vc || (!class_int && !class_trans)) {
+        return vec3<f32>(0.0);
+    }
+    return vc_rgb * (fract(wow_light.sh_c16.w) / BAKE_LANE_SCALE);
+}
+
+// MONKEY (enclosed day floor): the SUN'S OWN AMBIENT FLOOR for a room inside a building — the
+// daylight that comes through the doorways this renderer cannot locate.
+//
+// Three seeds now stand real fixtures in a building's authored openings (`lighting::daylight`:
+// interior<->exterior portals, EXT-class batches of interior groups, stitched group seams), and
+// where an opening IS in the data that is the better answer — a pool at the door falling off
+// inward, not a uniform lift. But the shipped corpus keeps rooms whose doorway is in no table at
+// all: the Goldshire inn's entry group authors no portal to its shell, no EXT-class batch, no
+// vertex within half a yard of the shell that owns its threshold planks, and no localized hot spot
+// in its own MOCV bake. There is nowhere to stand a light. What IS known is that the group is a
+// room in a building and the sun is up, and the honest rendering of that is "not pitch dark".
+//
+// The colour is the sky's own AMBIENT band renormalised to unit luminance, so the scalar cvar is
+// the floor's luminance outright and the tint is the day's. `sun_w` is `fog_params.z` —
+// `sun_shadow_strength(celestial_dir.y)`, exactly 0 at and below the horizon — so the NIGHT LOOK IS
+// BIT-IDENTICAL and the ramp rides the same dusk clock as `day_w`, the realtime shadows and the
+// daylight fixtures.
+//
+// It is added at the CALL SITE of `interior_room_light` rather than inside it, deliberately: that
+// function is also the exterior lane's `ext_room` term, which would otherwise lift every street
+// and outer wall in the world by this constant. And it composes with `interiorGain` by NOT being
+// scaled by it — the gain dims candle light, and this is sunlight.
+// `record_w` is the RECORD TABLE's `w` column (`recs[word & 0xffff].w`) — where every record bit
+// lives — and NOT the vertex word, whose own flag bits are a different space entirely.
+fn enclosed_day_floor(record_w: u32) -> vec3<f32> {
+    if ((record_w & RECORD_ENCLOSED) == 0u) {
+        return vec3<f32>(0.0);
+    }
+    let k = fract(wow_light.wmo_fog_params.w) / DAYLIGHT_LANE_SCALE;
+    let sun_w = clamp(wow_light.fog_params.z, 0.0, 1.0);
+    if (k * sun_w <= 0.0) {
+        return vec3<f32>(0.0);
+    }
+    let amb = wow_light.light_ambient.rgb;
+    let lum = dot(amb, vec3<f32>(0.2126, 0.7152, 0.0722));
+    // A degenerate ambient band (pitch-black zone) has no hue to carry, so fall back to white
+    // rather than dividing by nothing.
+    let tint = select(vec3<f32>(1.0), amb / max(lum, 1e-4), lum > 1e-4);
+    return tint * (k * sun_w);
+}
+
 // Vanilla cutout ref (224/255) — wow_model.wgsl's VANILLA_ALPHA_KEY.
 const VANILLA_ALPHA_KEY: f32 = 0.8784314;
 
+// MONKEY (torch shadows Phase 1): group 3 — the interior torch depth map + the ≤16-entry fixture
+// table. Declared (and sampled) ONLY under TORCH_SHADOWS, which the static_gx pipeline always sets;
+// the wow_model.wgsl copy of interior_room_light has no group 3 and must not see this block.
+#ifdef TORCH_SHADOWS
+struct TorchTable {
+    // MONKEY (static torch cache): byte-identical in BOTH shaders and TorchTableUniform.
+    // count@0 (16): x high-water slot count, y soft*100, z dynamic/live-bank mask, w reserved.
+    // positions@16 (256), view_projs@272 (6144): total 6416 bytes. A mismatch hides buildings.
+    // MONKEY (live bank rank): 96 static layers + 48 live layers; matrices stay slot-addressed.
+    count: vec4<u32>,
+    positions: array<vec4<f32>, 16>,
+    view_projs: array<mat4x4<f32>, 96>,
+}
+@group(3) @binding(0) var torch_depth: texture_depth_2d_array;
+@group(3) @binding(1) var torch_samp: sampler_comparison;
+@group(3) @binding(2) var<uniform> torch_table: TorchTable;
+// Reverse-Z depth bias: nudges the receiver's own depth up so a surface never shadows ITSELF (the
+// striped acne). KEEP SMALL — reverse-Z compresses depth far from the torch, so a large constant
+// bias there detaches every shadow (0.004 made the whole room read "lit"). 0.001 is the known-good
+// value that gave the clean forge-cast floor shadows; the residual acne only showed in the
+// worst-case interiorDebug 2 (min over all 4 maps), not the real per-fixture render.
+const TORCH_BIAS: f32 = 0.001;
+// MONKEY (surface normal offset): sample the map a hand's width OFF the receiving surface, along
+// its own normal. **MIRRORED from `terrain.wgsl` and `wow_model.wgsl` (same name, same 0.15) - keep
+// the three in sync**; this file was the one receiver still projecting the raw `P`, which is the
+// whole of the imp's "boxy" light pool.
+//
+// WHY A CONSTANT BIAS IS NOT ENOUGH, in numbers. A cube face is 512^2 at `TORCH_FACE_FOV` (pi/2 +
+// 0.02), so a texel covers `2*t*tan(45.57 deg)/512 = t/251` yd at ray distance `t`. On a floor `h`
+// below the fixture, `r` out from under it (`t = sqrt(r^2+h^2)`), the STORED depth changes across a
+// texel by that footprint times the grazing slope `r/h`, and the PCSS kernel's outermost tap sits
+// `soft * TORCH_PCSS_MAX = 1.5 * 4 = 6` texels out:
+//     kernel depth spread  D = 6 * (t/251) * (r/h)
+// while `TORCH_BIAS` in reverse-Z (near 0.1, `cube_view_projs`) is worth `0.001 * t^2 / 0.1 =
+// 0.01*t^2` YARDS of separation, and this offset adds `0.15 * (h/t)` (the normal's component along
+// the ray - which is exactly why it is taken along the NORMAL and not straight up: on a floor lit
+// from a low angle the two agree, on a wall the vertical offset would buy nothing).
+//
+//   WALL TORCH, h = 3 yd        r=1: D 0.025 vs bias 0.100     r=3: D 0.101 vs 0.180
+//                               r=6: D 0.321 vs 0.450          r=9: D 0.680 vs 0.900
+//     -> the bias alone clears the kernel by 1.3-1.8x at every radius. Torches were always fine.
+//   IMP HAND FLAME, h = 1 yd    r=1: D 0.034 vs bias 0.020     r=2: D 0.107 vs 0.050
+//                               r=3: D 0.227 vs 0.100
+//     -> the bias LOSES by 1.7-2.3x over the whole pool: every tap past the centre lands on floor
+//        texels nearer the fixture than the biased reference, so a fraction of the 4 (or 8) taps
+//        fails and the floor self-shadows. The fraction changes with the grazing angle and steps at
+//        the CUBE FACE boundaries, which is what turns a round pool into a square one (and, before
+//        PCSS widened the kernel, into concentric rings).
+//   WITH THIS OFFSET, h = 1 yd  r=1: 0.020+0.106 = 0.126 vs D 0.034  (3.7x margin)
+//                               r=2: 0.050+0.067 = 0.117 vs D 0.107  (1.1x)
+//                               r=3: 0.100+0.047 = 0.147 vs D 0.227  (still 1.5x short)
+//     -> clean out to r ~ 2.1 yd, which is where a 1 yd fixture's own direct term has already
+//        fallen to ~36 % of its peak (`INTERIOR_CORE_GAIN/(1+(d/1.75)^2)` at d = 2.3). RESIDUAL,
+//        named rather than hidden: a knee-high fixture's OUTER pool can still acne, and the honest
+//        cure for that is a slope-scaled bias or a grazing-angle clamp on the PCF radius, not a
+//        bigger constant (which detaches every real shadow - see TORCH_BIAS).
+//
+// MONKEY (slope bias): that RESIDUAL is now fixed - and TWO numbers above are wrong, so do not
+// re-derive from them. The table prices depth in yards along the RAY, but the compare reads
+// `ndc.z` on a cube FACE, which is a function of the VIEW-SPACE Z (the component along the face
+// AXIS). So (a) a floor is on the DOWN face while `r < h`, where its depth is the constant `h` and
+// acne is impossible, and crosses to a SIDE face after that, where the gradient is `2A/(f*h)` per
+// unit uv and does NOT grow with `r`; and (b) `0.15*(h/t)` is inverted - on a grazing floor this
+// offset moves the ray's own floor hit by `0.15*(t/h)`. Re-measured exactly, the offset holds a
+// h = 1 yd fixture clean to r = 10.1 yd, not 2.1. `shadow_hook::TORCH_SLOPE_MAX` carries the
+// corrected table and the receiver-plane bias that closes the rest.
+const TORCH_NORMAL_OFFSET: f32 = 0.15;
+// MONKEY (torch caster selection): the live PCF tap-radius scale, unpacked from the table's
+// `count.y`'s LOW 16 bits (stored x100 because the row is `vec4<u32>`; the high half is the
+// MONKEY (shadow floor) strength). Floored so a zero table cannot collapse
+// the kernel to a single texel.
+fn torch_soft() -> f32 {
+    return max(f32(torch_table.count.y & 0xffffu) * 0.01, 0.05);
+}
+// MONKEY (shadow floor): the live SHADOW STRENGTH (`torchShadowStrength`, 0..1, default 0.7),
+// unpacked from `count.y`'s HIGH half (`(strength x 100) << 16 | soft x 100` - see
+// `TorchTableUniform::pack`; the low half is `torch_soft` above and `count.w`'s flags are
+// untouched). It is applied as `mix(1, s, w * strength)` where the cross-fade weight already
+// multiplies the shadow factor, which is algebraically the same thing as flooring the factor
+// itself (`1 - w*strength*(1-s)` either way) for one extra multiply and no extra tap.
+//
+// WHY a floor at all: a torch map is the ONLY occlusion in the direct term, so a blocked fragment
+// used to drop that term to exactly zero - a pitch-black, razor-edged scar of tent canvas across
+// Darkmoon's grass, table legs printed on the Darkshire inn floor. Nothing in this renderer
+// bounces, so the 30 % that survives at the default IS the bounce: the fill/ambient arms are
+// untouched (they never saw this factor), only the DIRECT arm is floored. 1 restores the shipped
+// pitch-black look exactly, 0 disables torch shadows without disturbing the lane behind them.
+fn torch_strength() -> f32 {
+    return clamp(f32(torch_table.count.y >> 16u) * 0.01, 0.0, 1.0);
+}
+#endif
+
+// MONKEY (outdoor torch shadows): the EXTERIOR lane's world-distance fade radius (yd). See
+// `shadow_hook::torch_map_shadow`'s `fade` note for why the interior's reverse-Z `ndc.z` fade is
+// useless out here (it is already down to 5 % at 10 yd, and a campfire's pool is 15-25). Chosen
+// just inside the cube projection's own 48 yd far plane, so a shadow is at full strength across
+// the whole pool and has finished fading by the time the fragment leaves the frustum — which is
+// what stops the frustum edge from being a visible hard cut.
+const TORCH_EXT_FADE_YD: f32 = 44.0;
+// MONKEY (outdoor torch shadows): `count.w` bit 0 — the EXTERIOR receiver lane's live gate,
+// published by `benilla_app::torch_shadow` (the `exteriorShadows` cvar AND night AND at least one
+// promoted exterior fixture). Everything the exterior lane costs hangs off this ONE uniform read,
+// so by day / with the cvar off the receivers below are exactly the code they were before.
+const TORCH_EXT_LANE: u32 = 1u;
+// MONKEY (torch lane perf): below THIS much unshadowed direct contribution a fragment skips the
+// torch table scan and its four comparison taps entirely, because the shadow factor is multiplied
+// into that contribution and can therefore only ever subtract less than this from the frame.
+//
+// Sized off what the eye can see, not off "small": the interior budget goes through the
+// `1 - exp(-x * exposure)` rolloff, which for a term this small is just `x * exposure`, so at the
+// shipped `interiorExposure 2.5` the worst possible step across the guard's boundary is
+// 2.5e-4 linear = well under one 8-bit code. A tenth of this (1e-3) would have been a visible
+// ~8/255 contour along the iso-surface where the guard flips. Most of the skips it buys are exact
+// zeros anyway -- `window` IS 0 past the fixture's reach and `nl` IS 0 on a surface facing away --
+// so the threshold only has to be small enough to be invisible, never large enough to be useful.
+const TORCH_SKIP_EPS: f32 = 1e-4;
+fn torch_ext_on() -> bool {
+#ifdef TORCH_SHADOWS
+    return (torch_table.count.w & TORCH_EXT_LANE) != 0u;
+#else
+    return false;
+#endif
+}
+
+// MONKEY (Phase 5): the cube face that contains direction `d` (fixture → fragment) — the major
+// axis, signed. The face order is the contract with `benilla_app::torch_shadow::cube_view_projs`:
+// 0 +X, 1 −X, 2 +Y, 3 −Y, 4 +Z, 5 −Z. Each face is a 90°(+ε) frustum down that axis, so the face
+// holding the major axis always contains the direction.
+fn torch_face(d: vec3<f32>) -> u32 {
+    let a = abs(d);
+    if (a.x >= a.y && a.x >= a.z) {
+        return select(1u, 0u, d.x > 0.0);
+    }
+    if (a.y >= a.z) {
+        return select(3u, 2u, d.y > 0.0);
+    }
+    return select(5u, 4u, d.z > 0.0);
+}
+
+// This fixture's OWN cast shadow: correlate the `wow_light` fixture at `light_pos` to a
+// promoted torch (position match within 1 yd), pick the cube face facing the fragment, and sample
+// that layer. 1.0 (unshadowed) when no map matches, or when TORCH_SHADOWS is off (wow_model's copy
+// of the caller never sets it).
+//
+// MONKEY (outdoor torch shadows): `fade_radius` selects the FAR FADE, and it is the ONLY difference
+// between the interior and exterior lanes here — the correlation, the face pick, the live-bank
+// compaction and the slot cross-fade are one body because a shadow map does not know which lane
+// promoted it. `0` = the interior/legacy `ndc.z` fade, unchanged bit-for-bit; `> 0` = the exterior
+// world-distance fade `1 − smoothstep(0.8R, R, d)` measured from the FIXTURE (not from the camera:
+// this is "how far does this fire's shadow carry", a property of the fire).
+// MONKEY (slope bias): `N` rides along purely so the projector can bias against the RECEIVER'S
+// PLANE. `P` is the already-offset point, `N` the normal it was offset along, and this function
+// makes no other use of it - the correlation, the face pick and the fades are unchanged.
+fn torch_map_at(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>, fade_radius: f32) -> f32 {
+#ifdef TORCH_SHADOWS
+    // MONKEY (torch lane perf): the whole table is empty far more often than not (no promoted
+    // fixture in range, or the lane switched off while the shader-def is still compiled in). Say so
+    // once, up front, so the caller pays one uniform read rather than a loop set-up per fixture.
+    if (torch_table.count.x == 0u) {
+        return 1.0;
+    }
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        // MONKEY (static torch cache): holes and pending uploads never sample stale layers.
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let fixture = torch_table.positions[i].xyz;
+        if (distance(fixture, light_pos) < 1.0) {
+            let face = torch_face(P - fixture);
+            let layer = i * 6u + face;
+            // MONKEY (live bank rank): count.z is CPU-ready-filtered; holes must not consume
+            // live cubes. Keep the projection on the static slot while compacting depth only.
+            let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+            let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+            // MONKEY (outdoor torch shadows): negative = "use your own ndc fade" (the interior
+            // contract). The exterior weight is computed HERE because only this scope knows both
+            // the fixture and the fragment.
+            let fade = select(
+                -1.0,
+                1.0 - smoothstep(0.8 * fade_radius, fade_radius, distance(fixture, P)),
+                fade_radius > 0.0,
+            );
+            let s = shadow_hook::torch_map_shadow(
+                torch_table.view_projs[layer], i32(depth_layer), P, N, torch_depth, torch_samp,
+                TORCH_BIAS, torch_soft(), fade);
+            // MONKEY (torch caster selection): `.w` is the slot's FADE WEIGHT. A slot ramps 0 -> 1
+            // over ~1/3 s when it is promoted and 1 -> 0 before it is reused, and `mix` turns that
+            // into the shadow appearing/dissolving instead of switching. Without it the selection
+            // churn in a candle-dense room (Northshire's 42 candelabra, 5 yd apart) reads as
+            // shadows popping on and off as you walk - the bug this lane exists to fix.
+            // MONKEY (shadow floor): and `torch_strength()` is the DIRECT-term floor folded
+            // into that same weight (see the function). `w * strength` rather than a second `mix`
+            // because the two are the same expression.
+            return mix(1.0, s, torch_table.positions[i].w * torch_strength());
+        }
+    }
+#endif
+    return 1.0;
+}
+
+// The INTERIOR lane's call — unchanged behaviour (`fade_radius 0` ⇒ the reverse-Z `ndc.z` fade).
+// MONKEY (surface normal offset): `N` is the LIT normal of the receiving fragment, and the offset
+// point is what gets projected, face-picked and compared — exactly as `terrain.wgsl`'s
+// `torch_terrain_shadow` and `wow_model.wgsl`'s `torch_entity_shadow_at` already do (both offset
+// BEFORE `torch_face`, so a fragment right on a cube-face boundary picks the same face its
+// neighbour does). See TORCH_NORMAL_OFFSET for the texel-vs-bias arithmetic this is the answer to.
+fn torch_surface_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+    return torch_map_at(light_pos, P + N * TORCH_NORMAL_OFFSET, N, 0.0);
+}
+
+// MONKEY (outdoor torch shadows): the EXTERIOR lane's call — the campfire/brazier/lamppost pool on
+// a WMO's outdoor-class surfaces and on exterior doodads.
+// MONKEY (surface normal offset): the same 0.15 yd normal offset as the interior lane and the
+// terrain/entity receivers — an outdoor WMO floor under a low fire (a campfire on a porch) has the
+// same grazing-angle PCF acne as the imp's floor; see TORCH_NORMAL_OFFSET for the arithmetic.
+fn torch_exterior_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+    return torch_map_at(light_pos, P + N * TORCH_NORMAL_OFFSET, N, TORCH_EXT_FADE_YD);
+}
+
+// MONKEY (torch debug, interiorDebug 2): the MIN raw depth-map shadow factor over EVERY promoted map
+// (ignores the fixture-position match), so the map's actual content is visible as greyscale on the
+// floor: all-WHITE = maps empty / projection misses the fragment; uniform GREY = self-shadow/bias;
+// SHAPED dark regions = real occlusion is being captured (then the fix is correlation/placement).
+// MONKEY (surface normal offset): the overlay projects the SAME offset point the lit path does, or
+// it would show acne the render no longer has (and hide acne it does).
+fn torch_debug_factor(P: vec3<f32>, N: vec3<f32>) -> f32 {
+#ifdef TORCH_SHADOWS
+    let Ps = P + N * TORCH_NORMAL_OFFSET;
+    var s = 1.0;
+    for (var i = 0u; i < torch_table.count.x; i = i + 1u) {
+        if (torch_table.positions[i].w <= 0.0) { continue; }
+        let face = torch_face(Ps - torch_table.positions[i].xyz);
+        let layer = i * 6u + face;
+        // MONKEY (live bank rank): debug samples the same compact bank as the lit path.
+        let rank = countOneBits(torch_table.count.z & ((1u << i) - 1u));
+        let depth_layer = select(layer, 96u + 6u * rank + face, (torch_table.count.z & (1u << i)) != 0u);
+        // MONKEY (slope bias): same plane as the lit path, so `interiorDebug 2` stays honest.
+        let raw = shadow_hook::torch_map_shadow(
+            torch_table.view_projs[layer], i32(depth_layer), Ps, N, torch_depth, torch_samp,
+            TORCH_BIAS, torch_soft(), -1.0);
+        // MONKEY (torch caster selection): the WEIGHTED factor, so the debug view shows what the
+        // real render shows - a fading slot greys out here too, and a slot stuck at w = 0 (never
+        // ramping in) is visible as a map that contributes nothing.
+        s = min(s, mix(1.0, raw, torch_table.positions[i].w));
+    }
+    return s;
+#else
+    return 1.0;
+#endif
+}
+
 // ---- mirrored law (wow_model.wgsl) ----
 
 fn wow_normalize(v: vec3<f32>) -> vec3<f32> {
@@ -108,43 +532,733 @@ fn wow_normalize(v: vec3<f32>) -> vec3<f32> {
     return select(vec3<f32>(0.0), normalize(v), l2 > 1e-12);
 }
 
-fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
+// MONKEY (outdoor torch shadows): the ≤`EXT_SEL_K`-nearest EXTERIOR selection, packed into FOUR
+// u32s as twelve 8-bit indices (rank 0 in the low byte of `.x`), `EXT_SEL_EMPTY` for an unfilled
+// rank.
+//
+// WHY the selection is packed and TRAVELS from the vertex stage: the exterior point term is chosen
+// per VERTEX (the reference FFP's own granularity, and — on a WMO's outdoor-class surfaces —
+// anchored at the MCNK CELL so a street and the road it runs into rank the same lights and agree
+// at the seam, see `wmo_exterior_point_sum`). The per-FRAGMENT shadowed term must use exactly
+// THAT selection: re-ranking per fragment would put a hard line across the cobbles at every cell
+// boundary, where the interpolated vertex term has none. So the vertex stage publishes its choice
+// and the fragment stage only re-EVALUATES it (and shadows it).
+//
+// MONKEY (ext light k12) - **WHY K WENT 3 -> 8.** Three is the reference FFP's own commit limit (GL
+// slots 1-3; wow-re `wmo-surface-dynamic-light` sections 4/6) and it was the right number for the
+// reference's SPARSE, hand-authored light set: with two or three authored lights in a village the
+// nearest three IS all of them, and no two draw units can disagree. benilla does not have that set
+// - `fire_light.rs` SYNTHESISES a point light for every torch, lantern, brazier and campfire
+// GameObject/doodad in range, so a lamp-lit set piece now puts 15+ exterior fixtures inside ONE
+// chunk's candidacy box (measured at the Darkmoon Faire: 12 `Free Standing Torch 01` + 3
+// `General Lantern 01` within reach of the player's chunk, plus a stall lamp and the fireworks'
+// spell lights). Once the candidates outnumber the slots, adjacent draw units keep DIFFERENT
+// threes; and because the boundary between draw units is a straight line - an MCNK cell edge, or
+// the jump from a cell-anchored chunk to the origin-anchored bench standing on it - the
+// disagreement reads as a HARD STRAIGHT EDGE across a torch's pool of light (the director's
+// "scars"), and as a bench lit by a firework over ground that is not. More slots make neighbouring
+// units AGREE, so a pool ends where the FALLOFF ends instead of where the cell does; the only open
+// question is how many is enough, and the next paragraph answers it with the measurement.
+//
+// 8 bits per rank caps the LIVE table at 255 real entries, `EXT_SEL_EMPTY` = 255 being the
+// sentinel; `global_light::MAX_LIVE_POINT_LIGHTS` enforces that CPU-side. The buffer still carries
+// 256 slots, so `LightStd430` keeps its 8528 B and no mirror struct moves.
+//
+// MONKEY (ext light k12) - **AND WHY 8 -> 12, one round later.** Eight was MARGINAL the day it
+// landed and the note here said so. The Darkmoon Faire's densest chunk holds THIRTEEN candidates
+// and EIGHT of them stand strictly inside its own 33.33 yd cell, so a torch 2.5 yd outside the edge
+// - lighting the grass right at the seam - cannot win a slot under any ranking, and that chunk goes
+// on disagreeing with its neighbour about it. On that particular seam K=8 did not help, it made
+// things WORSE (0.198 -> 0.356 of a falloff unit): raising K let the SPARSE neighbour take in
+// lights the dense chunk still had no room for, so the two sets grew further apart, not closer.
+// Twelve is the first K at which every chunk around the player keeps everything it can see bar one:
+//
+//   worst ABSOLUTE seam jump, the four chunks meeting at the corner nearest WoW (-9557, 99)
+//   (`k12_table.py` in the scratchpad; falloff units, colour and N.L factored out, the byte-verified
+//   `1/(0.7d + 0.03d^2)`, 200 samples along each shared edge)
+//     seam                     cands      K=3      K=8     K=12     K=16
+//     (-288,2)|(-288,3)         6 | 2   0.0418   0.1117   0.1117   0.1117
+//     (-288,2)|(-287,2)        6 | 13   0.6425   0.0882   0.0669   0.1281
+//     (-288,3)|(-287,3)         2 | 7   0.2888   0.0862   0.0862   0.0862
+//     (-287,2)|(-287,3)        13 | 7   0.1980   0.3556   0.1144   0.1406
+//     WORST                            0.6425   0.3556   0.1144   0.1406
+//
+// Read the last two columns together. At K>=13 every chunk keeps ALL its candidates, so 0.1406 is
+// the CANDIDACY BOX's own floor - the residual disagreement two chunks have because their gather
+// boxes are centred 33 yd apart - and no K can touch it (widening the box is a separate change, and
+// it is the byte-verified one). K=12 measures 0.1144, slightly UNDER that floor, because the dense
+// chunk drops exactly one far candidate its neighbour also barely weights. So twelve ENDS this line
+// of attack: 16 is not better, only wider.
+//
+// The own-origin case in the same table - a bench standing on the ground, ranking from its own
+// position, against the chunk under it - goes 79 % / 71 % / 52 % apart at K=3, to 31 % / 27 % / 5 %
+// at K=8, to 3 % / 1 % / 5 % at K=12. That is the "bench lit by a firework over dark grass" closing.
+//
+// RAISING K FURTHER: `ext_sel_get` and the pack tail index the selection vector dynamically
+// (`sel[s >> 2u]`) and the rank arrays are zero-constructed and filled, so K is not spelled out
+// anywhere but here. The vector is `vec4<u32>` now and holds SIXTEEN rank slots, so K = 13..16 is
+// this constant ALONE - no type site, no interstage field, no `EXT_SEL_NONE` edit. Past 16 the next
+// step is a second `vec4<u32>` (four more interstage components) and `ext_sel_get` learning which
+// vector to read, which is a real change rather than a constant.
+const EXT_SEL_K: u32 = 12u;
+const EXT_SEL_EMPTY: u32 = 255u;
+// Twelve empty ranks. MONKEY (ext light k12): FOUR words - the vector holds sixteen 8-bit rank
+// slots and only the first `EXT_SEL_K` are ever read, so filling all four with the sentinel costs
+// nothing and leaves no word that could be mistaken for a real index if K is raised again. (The
+// PACK tail below builds its `vec4<u32>` from ZERO and writes only ranks 0..K-1, so its unused high
+// word reads as index 0 rather than the sentinel - harmless, because no loop here ever looks past
+// `EXT_SEL_K`.)
+const EXT_SEL_NONE: vec4<u32> = vec4<u32>(4294967295u, 4294967295u, 4294967295u, 4294967295u);
+
+// MONKEY (ext light k12): how many of the `EXT_SEL_K` ranks pay for a CUBE-MAP OCCLUSION lookup in
+// the night lane. The ranking is by distance, so ranks 0..2 are the three fixtures whose term
+// dominates this fragment; ranks 3..11 are the long tail that fixes the SELECTION (the scars) and
+// contribute a soft, low-amplitude wash where a hard-edged shadow would not be legible anyway.
+// Holding the shadowed count at the OLD K pins the per-fragment cost of the night lane at exactly
+// what it was - three table scans and their taps - while the selection itself gets twelve deep.
+const EXT_SEL_SHADOWED: u32 = 3u;
+
+// Unpack rank `s` (0..`EXT_SEL_K`-1) from the four-word selection. MIRRORED - keep in sync.
+fn ext_sel_get(sel: vec4<u32>, s: u32) -> u32 {
+    return (sel[s >> 2u] >> (8u * (s & 3u))) & 255u;
+}
+
+// The ranking half of the old `point_light_sum` — the EXTERIOR doodad/MODD-prop family, anchored
+// at the receiving unit's own origin. Same tests, same order, same tie handling (strictly-less
+// inserts, so an equal distance leaves the earlier table index at the better rank) so the sum can
+// be re-evaluated later against the identical choice.
+//
+// MONKEY (ext light k12): `box` is the draw unit's HORIZONTAL half-extent in yards, and it changes
+// what "nearest" MEANS - ranking is by the distance from the light to the unit's AABB, not to the
+// unit's anchor POINT. A cell-anchored unit (terrain's 33.33 yd MCNK chunk, clutter, an
+// exterior-class WMO street) passes `MCNK_CELL_HALF`: a torch standing 2 yd outside a cell's edge
+// is 2 yd from the nearest surface that cell draws, yet ~18 yd from its CENTRE, which is how it
+// used to lose its slot to three torches clustered near the middle while lighting nothing of the
+// ground right under it. Clamping the light into the box (`max(|d| - box, 0)` per horizontal axis)
+// ranks it the way the surface actually sees it, and - the point of the exercise - makes two
+// ADJACENT cells rank a light on their shared edge almost identically, so their sets agree there.
+// The VERTICAL stays unbounded, exactly as the reference's hash sweep is. `box = 0` reproduces the
+// old point-anchored ranking BIT-FOR-BIT, and that is what the own-origin units (props, entities)
+// pass, so nothing on those lanes moves.
+//
+// CANDIDACY deliberately stays on the anchor POINT (`dc2` below): it is the byte-verified gather
+// test, and widening it is a different question from how the survivors are ordered.
+fn point_light_pick(anchor: vec3<f32>, box: f32) -> vec4<u32> {
     let count = u32(wow_light.point_count.x);
-    var sel = array<u32, 3>(0u, 0u, 0u);
-    var sd = array<f32, 3>(1e30, 1e30, 1e30);
+    var sel = array<u32, EXT_SEL_K>();
+    var sd = array<f32, EXT_SEL_K>();
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        sd[s] = 1e30;
+    }
     for (var i = 0u; i < count; i = i + 1u) {
-        let pos_range = wow_light.points[2u * i];
-        let dv = pos_range.xyz - anchor;
-        let d2 = dot(dv, dv);
-        if (d2 > pos_range.w * pos_range.w) {
+        // MONKEY (light lanes): skip INTERIOR fixtures (colour row `.w > 0.5`) — mirrored from
+        // wow_model.wgsl. This is the EXTERIOR doodad/MODD-prop family (a WMO surface takes
+        // `wmo_exterior_point_sum` or nothing), so a building's own fixtures must not reach it — the
+        // warm pool on the grass at the foot of the inn's wall. Skipped before the ≤`EXT_SEL_K`
+        // ranking, so an interior fixture cannot take a slot an outdoor fire should have had.
+        if (wow_light.points[2u * i + 1u].w > 0.5) {
             continue;
         }
-        if (d2 < sd[0]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = sd[0]; sel[1] = sel[0];
-            sd[0] = d2; sel[0] = i;
-        } else if (d2 < sd[1]) {
-            sd[2] = sd[1]; sel[2] = sel[1];
-            sd[1] = d2; sel[1] = i;
-        } else if (d2 < sd[2]) {
-            sd[2] = d2; sel[2] = i;
+        let pos_range = wow_light.points[2u * i];
+        let dv = pos_range.xyz - anchor;
+        let dc2 = dot(dv, dv);
+        if (dc2 > pos_range.w * pos_range.w) {
+            continue;
+        }
+        // MONKEY (ext light k12): rank by the distance to the draw unit's BOX (see the header
+        // note). With `box = 0` both `max`es are identities and this is exactly the old `dc2`.
+        let e = max(abs(dv.xz) - vec2<f32>(box), vec2<f32>(0.0));
+        let d2 = dot(e, e) + dv.y * dv.y;
+        // MONKEY (ext light k12): an `EXT_SEL_K`-deep insertion in place of the hand-unrolled
+        // 3-deep cascade. Both loops are bounded by a module const, so the compiler unrolls them;
+        // the comparison is strictly-less, which keeps the old tie order (first-found wins).
+        //
+        // The guard on the WORST kept rank first: `sd` is sorted, so a candidate that cannot beat
+        // `sd[K-1]` cannot beat anything, and the scan below would walk all eight slots only to
+        // decide that. It makes the REJECT path - which is what nearly every table entry takes once
+        // the set is full - ONE comparison, i.e. cheaper than the three the old cascade spent, so
+        // widening K did not make the common case more expensive. Exactly equivalent to letting the
+        // scan run: `d2 >= sd[K-1]` is precisely the condition under which it returns `r = K`.
+        if (d2 >= sd[EXT_SEL_K - 1u]) {
+            continue;
+        }
+        var r = EXT_SEL_K;
+        for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+            if (d2 < sd[s]) {
+                r = s;
+                break;
+            }
+        }
+        if (r < EXT_SEL_K) {
+            for (var s = EXT_SEL_K - 1u; s > r; s = s - 1u) {
+                sd[s] = sd[s - 1u];
+                sel[s] = sel[s - 1u];
+            }
+            sd[r] = d2;
+            sel[r] = i;
         }
     }
+    // Pack low-byte-first, `EXT_SEL_EMPTY` for a rank nothing reached. No real index can collide
+    // with the sentinel: the live table caps at 255 (`MAX_LIVE_POINT_LIGHTS`).
+    var packed = vec4<u32>(0u, 0u, 0u, 0u);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = select(EXT_SEL_EMPTY, sel[s], sd[s] <= 9.9e29);
+        packed[s >> 2u] |= idx << (8u * (s & 3u));
+    }
+    return packed;
+}
+
+// The evaluation half — the byte-verified falloff `1/(0.7d + 0.03d²)` × `max(N·L, 0)` × the
+// committed colour, in rank order, stopping at the first empty rank exactly as the old
+// `sd[s] > 9.9e29` break did. Shared by both pickers (their sum loops were already identical).
+// MONKEY (ext light k12): up to `EXT_SEL_K` terms now, still Gouraud (per vertex) and still linear
+// in the falloff, so nothing about the day lane's FORM changed — a unit simply stops dropping the
+// fixtures its neighbour kept.
+fn point_light_eval(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
     var sum = vec3<f32>(0.0);
-    for (var s = 0u; s < 3u; s = s + 1u) {
-        if (sd[s] > 9.9e29) {
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
             break;
         }
-        let pos_range = wow_light.points[2u * sel[s]];
-        let to_light = pos_range.xyz - P;
+        let to_light = wow_light.points[2u * idx].xyz - P;
         let d = length(to_light);
         let atten = 1.0 / (0.7 * d + 0.03 * d * d);
         let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
-        sum += wow_light.points[2u * sel[s] + 1u].rgb * (atten * nl);
+        sum += wow_light.points[2u * idx + 1u].rgb * (atten * nl);
     }
     return sum;
 }
 
+// MONKEY (outdoor torch shadows): the SHADOWED evaluation — the same entries the vertex picked,
+// each multiplied by its OWN fixture's cube-map occlusion, so a crate between the fragment and
+// campfire A darkens A's term while lamppost B's is untouched. Per fixture, exactly as the interior
+// lane is (this is the same argument one lane over: a single scene-wide shadow factor cannot
+// express "shadowed from one fire, lit by another", which is what a village square at night
+// actually looks like). Reached only under `torch_ext_on()`, so nothing here executes in daylight
+// or with `exteriorShadows 0`.
+//
+// MONKEY (ext light k12): the SUM runs to `EXT_SEL_K`, but only the first `EXT_SEL_SHADOWED` ranks
+// pay for an occlusion lookup, so the per-fragment cost of this lane is pinned at exactly what it
+// was before the widening while the selection itself got twelve deep. Ranks 3..11 are the
+// distance-ordered tail — the terms that make a torch's pool agree across a draw-unit boundary —
+// and they arrive unshadowed, which at their amplitude is not a look the eye can separate from a
+// shadowed one.
+fn point_light_eval_shadowed(sel: vec4<u32>, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = ext_sel_get(sel, s);
+        if (idx == EXT_SEL_EMPTY) {
+            break;
+        }
+        let fixture = wow_light.points[2u * idx].xyz;
+        let to_light = fixture - P;
+        let d = length(to_light);
+        let atten = 1.0 / (0.7 * d + 0.03 * d * d);
+        let nl = max(dot(N, to_light / max(d, 1e-4)), 0.0);
+        // MONKEY (torch lane perf): same argument as the interior lane's guard one screen up — the
+        // occlusion is a factor on a term that is already zero on any surface facing away from the
+        // fire, and the scan + four taps are the expensive half of this loop body.
+        let ext_w = atten * nl;
+        var occ = 1.0;
+        if (s < EXT_SEL_SHADOWED && ext_w > TORCH_SKIP_EPS) {
+            occ = torch_exterior_shadow(fixture, P, N);
+        }
+        sum += wow_light.points[2u * idx + 1u].rgb * (ext_w * occ);
+    }
+    return sum;
+}
+
+fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
+    return point_light_eval(point_light_pick(anchor, 0.0), P, N);
+}
+
+// MONKEY (wmo exterior points): the EXTERIOR-lane point term for a WMO's OUTDOOR-class surfaces —
+// Stormwind's cobbles, its city walls, an inn's porch: every group whose MOGP flags carry `0x48`
+// (`WORD_INTERIOR` clear). Until now those took NO point term at all: the vertex stage zeroed
+// `point_lit` for every `WORD_WMO` batch, because the reference really does zero it on the surfaces
+// it lights with the MOCV bake — but that finding is about INTERIOR groups (wow-re
+// `trace-forensics-abbey-interior-d3d` §2 measured abbey rooms). An exterior-class group is drawn
+// by the exterior law, the same law terrain is drawn by, and terrain takes the point term. The
+// symptom of the over-broad zero: a Trade District wall torch at night lit the NPC beside it (an
+// M2, on `wow_model.wgsl`'s lane) and the dirt road at the gate (terrain), but not one cobble of
+// the street it hangs over.
+//
+// It is `terrain.wgsl`'s `point_light_sum` semantics DELIBERATELY, not this file's own:
+//  · the anchor is the **MCNK cell centre** ([`mcnk_cell_anchor`]), not the batch's baked
+//    placement anchor. A WMO's baked anchor is its PLACEMENT origin — one point for the whole of
+//    Stormwind — so a nearest-K ranked from it would commit the same few lights to every street
+//    in the city. The 33.33 yd cell is the unit terrain uses, so the road and the street it runs
+//    into rank the SAME candidates and agree at the seam, which is the whole requirement.
+//  · candidacy is terrain's Chebyshev box `TERRAIN_REACH`, not this file's 48 yd sphere, for the
+//    same agreement reason (and because it is the byte-verified gather — see `terrain.wgsl`).
+// Cost: one bounded pass over the ≤256-entry table per VERTEX (never per fragment), the same walk
+// the doodad lane beside it already pays. Gated only on the table's contents — the exterior lane
+// is independent of `interiorLight`, and an empty/daytime table makes it exactly zero. Additive
+// into the clamped `primary` sum, so a fully sunlit street cannot brighten past white: daytime is
+// materially unchanged, exactly as on terrain.
+//
+// MIRRORED verbatim in `wow_model.wgsl` (which keeps its own `mcnk_cell_anchor`) — the small
+// minority of WMO batches the retained collector declines (env-mapped, depth-flag oddities) falls
+// through to the entity path, and a street lit on one pipeline and black on the other is worse
+// than either. Keep the two bodies identical.
+const WMO_EXT_REACH: f32 = 33.570166;
+fn mcnk_cell_anchor(P: vec3<f32>) -> vec3<f32> {
+    let cell = 533.33333 / 16.0;
+    let half = 32.0 * 533.33333;
+    let ix = floor((half + P.x) / cell);
+    let iz = floor((half + P.z) / cell);
+    return vec3<f32>((ix + 0.5) * cell - half, P.y, (iz + 0.5) * cell - half);
+}
+
+// MONKEY (ext light k12): the MCNK cell's HORIZONTAL half-extent (yd) - the `box` a cell-anchored
+// draw unit ranks by. The same grid constant as above, halved: 533.33333/16/2 = 16.666666. An
+// own-origin unit passes 0 instead. MIRRORED in terrain.wgsl - keep in sync.
+const MCNK_CELL_HALF: f32 = 533.33333 / 32.0;
+// MONKEY (outdoor torch shadows): the ranking half, split out for the same reason as
+// `point_light_pick` — the fragment stage must re-evaluate the VERTEX's choice, not make its own.
+fn wmo_exterior_pick(P: vec3<f32>) -> vec4<u32> {
+    let anchor = mcnk_cell_anchor(P);
+    let count = u32(wow_light.point_count.x);
+    var sel = array<u32, EXT_SEL_K>();
+    var sd = array<f32, EXT_SEL_K>();
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        sd[s] = 1e30;
+    }
+    for (var i = 0u; i < count; i = i + 1u) {
+        // Exterior lane only: an interior fixture's `.w` is its reach (≥ 1), an exterior source's
+        // is 0. A building's own candles must not pool on the street outside its wall.
+        if (wow_light.points[2u * i + 1u].w > 0.5) {
+            continue;
+        }
+        let dv = wow_light.points[2u * i].xyz - anchor;
+        // Terrain's hash sweep is horizontal and unbounded vertically; the ranking below is the
+        // full 3-D distance, as `0x71bf90` does.
+        if (max(abs(dv.x), abs(dv.z)) > WMO_EXT_REACH) {
+            continue;
+        }
+        // MONKEY (ext light k12): rank by the distance to the MCNK cell's BOX, not to its centre -
+        // see `point_light_pick`. This is the term that makes a street and the road it runs into
+        // agree about a torch standing on the seam between them.
+        let e = max(abs(dv.xz) - vec2<f32>(MCNK_CELL_HALF), vec2<f32>(0.0));
+        let d2 = dot(e, e) + dv.y * dv.y;
+        // MONKEY (ext light k12): an `EXT_SEL_K`-deep insertion in place of the hand-unrolled
+        // 3-deep cascade. Both loops are bounded by a module const, so the compiler unrolls them;
+        // the comparison is strictly-less, which keeps the old tie order (first-found wins).
+        //
+        // The guard on the WORST kept rank first: `sd` is sorted, so a candidate that cannot beat
+        // `sd[K-1]` cannot beat anything, and the scan below would walk all eight slots only to
+        // decide that. It makes the REJECT path - which is what nearly every table entry takes once
+        // the set is full - ONE comparison, i.e. cheaper than the three the old cascade spent, so
+        // widening K did not make the common case more expensive. Exactly equivalent to letting the
+        // scan run: `d2 >= sd[K-1]` is precisely the condition under which it returns `r = K`.
+        if (d2 >= sd[EXT_SEL_K - 1u]) {
+            continue;
+        }
+        var r = EXT_SEL_K;
+        for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+            if (d2 < sd[s]) {
+                r = s;
+                break;
+            }
+        }
+        if (r < EXT_SEL_K) {
+            for (var s = EXT_SEL_K - 1u; s > r; s = s - 1u) {
+                sd[s] = sd[s - 1u];
+                sel[s] = sel[s - 1u];
+            }
+            sd[r] = d2;
+            sel[r] = i;
+        }
+    }
+    // Pack low-byte-first, `EXT_SEL_EMPTY` for a rank nothing reached. No real index can collide
+    // with the sentinel: the live table caps at 255 (`MAX_LIVE_POINT_LIGHTS`).
+    var packed = vec4<u32>(0u, 0u, 0u, 0u);
+    for (var s = 0u; s < EXT_SEL_K; s = s + 1u) {
+        let idx = select(EXT_SEL_EMPTY, sel[s], sd[s] <= 9.9e29);
+        packed[s >> 2u] |= idx << (8u * (s & 3u));
+    }
+    return packed;
+}
+fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    return point_light_eval(wmo_exterior_pick(P), P, N);
+}
+
+// MONKEY (dynamic interiors): the per-FRAGMENT room light for interior WMO surfaces AND interior
+// props — EVERY in-range light of the room-gated table, no nearest-3 selection (a per-fragment
+// selection swap draws a seam where the 4th light drops out). Two terms per light:
+//  · DIRECT — the reference's falloff × a WRAPPED Lambert, (N·L + wrap)/(1 + wrap): a hearth
+//    sitting at floor level is horizontal to the floor around it, and a hard max(N·L, 0) lights
+//    nothing there (the smithy only worked because its forges are raised) — times the fixture's
+//    AUTHORED ATTENUATION WINDOW (MONKEY, below).
+//  · FILL — a normal-free bounce, colour × K_FILL × (1 − d/reach)²: the "lamps everywhere" glow
+//    Blizzard's bake carried, sourced from the room's own fixtures instead of a constant. The
+//    colour is normalised for this term (the table commits RAW over-gamut colour × intensity),
+//    so one hot forge doesn't wash a whole room.
+// MONKEY (light lanes / interior attenuation): the loop is now over the INTERIOR half of the table
+// only (colour row `.w > 0.5`), and that same `.w` is each fixture's REACH in yards — its authored
+// MOLT attenuation end (M2 sources bucket by intensity), scaled live by `interiorAttenScale`. The
+// reach bounds the loop, shapes the fill, and drives the direct window. `interiorAttenScale 0`
+// packs the legacy 48 yd instead — under the soft profile below that is the widest, flattest pool
+// the lane can make, the nearest thing left to the pre-window flat lane (it is no longer the
+// byte-exact restore it was, because the window's SHAPE moved with it).
+// `torch_shadow` (the #2 lane, 1.0 when no torch is promoted) shades the direct term only —
+// bounce is indirect. A base ambient keeps a fixture-less nook from going black. The knobs are
+// LIVE cvars packed into `point_count.yzw` — `.y` base ambient, `.z` fill gain, `.w` exposure
+// (the callers' multiplier on the whole budget before the rolloff) — so
+// `/script SetCVar("interiorExposure", 2)` retunes a room without a rebuild. The fill is
+// half-desaturated: bounce off wood and stone is not candle-orange.
+const INTERIOR_WRAP: f32 = 0.5;
+// MONKEY (soft falloff): the interior pool's PROFILE — **keep this whole block byte-identical
+// between wow_model.wgsl and static_gx.wgsl.**
+//
+// The colour row's `.w` packs each fixture's EFFECTIVE RADIUS `R`: its authored MOLT
+// `attenuation_end` (an M2 source buckets by intensity instead) already multiplied by the live
+// `interiorAttenScale` (default 1.6). MONKEY (pool energy): the EXTENT terms — the direct window
+// and the fill span — are still written as fractions of `R`, so the cvar stays a pure zoom on how
+// far every pool REACHES; the core is not, so it is no longer also a brightness dial.
+//
+// The RETIRED profile was the reference's `1/(0.7d + 0.03d²)` windowed by
+// `1 − smoothstep(0.65R, R, d)` at `R` = the authored reach. That window closed a still-BRIGHT
+// curve — 0.28 of its 1 yd value at 0.65R — over the last 35 % of the radius, i.e. a bright disc
+// with a visible rim and black beyond it. That is the abbey candelabra ring. Three changes replace
+// it, and the ring cannot come back because the curve is already dim wherever the window bites:
+//  · CORE — `1/(1 + (d/r0)²)`: inverse square with a soft core. MONKEY (pool energy): `r0` is a
+//    CONSTANT `INTERIOR_CORE_YD` **yards**, not a fraction of `R` any more. It was `0.26·R`, and
+//    that tied a fixture's BRIGHTNESS to its REACH — the pool's total ENERGY grew as `R²`. The
+//    Goldshire inn's `R ≈ 11-15` fixtures therefore ran a 2.1× (at 3 yd) to 2.9× (at 5 yd) hotter
+//    curve than Northshire abbey's `R ≈ 7`; ten of them overlap in one room, the
+//    `1 − exp(−x·exposure)` rolloff saturated, and the inn read as one flat yellow while the
+//    abbey — whose pools the owner signed off — sat exactly where it should. Reach must BOUND a
+//    pool, not fuel it. So the energy is now one curve for every fixture and only the WINDOW and
+//    the fill span still scale with `R`: two fixtures of different reach read IDENTICALLY until
+//    the shorter one's window closes. `1.75 yd` is what the abbey already had (`0.26 × 6.7` — its
+//    median authored end 4.2 at the default `interiorAttenScale` 1.6), so the under-candle level
+//    the exposure was tuned against is preserved to within ±10 % across the abbey's own reach
+//    spread (−5 % at its median fixture) and nothing about the approved look moves.
+//  · GAIN — `INTERIOR_CORE_GAIN` normalises the core against the retired hyperbolic's 1 yd value,
+//    `1/(0.7 + 0.03) = 1.3699`. With a CONSTANT `r0` that normalisation is the same for every
+//    fixture instead of holding only at the median reach, which is the whole point; it lands at
+//    `1.5/(1 + (1/1.75)²) = 1.1308`, i.e. 0.83 × the hyperbolic — the abbey's own current level.
+//    (Gain 1.817 would restore 1.3699 exactly; that is a 21 % brighter room than the approved
+//    one, so it is deliberately NOT taken. Change the GAIN, never the core radius, to re-level.)
+//  · WINDOW — `(clamp01(1 − (d/R)^p))²`, the UE4-style windowing: value AND derivative both vanish
+//    at `d = R` (C1, so no rim), ≈1 over most of the radius, and it only ever removes energy the
+//    curve has already lost.
+// MONKEY (pool energy): the direct term (before the wrapped Lambert) at d = 1 / 3 / 5 / 8 / 12 yd,
+// abbey-class `R = 7` beside inn-class `R = 13` —
+//   was   R=7  1.152 / 0.403 / 0.164 / 0     / 0       R=13  1.379 / 0.839 / 0.470 / 0.224 / 0.033
+//   now   R=7  1.131 / 0.381 / 0.153 / 0     / 0       R=13  1.131 / 0.381 / 0.164 / 0.067 / 0.009
+// The two "now" rows are the SAME curve until R=7's window bites (where it is already down to
+// 0.15); R=13 only keeps a longer, dimmer TAIL, because its window is wider. That is the fix.
+//
+// FILL keeps its EXACT form (`(1 − d/r)²`, which is `interior_window(d, r, 1.0)`) and only widens:
+// its radius is `INTERIOR_FILL_SPAN·R`, so the floor BETWEEN two pools takes a gentle wash instead
+// of the bare ambient floor. Its value at the fixture is still 1, so `interiorFill` keeps the
+// meaning it was tuned with.
+const INTERIOR_CORE_YD: f32 = 1.75;
+const INTERIOR_CORE_GAIN: f32 = 1.5;
+const INTERIOR_DIRECT_POW: f32 = 10.0;
+const INTERIOR_FILL_SPAN: f32 = 1.5;
+const INTERIOR_FILL_POW: f32 = 1.0;
+// `(clamp01(1 − (d/r)^p))²`. The inner clamp keeps `pow` off a negative base; `max(r, …)` keeps it
+// off a zero divisor (the packer floors R at 1.0, but a shader must not lean on a producer's
+// invariant). `clamp(…, 0, 1)` rather than `saturate` — nothing else in this shader set uses
+// `saturate`, and the two are the same instruction.
+fn interior_window(d: f32, r: f32, p: f32) -> f32 {
+    let w = clamp(1.0 - pow(clamp(d / max(r, 1e-4), 0.0, 1.0), p), 0.0, 1.0);
+    return w * w;
+}
+// MONKEY (portal claims): the exterior-lane room term's distance gate (yd) — see its call site.
+const EXT_ROOM_FADE_START: f32 = 60.0;
+const EXT_ROOM_FADE_END: f32 = 90.0;
+// MONKEY (soft portal claims): 32, not 8 — six 4-word fade records follow the six ids. Keep in
+// sync with `benilla_world::lighting::{ROOM_CLAIM_STRIDE, ROOM_CLAIM_FADE, CLAIM_FADE_SCALE}`: a
+// stride that disagrees reads every fixture's claims out of a neighbour's record, and every
+// building in the frame goes dark (or floods) at once.
+const ROOM_CLAIM_STRIDE: u32 = 32u;
+const ROOM_CLAIM_MAX: u32 = 6u;
+const ROOM_CLAIM_FADE: u32 = 8u;
+const CLAIM_FADE_SCALE: f32 = 256.0;
+// MONKEY (portal claims): bit 16 of a packed claim word — "the EXTERIOR batch lane may honour this
+// claim". Keep in sync with `benilla_world::lighting::CLAIM_EXT_OK`; the group id (`group + 1`, 12
+// bits) lives below it, hence the mask.
+const CLAIM_EXT_OK: u32 = 65536u;
+// MONKEY (soft portal claims): bits 17..=24 of a claim word — the ENTRY weight as a byte. Keep in
+// sync with `benilla_world::lighting::CLAIM_ENTRY_SHIFT`.
+const CLAIM_ENTRY_SHIFT: u32 = 17u;
+const CLAIM_GROUP_MASK: u32 = 0xffffu;
+// MONKEY (room gate): may fixture `i` light a surface of room `(room_inst, room_group)`? Three
+// fail-OPEN arms, deliberately, because a wrong "no" is a black room while a wrong "yes" is only
+// the leak we already had: a fragment with no room key (`room_group == 0`), a fixture that claims
+// nothing (count 0 — an unclaimed MOLT fixture, or the whole gate switched off from `cvars`, which
+// simply packs every light that way), and any fixture whose claim list overflowed the table. Only
+// a fixture that positively claims SOME room of THIS building can be refused.
+//
+// MONKEY (portal claims): `strict` inverts all three of those arms, and it is what the EXTERIOR
+// batch lane passes. That lane is an ADDITION — an exterior-class group inside a building (the
+// inn's shell, its basement stairwell) is drawn by the night-sky law and gains its room's candle
+// light — so its wrong answers are the other way round: a wrong "yes" would light a whole city
+// street from a tavern candle through a wall, while a wrong "no" only leaves a surface exactly as
+// it renders today. So it fails CLOSED: no room key, no claims, another building's claim, or a
+// claim not marked [`CLAIM_EXT_OK`] (a district-scale shell) all mean "not this fixture".
+//
+// MONKEY (soft portal claims): the answer is a WEIGHT in [0, 1], not a yes/no — 1 admits the
+// fixture in full, 0 refuses it, and a PORTAL claim lands in between. The binary form is what put
+// the reported scar on the Lion's Pride Inn's upstairs floor: two groups meet mid-plank at the
+// doorway, the fixture was admitted at full strength on one side and refused outright on the
+// other, so the boards changed brightness along a straight line. Every fail-open/fail-closed arm
+// keeps its old meaning (1.0 / 0.0), so `interiorRoomGate 0` — which packs every fixture with
+// count 0 — is still exactly "ungated".
+//
+// The weight of a portal claim is `entry * (1 − smoothstep(0, radius, max(|P − center| − slack,
+// 0)))`: `entry` at the doorway itself, gone where the fixture's remaining reach runs out.
+// `slack` is the doorway's own bounding-sphere radius, and it is what makes the threshold
+// continuous: on the near side the fixture is admitted at 1 by CONTAINMENT, and on the far side
+// every fragment within the door frame measures distance 0 and is admitted at `entry` — which the
+// claim rule sets to exactly the weight the near side has there (1 off a base claim, the first
+// hop's decayed value off a first hop). Away from the frame the far side falls off smoothly, but
+// there the two sides are separated by a WALL rather than by continuous floor, so nothing reads as
+// a step.
+fn interior_room_admits(i: u32, room_inst: u32, room_group: u32, strict: bool, P: vec3<f32>) -> f32 {
+    if (room_group == 0u) {
+        return select(1.0, 0.0, strict);
+    }
+    let base = ROOM_CLAIM_STRIDE * i;
+    let n = room_claims[base + 1u];
+    if (n == 0u) {
+        return select(1.0, 0.0, strict);
+    }
+    // A different building's fixture never lights this one — one compare rejects a neighbouring
+    // inn's whole table, which is why the instance sits in the head word.
+    if (room_claims[base] != room_inst) {
+        return 0.0;
+    }
+    for (var k = 0u; k < min(n, ROOM_CLAIM_MAX); k = k + 1u) {
+        let claim = room_claims[base + 2u + k];
+        if ((claim & CLAIM_GROUP_MASK) == room_group && (!strict || (claim & CLAIM_EXT_OK) != 0u)) {
+            // A group appears at most once in a claim list (the rule dedupes), so the first match
+            // is the only one — no need to keep looking for a better weight.
+            let f = base + ROOM_CLAIM_FADE + 4u * k;
+            let packed = room_claims[f + 3u];
+            let radius = f32(packed & 0xffffu) / CLAIM_FADE_SCALE;
+            if (radius <= 0.0) {
+                return 1.0; // a HARD claim: the fixture stands in this room, or MOLR names it
+            }
+            let center = vec3<f32>(
+                bitcast<f32>(room_claims[f]),
+                bitcast<f32>(room_claims[f + 1u]),
+                bitcast<f32>(room_claims[f + 2u]),
+            );
+            let slack = f32(packed >> 16u) / CLAIM_FADE_SCALE;
+            let entry = f32((claim >> CLAIM_ENTRY_SHIFT) & 0xffu) / 255.0;
+            let d = max(distance(P, center) - slack, 0.0);
+            return entry * (1.0 - smoothstep(0.0, radius, d));
+        }
+    }
+    return 0.0;
+}
+// This region's building identity (the cell uniform's `.w` lane; 0 on a terrain cell). Carried as
+// a NUMBER, not as bits: an entity index is a small integer, and `f32::from_bits(12345)` is a
+// DENORMAL float that a driver flushing denormals to zero would silently collapse to 0 — every
+// building would then share identity 0. An f32 represents every integer below 2^24 exactly, which
+// is far above any live entity index, so the round trip is lossless and FTZ-proof; the packer
+// refuses to gate anything at or above that bound (see `assemble_region`).
+fn gx_room_inst() -> u32 {
+    return u32(cell.origin.w);
+}
+// This item's room key — `group + 1`, 0 when the item names no room (see RECORD_ROOM_SHIFT).
+fn gx_room_group(word: u32) -> u32 {
+    return (recs[word & 0xffffu].w >> RECORD_ROOM_SHIFT) & RECORD_ROOM_MASK;
+}
+// MONKEY (room gate): `room_inst`/`room_group` are the RECEIVING surface's room (see
+// `interior_room_admits`). `wow_model.wgsl`'s copy takes the same room arguments and stubs the
+// predicate to `true` — it has neither the claim binding nor a per-fragment room key, which is
+// also why it needs no `strict` (MONKEY, portal claims: only this file has an exterior WMO lane).
+// **The PROFILE block above stays byte-identical between the two files; the signature does not.**
+fn interior_room_light(
+    P: vec3<f32>,
+    N: vec3<f32>,
+    room_inst: u32,
+    room_group: u32,
+    strict: bool,
+) -> vec3<f32> {
+    let count = u32(wow_light.point_count.x);
+    let k_fill = wow_light.point_count.z;
+    var direct = vec3<f32>(0.0);
+    var fill = vec3<f32>(0.0);
+    for (var i = 0u; i < count; i = i + 1u) {
+        let color_lane = wow_light.points[2u * i + 1u];
+        // MONKEY (light lanes): only a fixture that CLAIMS a room lights this room (keep in sync
+        // with wow_model.wgsl). `.w` is 0 on every exterior source, so a campfire burning just
+        // outside the door stops reaching the floor inside it — the leak's other direction.
+        if (color_lane.w < 0.5) {
+            continue;
+        }
+        // MONKEY (room gate): and only a fixture that claims THIS ROOM lights this room's surfaces.
+        // Before this, the whole INT half of the table lit every interior fragment of every
+        // building in range and the only occlusion was the <=6 promoted cube-shadow casters — so an
+        // inn's ground-floor candles lit its basement THROUGH the floor, and an upstairs corridor
+        // wall glowed from the fixture in the room behind it. Tested here, before the distance
+        // test, because it is the term that throws away the most: a room claims one or two of the
+        // table's fixtures, not all of them.
+        // MONKEY (soft portal claims): `w` is the claim's WEIGHT, and it multiplies BOTH terms
+        // below. `wow_model.wgsl`'s copy of this loop keeps the old boolean stub (entities are
+        // ungated — it has neither the claim binding nor a per-fragment room key), which is the
+        // one place the two files' loop bodies deliberately differ; the PROFILE constants above
+        // stay byte-identical.
+        let w = interior_room_admits(i, room_inst, room_group, strict, P);
+        if (w <= 0.0) {
+            continue;
+        }
+        // MONKEY (soft falloff): `.w` is ALSO this fixture's EFFECTIVE RADIUS `R` in yards — the
+        // authored MOLT `attenuation_end` (or the M2 intensity bucket) already multiplied by the
+        // live `interiorAttenScale` at pack time. It replaces the flat 48 yd candidacy radius in
+        // `pos_range.w` on this lane, which is why the inn's 10 candles read as one uniform wash
+        // while the smithy's 3 forges read fine.
+        let reach_yd = color_lane.w;
+        // Candidacy is the FILL radius, not R: the wash reaches further than the direct pool (see
+        // the profile block), and rejecting at R would cut it off exactly at the pool's own edge —
+        // putting the rim back one term down.
+        let fill_yd = INTERIOR_FILL_SPAN * reach_yd;
+        let pos_range = wow_light.points[2u * i];
+        let to_light = pos_range.xyz - P;
+        let d2 = dot(to_light, to_light);
+        if (d2 > fill_yd * fill_yd) {
+            continue;
+        }
+        let d = sqrt(d2);
+        let c = color_lane.rgb;
+        // MONKEY (soft falloff): inverse square with the authored-start soft core, normalised so
+        // the 1 yd value is the retired hyperbolic's (profile block above).
+        // MONKEY (pool energy): a CONSTANT core radius in yards (profile block above) — the reach
+        // no longer scales the pool's brightness, only its window. `max` keeps the divide honest
+        // if the constant is ever tuned toward 0.
+        let r0 = max(INTERIOR_CORE_YD, 1e-3);
+        let atten = INTERIOR_CORE_GAIN / (1.0 + (d / r0) * (d / r0));
+        let window = interior_window(d, reach_yd, INTERIOR_DIRECT_POW);
+        let nl = max(
+            (dot(N, to_light / max(d, 1e-4)) + INTERIOR_WRAP) / (1.0 + INTERIOR_WRAP),
+            0.0,
+        );
+        // Normalised for BOTH terms: the table commits RAW over-gamut colour × intensity, and the
+        // smithy's three forges (1.4, 0.87, 0.4) drove the direct term to a washed-out white while
+        // the inn's unit candles sat where they should. The hue is what survives.
+        let c_norm = c / max(1.0, max(c.r, max(c.g, c.b)));
+        // Phase 1: this fixture's OWN cast shadow, sampled from its down-looking depth map
+        // (`torch_surface_shadow` correlates the fixture to its promoted map by position; 1.0 when
+        // it was not promoted). Per-fixture, so a pillar between the fragment and torch A darkens A's
+        // term without touching torch B's — the occlusion that makes an interior read
+        // lit-and-shadowed instead of flat. (`static_gx.wgsl` only; the wow_model copy of this
+        // function keeps the 1.0 `torch_shadow_for` stub — it has no group 3.)
+        // MONKEY (torch lane perf): the shadow sample is MULTIPLIED into the direct term, so
+        // where that term is already nothing the table scan and its four comparison taps buy
+        // nothing. And it very often is: `window` is exactly 0 past the fixture's reach, `nl` is 0
+        // on a surface facing away even under the wrap, and `w` is the claim weight a portal fade
+        // has taken to 0. The scan is by POSITION over up to sixteen slots, so this is the
+        // difference between "every interior fixture in range pays a scan on every fragment it
+        // touches" and "only the ones actually lighting it do". A branch rather than a `select`
+        // deliberately: the whole point is to NOT execute the taps.
+        let direct_w = atten * nl * window;
+        var s = 1.0;
+        if (direct_w * w > TORCH_SKIP_EPS) {
+            s = torch_surface_shadow(pos_range.xyz, P, N);
+        }
+        direct += c_norm * direct_w * s * w;
+        // MONKEY (soft falloff): the fill's profile is UNCHANGED in FORM — `(1 − d/r)²`, which is
+        // exactly `interior_window(d, r, 1.0)` — and only its radius moved, from R to
+        // `INTERIOR_FILL_SPAN·R`. That is the whole "gentle wash between the pools": at the fixture
+        // it is still 1 (so `interiorFill` keeps its tuned meaning) and it decays to 0 at 2R with a
+        // vanishing derivative, so the floor half-way between two candles is dim, not black.
+        let c_fill = mix(c_norm, vec3<f32>(dot(c_norm, vec3<f32>(0.299, 0.587, 0.114))), 0.5);
+        // The DOMINANT fixture's fill, not the SUM: an ambient room glow must not scale with the
+        // candle count, or a dense room (the inn's ~10 fixtures vs the smithy's 3) piles fill up
+        // until the rolloff saturates every surface to a flat white. `max` keeps the nearest/
+        // brightest fixture's glow and leaves the direct term to carry the per-fixture relief.
+        fill = max(fill, c_fill * (k_fill * interior_window(d, fill_yd, INTERIOR_FILL_POW) * w));
+    }
+    // Fill is INDIRECT bounce, so it is not shadowed; direct already carries each fixture's shadow.
+    // MONKEY (shell candle add): STRICT callers want only the claimed DIRECT + FILL. The shell
+    // already has sky ambient; returning the raw budget here also avoids adding then subtracting
+    // that floor (cancellation would lose weak fixtures). Non-strict room lighting is unchanged.
+    if (strict) {
+        return direct + fill;
+    }
+    return direct + fill + vec3<f32>(wow_light.point_count.y);
+}
+
+// MONKEY (trans blend continuity): the day blend's "never darker than the room law" guard, as a
+// C1-CONTINUOUS maximum instead of a per-channel `max`.
+//
+// THE BUG IT FIXES, measured on the Lion's Pride Inn's vestibule floor (`GoldshireInn` g0 batch b0 -
+// 8 TRANS triangles - rendered off `benilla-extract wmolights --verts 0` at 0.05 yd with this file's
+// exact interior-lane arithmetic at the owner's live cvars):
+//
+//   `max(room_rgb, rgb)` is evaluated PER CHANNEL, so the room law and the sunlit reference cross at
+//   a DIFFERENT place in R, in G and in B. Each crossing is continuous in value and BROKEN in its
+//   first derivative, and each is therefore a Mach line - three of them, at three different places,
+//   with the colour stepping warmer across each (the fragments between two loci have one channel on
+//   the reference and two on the room law, which is a hue no law in the shader ever asks for).
+//   The BLUE locus is the reported scar: a line from the door's south jamb running diagonally into
+//   the floor and dying near the middle -
+//       08:20  (20.30, -1.23) -> (15.16, -4.33)   jump 0.1595/yd = 32.5 %/yd at a level of 0.491
+//       noon   (19.96, -0.83) -> (15.68, -4.68)   jump 0.1594/yd = 28.6 %/yd at a level of 0.557
+//   with GREEN a second, shorter line nearer the door and RED crossing only at 08:20 (which is why
+//   the scar is worse in the morning than at noon). The wedge between the blue and green loci reads
+//   lighter and less warm than the floor beyond it (mean 0.621 lum / R:B 1.206 against 0.415 / 1.280
+//   at 08:20) - the "wedge on one side" of the report.
+//   That these are TRUE C1 breaks and not the light pool's own curvature is settled by halving the
+//   sample step: a break's |d2| scales as 1/h (2.25 -> 4.49 -> 8.93 /yd^2 at 0.05 / 0.025 / 0.0125 yd)
+//   while a smooth arc's does not.
+//
+// WHY THIS SHAPE. Three laws were measured against the same floor:
+//   (1) pick by LUMINANCE (one achromatic locus, all three channels switch together) - still a hard
+//       C1 break, and the colour step across it gets WORSE, not better (hue step 16.7 / 20.0 against
+//       the shipped 14.5 / 12.1 at 08:20 / noon): concentrating three small hue jumps into one big
+//       one is the wrong direction.
+//   (2) THIS - a quadratic smooth-max of half-width `TRANS_SMAX_W`. The selector disappears outright:
+//       the function is C1 everywhere, so there is no locus left to draw a line at. Costs at most
+//       0.0087 (08:20) / 0.0085 (noon) of display luminance against the shipped result - under 1 %,
+//       and under a single 8-bit code over most of the floor.
+//   (3) drop the `max` and `mix` straight to the reference - the same clean derivative, but it
+//       re-opens the subtraction the `max` was added against: it renders this floor up to 0.0811 x tex
+//       (11.0 %) DARKER at 08:20, 4.7 % at noon and 3.0 % at 20:00, because the room law is above the
+//       reference over the whole area the p0 daylight fixture actually reaches.
+//
+// It OVERSHOOTS rather than undershoots, deliberately and by at most `w/4` (0.0125): a C1 function
+// that equals `max` outside a band must do one or the other inside it, and undershooting would dip
+// BELOW `room_rgb` - which is precisely the "the blend may only ever brighten" invariant the outer
+// `max` and the night floor exist to hold. `smax >= max(a, b) >= room_rgb` still holds here.
+//
+// NIGHT IS BIT-IDENTICAL and not by argument: the whole selector is behind `day_w`, and
+// `mix(a, b, 0.0)` is `a * 1 + b * 0` = `a` exactly, whatever `b` is. Verified numerically against the
+// shipped law at `sun_w = 0` - max |difference| 0.000e+00 on every fragment of the floor.
+const TRANS_SMAX_W: f32 = 0.05;
+fn trans_smax(a: vec3<f32>, b: vec3<f32>) -> vec3<f32> {
+    let h = clamp(0.5 + 0.5 * (b - a) / TRANS_SMAX_W, vec3<f32>(0.0), vec3<f32>(1.0));
+    return a + (b - a) * h + TRANS_SMAX_W * h * (vec3<f32>(1.0) - h);
+}
+
+// MONKEY (shell candle add): candle irradiance lights the TEXTURE, not the authored MOCV shadow
+// bake. Give it the room lane's exposure rolloff, then fade the RESULT over 60..90 yd: fading the
+// raw budget before exp would change the pool's brightness profile with camera distance. The sky,
+// exterior points and SIDN keep their original law; only their remaining display headroom bounds
+// the addition. A hard zero guard keeps unclaimed/distant facades bit-identical, even by daylight.
+// `texture_rgb` is the sample BEFORE the MOCV fold: dividing folded black by 1/255 cannot recover
+// a texture on a zero-bake vertex. The reference path keeps its fold/divide arithmetic untouched.
+fn shell_candle_add(
+    sky_rgb: vec3<f32>,
+    texture_rgb: vec3<f32>,
+    room_raw: vec3<f32>,
+    far: f32,
+) -> vec3<f32> {
+    if (far <= 0.0 || all(room_raw <= vec3<f32>(0.0))) {
+        return sky_rgb;
+    }
+    let candle = vec3<f32>(1.0) - exp(-room_raw * wow_light.point_count.w);
+    return clamp(sky_rgb + texture_rgb * candle * far, vec3<f32>(0.0), vec3<f32>(1.0));
+}
+
 // ---- the pass ----
 
 struct GxVertex {
@@ -166,6 +1280,16 @@ struct GxVsOut {
     @location(3) @interpolate(flat) word: u32,
     @location(4) point_lit: vec3<f32>,
     @location(5) color: vec4<f32>,
+    // MONKEY (outdoor torch shadows; ext light k8): WHICH ≤`EXT_SEL_K` exterior table entries
+    // `point_lit` was summed from, packed 8 bits each across FOUR u32s (see `EXT_SEL_NONE` /
+    // `ext_sel_get`). FLAT, because it is a choice, not a quantity — interpolating packed indices
+    // would produce a different, meaningless one. `EXT_SEL_NONE` on every lane that takes no
+    // exterior point term (interior WMO surfaces, interior props, the collapsed exile vertex),
+    // which makes the fragment lane a no-op there by construction. Widened from ONE u32 of three
+    // 10-bit ranks to TWO u32s of eight 8-bit ranks and then to FOUR u32s of twelve — three extra
+    // interstage components in all (21 for this struct, against a 60-component limit) — see
+    // `EXT_SEL_K`.
+    @location(6) @interpolate(flat) ext_sel: vec4<u32>,
 }
 
 @vertex
@@ -183,6 +1307,7 @@ fn vertex(v: GxVertex) -> GxVsOut {
         out.word = v.word;
         out.point_lit = vec3<f32>(0.0);
         out.color = vec4<f32>(1.0);
+        out.ext_sel = EXT_SEL_NONE;
         return out;
     }
     // Camera-relative clip (0974/wow_model.wgsl): both addends are small — the recentred
@@ -205,16 +1330,38 @@ fn vertex(v: GxVertex) -> GxVsOut {
     out.uv = v.uv;
     out.word = v.word;
     out.color = v.color;
-    // The ≤3-nearest FFP selection, anchored at the PLACEMENT origin exactly like the entity
+    // The ≤`EXT_SEL_K`-nearest selection, anchored at the PLACEMENT origin exactly like the entity
     // path (the baked per-vertex anchor — 1429's parity note; the blob path coarsened this).
     // WMO surfaces take ZERO point lights — the entity path zeroes them in the vertex stage
     // (wow-re trace-forensics-abbey-interior-d3d §2: zero on every observed WMO surface) —
     // and so do interior M2 props (B4): their group-MOLR point lobes are folded into the
     // per-item SH probe at spawn, the entity path's own vertex-stage zeroing.
-    if ((v.word & (WORD_WMO | WORD_INTERIOR)) != 0u) {
+    if ((v.word & WORD_WMO) != 0u && (v.word & WORD_INTERIOR) != 0u) {
+        // INTERIOR WMO surfaces stay zero here, the reference's own vertex-stage zeroing. MONKEY
+        // (dynamic interiors): they light from the live torches PER-FRAGMENT in the fragment
+        // stage (`interior_room_light`) — a per-vertex sum on a WMO's huge floor triangles is
+        // Gouraud: straight-edged wedges, and a torch mid-triangle lights nothing.
         out.point_lit = vec3<f32>(0.0);
+        out.ext_sel = EXT_SEL_NONE;
+    } else if ((v.word & WORD_WMO) != 0u) {
+        // MONKEY (wmo exterior points): an EXTERIOR-class group (MOGP `& 0x48`) is a street, a
+        // courtyard, a porch — drawn by the exterior law, so it takes the exterior point term the
+        // terrain beside it takes. Its own anchor is the placement origin (one point for all of
+        // Stormwind), so `wmo_exterior_point_sum` re-anchors on the MCNK cell; see its comment.
+        // Per-vertex like terrain's, not per-fragment: WMO surfaces are MOCV-baked per vertex, so
+        // they carry the tessellation a Gouraud term needs, and this stays one bounded walk.
+        // MONKEY (outdoor torch shadows): the pick is published so the fragment stage can shadow
+        // this same selection at night without re-ranking (see `EXT_SEL_NONE`). One table walk
+        // still, not two — the sum was always `eval(pick(...))`, it is just no longer inlined.
+        let sel = wmo_exterior_pick(world);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, world, v.normal);
     } else {
-        out.point_lit = point_light_sum(world, v.normal, v.anchor);
+        // MONKEY (ext light k12): `box = 0` — an exterior doodad/MODD prop is its own draw unit and
+        // ranks from its baked PLACEMENT origin, exactly as it did before the widening.
+        let sel = point_light_pick(v.anchor, 0.0);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, world, v.normal);
     }
     return out;
 }
@@ -274,6 +1421,30 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
     // entity path removes (the first capture A/B lit every back-facing canopy card from the
     // wrong side — the felwood heatmap's bright clusters).
     let n_lit = wow_normalize(in.world_normal);
+    // MONKEY (outdoor torch shadows): the EXTERIOR point term, cast-shadowed at night.
+    //
+    // `in.point_lit` is the Gouraud (per-vertex) exterior sum, and it stays the ONLY thing this
+    // lane reads by day. After dark the same entries are re-evaluated PER FRAGMENT with each
+    // one's own cube-map occlusion folded in (`point_light_eval_shadowed`), and the two are blended
+    // by `night_w = 1 − sun_shadow_strength`. Two things fall out of writing it as a blend rather
+    // than a swap:
+    //   · `fog_params.z` is EXACTLY 1.0 whenever the sun is above the daylight threshold
+    //     (`global_light::sun_shadow_strength`, a smoothstep that saturates), so `night_w` is
+    //     exactly 0 and the `if` is not entered at all — daylight is the same instructions and the
+    //     same bits it was, not "a mix that ought to round back".
+    //   · at dusk the shadow arrives on the same clock the sun shadows leave on, and the
+    //     Gouraud→per-fragment change of the term itself arrives with it instead of snapping.
+    // `torch_ext_on()` is the CPU's one-bit verdict (`exteriorShadows` && night && ≥1 promoted
+    // exterior fixture), so with the cvar off the branch is dead too.
+    var point_lit = in.point_lit;
+    let ext_night_w = select(0.0, clamp(1.0 - wow_light.fog_params.z, 0.0, 1.0), torch_ext_on());
+    if (ext_night_w > 0.0) {
+        point_lit = mix(
+            in.point_lit,
+            point_light_eval_shadowed(in.ext_sel, in.world_position.xyz, n_lit),
+            ext_night_w,
+        );
+    }
     let L = -normalize(wow_light.light_sun.xyz);
     let ndotl = max(dot(n_lit, L), 0.0);
     let lit_nl = clamp(
@@ -281,6 +1452,43 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         vec3<f32>(0.0),
         vec3<f32>(1.0),
     );
+    // The retained path uses the same Bevy directional shadow map as terrain and entity models.
+    // `static_gx` used to have no mesh-view shadow bindings, which made every Stormwind WMO act
+    // as if shadows were disabled even though the caster map was populated.
+    // MONKEY (shadow hook): EXTERIOR surfaces take the directional sun shadow (fetch + edge/night
+    // fade, via `benilla::shadow_hook`) — now with the same fades as terrain + models. INTERIOR
+    // batches (`WORD_INTERIOR`) take the point-light (torch) shadow instead (#2): no sun reaches a
+    // sealed room, but a promoted torch does. Both are no-ops when their light source is absent.
+    var world_shadow = 1.0;
+    if ((in.word & WORD_INTERIOR) == 0u) {
+        let view_z = (view.view_from_world * in.world_position).z;
+        let cam_dist = distance(in.world_position.xyz, view.world_position.xyz);
+        world_shadow = shadow_hook::realtime_shadow(
+            in.world_position,
+            n_lit,
+            view_z,
+            cam_dist,
+            wow_light.wmo_fog_params.z,
+            wow_light.fog_params.z,
+        );
+    } else {
+        world_shadow = shadow_hook::torch_shadow(in.world_position, n_lit);
+    }
+    let shadow_term = mix(SHADOW_SUN_FLOOR, 1.0, world_shadow);
+    // Keep ambient energy when the realtime map blocks the sun. The retained pass also carries
+    // authored fixture/probe lighting, which must not be darkened by a directional shadow. The
+    // `world_shadow < 0.999` arm keeps `worldShadows 0` (no shadow-mapped light) and a fully
+    // sunlit fragment byte-identical: `ambient + (lit − ambient) × 1.0` is not guaranteed to
+    // round back to `lit`.
+    let lit_nl_shadowed = select(
+        lit_nl,
+        clamp(
+            wow_light.light_ambient.rgb + (lit_nl - wow_light.light_ambient.rgb) * shadow_term,
+            vec3<f32>(0.0),
+            vec3<f32>(1.0),
+        ),
+        world_shadow < 0.999,
+    );
     // The order-2 SH basis products over the fragment normal — shared by the exterior
     // doodad lobe and the interior-prop probe lane (wow_model.wgsl computes them once too).
     let quad = vec4<f32>(n_lit.x * n_lit.y, n_lit.y * n_lit.z, n_lit.z * n_lit.z, n_lit.x * n_lit.z);
@@ -307,12 +1515,14 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // WINDOW (MOMT 0x20) — interior drawer only: GL_LIGHT0 swapped to the brighter
         // Direct/Ambient midpoint pair, ambient +16/255 saturating (0x6d37e0).
         let window_mid = 0.5 * (wow_light.light_ambient.rgb + wow_light.light_diffuse.rgb);
-        let lit_window = clamp(
-            window_mid + vec3<f32>(16.0 / 255.0) + window_mid * ndotl,
+        // The window's directional half rides the sun, so it takes the shadow term (×1.0 exact
+        // when the caster is off — no identity guard needed on a pure multiply).
+        let lit_window_shadowed = clamp(
+            window_mid + vec3<f32>(16.0 / 255.0) + window_mid * ndotl * shadow_term,
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
-        let lit_int_base = select(lit_nl, lit_window, (in.word & WORD_WINDOW) != 0u);
+        let lit_int_base = select(lit_nl_shadowed, lit_window_shadowed, (in.word & WORD_WINDOW) != 0u);
         // The interior BATCH-CLASS lanes (trace-forensics-abbey-interior-d3d §2): INT = unlit
         // (the bake IS the room's light), TRANS = the per-vertex MOCV-alpha lit↔bake lerp,
         // EXT = plain lit_nl. Exterior groups take lit_nl at sun-scale 1 (prog 198/VS 151 —
@@ -323,7 +1533,11 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         } else if (!class_int) {
             lit_wmo_interior = lit_int_base;
         }
-        let lit_wmo = select(lit_nl, lit_wmo_interior, interior);
+        // EXTERIOR surfaces are the ones the realtime map can shadow (the fetch above is
+        // gated on !interior, so `lit_nl_shadowed` collapses to `lit_nl` for interior
+        // fragments anyway). Taking plain `lit_nl` here left every Stormwind street and
+        // wall unshadowed while the caster map was fully populated.
+        let lit_wmo = select(lit_nl_shadowed, lit_wmo_interior, interior);
         // SIDN night glow (MOMT 0x10): the authored emissive × the live night fraction, an
         // EMISSION term — inside the clamped sum, never MOCV-multiplied; dead on the unlit
         // INT lane, TRANS-weighted by the lit-pass alpha (wmo-interior-night-light §4).
@@ -342,10 +1556,85 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
             }
         }
         let sidn_e = sidn_rgb * (wow_light.grade.x * sidn_w);
-        // GL_COLOR_MATERIAL: MOCV multiplies the lit terms INSIDE the clamp (point term is
-        // zero on WMO surfaces, kept in the sum for exact mirroring), emission adds beside.
+        // MONKEY (ext-class night law): plenty of geometry INSIDE a building is authored
+        // EXTERIOR-class — the Goldshire inn's whole 57.7 yd shell is one group (`upstairs`,
+        // MOGP 0x0a09, and it holds the stair down to the cellar), its east stairwell annex is
+        // another — and the exterior law is the DAY/NIGHT SKY law: after dark that is `light_ambient`
+        // + `light_diffuse`, which the night sky makes GREEN. A fragment of one of those groups
+        // therefore renders sky-green one plank away from a candle-lit interior group, which is the
+        // reported hard break at the cellar stair and (with the shell's outer face) on the floors
+        // above it. The claim-gated `ext_room` term below already reaches those surfaces, but it
+        // ADDS to the sky rather than replacing it, so the green survived underneath the candles.
+        //
+        // The fix is a per-batch LAW BLEND rather than another additive term: a building-scale
+        // exterior group is one the room gate is willing to light (the same
+        // `ext_building_scale`/`CLAIM_EXT_OK` eligibility, so no group can land between the two
+        // rules), so after dark it should be lit the way the room next to it is — the interior
+        // lane's ambient floor, its claim-gated fixtures, its exposure rolloff, and NO sky term.
+        // By day nothing moves: `night_w` is 0 whenever the sun is up, so the authored sunlit look
+        // of every porch, courtyard and city street is bit-for-bit what it was.
+        //
+        // `fog_params.z` is `sun_shadow_strength(celestial_dir.y)` — 1 in daylight, ramping to 0
+        // as the sun reaches the horizon (see `global_light.rs`), i.e. exactly the "how much of the
+        // sky law is real right now" number the sun shadows already fade on. Reusing it keeps the
+        // law swap on the same dusk/dawn clock as everything else that fades with the sun.
+        let interiors_on = wow_light.wmo_fog_params.w > 0.5;
+        let ext_night = !interior && interiors_on && (rec.w & RECORD_EXT_NIGHT) != 0u;
+        // MONKEY (ext-class night law, REVERTED for GROUPS 2026-09-09): swapping a whole
+        // exterior-class SHELL group onto the room law after dark painted every building FACADE
+        // black at dusk — the inn's and the smithy's outer walls are that shell, no candle claims
+        // them, and `interiorAmbient` (0.02) is the whole of what the room law had for them while
+        // the ground beside them was still sunset-lit (user screenshots, 20:40 server time). The
+        // shell keeps the reference sky law day and night; its claimed fixtures still arrive
+        // through the strict `ext_room` term below. The BATCH-level half of the fix (an EXT-class
+        // batch inside an INTERIOR group — the cellar stair) lives in `day_w` and is untouched.
+        // MONKEY (shell candle add): `ext_night` is the building eligibility gate as well as the
+        // `interiorDebug 4` overlay key; despite its historical name it applies by DAY too.
+        // MONKEY (portal claims): the EXTERIOR-class group's own room light. Bug B's second
+        // cause: plenty of groups INSIDE a building are authored EXTERIOR-class (MOGP `& 0x48`) —
+        // the Goldshire inn's whole shell is one, and its basement stairwell reads night-sky GREEN
+        // a step away from candle-lit rooms — and the interior lane never runs on them, so no
+        // fixture could reach them at all. It does now, through the SAME soft profile and the SAME
+        // claim table, in STRICT mode: only a fixture that positively claims THIS group of THIS
+        // building, and only when that claim is exterior-lane eligible (`CLAIM_EXT_OK` — a
+        // building's shell is, a city's district shell is not; see
+        // `benilla_world::lighting::LIT_ROOM_EXT_DENY`). Stormwind's streets are unaffected twice
+        // over: their own torches are EXTERIOR-lane sources, which this loop skips, and the
+        // district shells they belong to carry no eligible claim.
+        //
+        // MONKEY (shell candle add): STRICT now returns DIRECT + FILL without the room ambient.
+        // Carry it separately from `primary`: multiplying this live light through MOCV suppresses
+        // it on baked-dark reveals, and omitting the exposure rolloff dims even an unbaked shell
+        // beside its room. Goldshire g4 actually has NO MOCV (vc = 1); its measured doorway also
+        // changes normal across g3/g4, so matching the law does not promise identical irradiance.
+        //
+        // COST: this is a per-FRAGMENT walk of the point table on surfaces that never had one —
+        // and exterior WMO geometry is most of a city's screen. So it is distance-gated, with a
+        // fade rather than a cliff: past `EXT_ROOM_FADE_END` the loop is not entered at all. The
+        // widest pool the lane can make is `1.5 x INTERIOR_LEGACY_REACH`, but every shipped fixture
+        // sits at `R = 7..15` yd (fill 10..22), so the gate costs nothing visible and is the
+        // difference between paying for the effect where it can be seen and paying for it across
+        // the whole skyline.
+        var ext_room_raw = vec3<f32>(0.0);
+        var ext_room_far = 0.0;
+        let ext_room_d = distance(in.world_position.xyz, view.world_position.xyz);
+        if (ext_night && ext_room_d < EXT_ROOM_FADE_END) {
+            ext_room_raw = interior_room_light(
+                in.world_position.xyz,
+                n_lit,
+                gx_room_inst(),
+                gx_room_group(in.word),
+                true, // fail CLOSED: an unclaimed exterior surface renders exactly as before
+            );
+            ext_room_far = 1.0 - smoothstep(EXT_ROOM_FADE_START, EXT_ROOM_FADE_END, ext_room_d);
+        }
+        // GL_COLOR_MATERIAL: MOCV multiplies the lit terms INSIDE the clamp, emission adds
+        // beside. MONKEY (wmo exterior points): `in.point_lit` is zero on INTERIOR groups (the
+        // reference's own vertex-stage zeroing — they light per fragment below) and carries the
+        // exterior nearest-3 point term on EXTERIOR-class ones, which is what makes a street
+        // torch reach the cobbles. The clamp is why it costs nothing in daylight.
         let primary = clamp(
-            vc.rgb * (lit_wmo + in.point_lit) + sidn_e,
+            vc.rgb * (lit_wmo + point_lit) + sidn_e,
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -354,16 +1643,265 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // break the pixel-identity bar.
         let tex_rgb = folded / max(vc.rgb, vec3<f32>(1.0 / 255.0));
         rgb = tex_rgb * primary;
-        if (interior && class_int && has_vc) {
-            // INT self-illumination: tex·MOCV·(1 + 4·MOCV.a), only the final [0,1] clamp —
-            // the client's own interior pixel shader (literal 4.0). Gated on AUTHORED
-            // colours: a colour-less INT batch takes the entity path's no-COLORS combine
-            // (plain tex × lit), which the white-vc algebra above already reproduces.
-            rgb = clamp(
-                tex_rgb * vc.rgb * (1.0 + 4.0 * trans_a),
-                vec3<f32>(0.0),
-                vec3<f32>(1.0),
+        rgb = shell_candle_add(rgb, base.rgb, ext_room_raw, ext_room_far);
+        // MONKEY (shell candle add): only actual interior groups enter the room-law blend. Shells
+        // keep the sky plus the strictly claimed texture addition above, without a room ambient
+        // floor or an enclosed day floor spilling across their whole building-sized extent.
+        if (interior && interiors_on) {
+            // MONKEY (dynamic interiors #A, `interiorLight` on): the WHOLE interior group — INT, TRANS and EXT batch
+            // classes alike — lights from the LIVE room torches instead of the MOCV bake. Gating
+            // this on `class_int` left every TRANS/EXT batch (most of a floor near a doorway) on
+            // the baked `vc.rgb × lit` path above: the "old baked light/shadow still there".
+            //
+            // Per-FRAGMENT (`interior_room_light`, every room light): a per-vertex sum on a WMO's
+            // huge floor triangles is Gouraud — straight-edged wedges, a torch mid-triangle lights
+            // nothing — the same artefact shape as Blizzard's per-vertex bake. The torch shadow
+            // (#2 lane, 1.0 when no torch is promoted) shades the torch term only.
+            //
+            // Daylight keeps the AUTHORED batch-class weight, so a doorway still takes the sun:
+            // INT = none, TRANS = the per-vertex MOCV alpha lerp, EXT = full `lit_int_base`.
+            // MOCV.rgb (the baked light + shadow) is what gets dropped; its alpha is the exterior
+            // blend weight, not a shadow, and stays.
+            //
+            // Soft rolloff instead of a hard clamp: `1 − exp(−x)` maps the ILLUMINATION into [0,1)
+            // with derivative 1 at 0 (dim nooks untouched) and a smooth asymptote — a bright forge
+            // never draws the iso-brightness contour a hard `clamp` did. `tex × illum` can't clip.
+            // SIDN rides inside as the emission it is. Ambient 0.15 fills the dark (cvar/slider
+            // once the look is confirmed).
+            let room = interior_room_light(
+                in.world_position.xyz,
+                n_lit,
+                gx_room_inst(),
+                gx_room_group(in.word),
+                // The interior lane's gate fails OPEN (see `interior_room_admits`).
+                // MONKEY (ext-class night law): the EXTERIOR-class lane keeps the STRICT gate it
+                // has always used here. Failing open on this lane would hand every un-keyed
+                // exterior group in the frame the whole fixture table the moment the sun set — a
+                // barn lit by a city's candles. Failing closed leaves an unclaimed one at exactly
+                // the ambient floor, which is what an unlit interior nook reads as, and is the
+                // "no sky" half of the fix on its own.
+                ext_night,
             );
+            var day_w = 0.0;
+            if (class_trans) {
+                day_w = trans_a;
+            } else if (!class_int) {
+                day_w = 1.0;
+            }
+            // MONKEY (ext-class night law): …and the authored weight is scaled by the SUN. This is
+            // the second half of the same bug, one lane over, and it is what actually paints the
+            // Lion's Pride Inn's cellar stair sky-green: the stair is NOT an exterior group (its
+            // 700 vertices are group 10, `room03`, MOGP 0x2805 — interior), but its MOBA batches
+            // are EXT-CLASS, and an EXT-class batch of an interior group took `day_w = 1`
+            // unconditionally, i.e. it rendered on the reference path with `lit_int_base` = the
+            // sun/sky ambient+diffuse. That is the right law at noon (a doorway takes the sun) and
+            // it is the NIGHT SKY after dark — green, next to the INT-class wall beside it on the
+            // candle lane, with the break exactly where the batch class changes.
+            //
+            // The weight's own rationale is what fixes it: it exists so the interior side of a
+            // threshold matches the EXTERIOR group a step away. That group is now on the room law
+            // after dark too (`ext_night` above), so matching it at night means the room law here
+            // as well — the same argument, evaluated at the right time of day. `fog_params.z` is
+            // exactly 1.0 while the sun is up, so `day_w` and therefore every daylight fragment of
+            // every interior group is bit-for-bit unchanged.
+            let sun_w = clamp(wow_light.fog_params.z, 0.0, 1.0);
+            day_w = day_w * sun_w;
+            // MONKEY (ext-class night law): `in.point_lit` joins the rolloff. It is a HARD ZERO on
+            // every interior batch (the vertex stage zeroes it for `WORD_INTERIOR`), so this is an
+            // exact no-op for the lane that already ran here — and on an ext-class batch it is the
+            // exterior point term, i.e. the street torch hanging on the wall being lit. Without it
+            // the blend would take that torch away from every building facade the moment it swapped
+            // laws, which is a new seam where the wall meets the lit cobbles.
+            // MONKEY (enclosed day floor): the day's ambient floor joins the room's own budget,
+            // INSIDE the rolloff — so it saturates with everything else instead of stacking on top
+            // of a lit room, and a fixture-lit corner by day reads brighter than an unlit one by
+            // exactly as much as the rolloff still has room for. Zero on every batch that is not a
+            // room in a building, and zero at night, so both of those are bit-identical.
+            // MONKEY (bake floor): the batch's own MOCV bake, at `interiorBakeFloor x interiorGain`,
+            // joins the same budget — see `interior_bake_floor` for the whole argument and the
+            // measured before/after at the owner's cvars. Inside the rolloff for the same reason
+            // the day floor is: a lit room absorbs it, an unlit one is carried by it.
+            let illum = vec3<f32>(1.0)
+                - exp(
+                    -(room
+                        + enclosed_day_floor(rec.w)
+                        + interior_bake_floor(vc.rgb, has_vc, class_int, class_trans)
+                        + point_lit
+                        + sidn_e)
+                        * wow_light.point_count.w,
+                );
+            // BLEND toward the reference's own lit result (`rgb` above — MOCV × the exterior law)
+            // by the authored batch-class weight; never ADD daylight on top of the room light,
+            // which left the interior side of every threshold brighter than the exterior floor a
+            // step away (the hard line at the smithy door). At the portal (weight 1) this IS the
+            // exterior group's law, so the seam closes by construction, day or night; deep inside
+            // (weight 0) it is pure room light. EXT-class batches (1) stay on the reference path.
+            //
+            // MONKEY (trans night floor): …and the blend may only ever BRIGHTEN, and it carries a
+            // FLOOR. Both halves are one rule — **the room lane must never render a threshold batch
+            // darker than the reference law's own guaranteed minimum for that fragment** — and both
+            // are needed, because the Lion's Pride Inn's front door is dark in two different ways.
+            //
+            // MEASURED (`benilla-extract wmolights`, GoldshireInn, with the new MOBA batch-class
+            // table): the front-door vestibule is group **g0** — the unnamed group the MOGN table
+            // prints as `-`, portalled to the ext* porch `room04` (p0) on one side and to the room
+            // beyond (p1) on the other, and the ONLY group in the whole WMO with TRANS batches
+            // (3/3, MOCV alpha 13..255, mean 111..131 ⇒ `trans_a ≈ 0.44..0.51`). It is NOT the group
+            // named `entry` (g3 — 13/13 INT, and portalled only to the cellar and the kitchen, so
+            // nothing enters the building through it). That misidentification is why this was
+            // measured as "13/13 INT, no TRANS" once before. g0 is what `interiorDebug 4` paints
+            // YELLOW-GREEN in the doorway, framed by the BLUE ext* porch and backed by GREEN INT.
+            //
+            // (1) At NIGHT the blend is already off (`day_w = trans_a · sun_w`, and
+            //     `sun_shadow_strength` is exactly 0 at and below the horizon — in Elwynn that is
+            //     from ~20:30 on, so it was 0 in BOTH of the user's 20:40 and after-dark
+            //     screenshots). What is left is the room lane, and no fixture reaches g0: all ten
+            //     MOLT fixtures are ≥ 13 yd away with their windows closed, and its only claim is a
+            //     faded portal hop, so the budget collapses to the bare `interiorAmbient` floor —
+            //     `1 − exp(−0.0075 × 4) = 0.0296 × tex`, i.e. black, against `0.73 × tex` for the
+            //     candle-lit floor a step away. A 25× step, which is the reported hard rectangle.
+            //     The FLOOR fixes that: a TRANS batch's reference value is `vc × ((1 − trans_a) +
+            //     trans_a · sky)`, so `vc × (1 − trans_a)` is what the reference renders it at under
+            //     a COMPLETELY BLACK SKY — its guaranteed minimum, the artist's own "the doorway is
+            //     the light" bake share, and the one term the live-fixture lane threw away with the
+            //     rest of the bake. Restoring it puts the band at `0.324 × tex`: dimmer than the lit
+            //     room (0.44×), brighter than an unlit corner, no rectangle.
+            // (2) In the dusk WINDOW where `sun_w` is between 0 and 1 (Elwynn ~19:19→20:30) the
+            //     blend runs toward a reference that is ALREADY DARKER than the room law — the
+            //     night sky under `nightGain` — so it actively subtracts light from exactly this
+            //     band: at `sun_w = 0.2` it drags `0.19` down to `0.14`. `max(room_rgb, rgb)`
+            //     forbids that: the mix now runs between the room result and the BRIGHTER of the
+            //     two, so it can add the sky's contribution and never take the room's away. This
+            //     also makes "the enclosed day floor must be on both sides" automatic — the floor
+            //     lives in `room_rgb`, and the result is now `>= room_rgb` by construction.
+            //
+            // SCOPE, by construction rather than by a new flag:
+            //   · INT batches — `day_w` is 0 and `class_trans` is false, so BOTH halves are exact
+            //     no-ops. That is the overwhelming majority of interior geometry, and dynamic
+            //     interiors keeps every bit of it.
+            //   · EXT-class batches of an interior group (the cellar stair the sun-scaled `day_w`
+            //     was introduced for) — the loader forces their MOCV alpha to 1.0, so their bake
+            //     share `1 − trans_a` is exactly 0; they keep the sun-gated blend and CANNOT get the
+            //     night sky back through the floor. The verified green-stair fix is untouched.
+            //   · DAYLIGHT — with the sun up the reference is the sun law and the room lane carries
+            //     `enclosed_day_floor`, so both are far above the bake share and `max` is a no-op:
+            //     the same fragment at noon computes 0.4476 before and 0.4476 after. At the very top
+            //     of the dusk ramp (sun_w still 1, the sky already warm-dim) the `max` can bite by
+            //     ~0.0003 — a 0.07 % brightening of a band that the next minute falls off a cliff,
+            //     which is the trade this whole comment is about.
+            let room_rgb = tex_rgb * illum;
+            // MONKEY (portal bleed): …and the floor is a RELATIVE lift now, not an absolute display
+            // value. The bake share below is `vc x (1 - trans_a)` — what the REFERENCE renders this
+            // fragment at under a black sky — and the room lane's whole premise is that the bake's
+            // LEVEL is wrong (it was authored for a different global exposure; the live fixtures
+            // decide). What survives that premise is the bake's RELATIVE statement: "this threshold
+            // is brighter than the room around it". So the floor is capped at
+            // `TRANS_NIGHT_FLOOR_LIFT x the room result` and carries the ROOM's own hue, which fixes
+            // the reported band in both of the ways it was wrong.
+            //
+            // MEASURED at the owner's live cvars (`interiorGain 0.5`, `interiorAmbient 0.015`,
+            // `interiorFill 0.08`, `interiorExposure 2.5`, `interiorAttenScale 1.6`,
+            // `interiorDaylight 0`) on the Lion's Pride Inn's vestibule `g0`, one yard inside p1,
+            // at night, with the portal bleed in:
+            //   room law here 0.0194 x tex; its INT neighbour g1 one yard the other side 0.0215.
+            //   UNCAPPED bake floor 0.324..0.357 (the three TRANS batches' mean MOCV) = **15-18x the
+            //   neighbour**, and neutral grey where the neighbour is candle-warm. That is the flat
+            //   grey band in the 20:50 and 23:59 screenshots, exactly: the floor had become the
+            //   brightest surface in the entrance and the only unwarm one.
+            //   CAPPED at 1.5x: 0.0291, i.e. 1.35x the neighbour, in the neighbour's own colour.
+            // The 25x black-hole step the floor was introduced against is gone for a different
+            // reason — the "candle-lit floor a step away" it was measured against (0.73 x tex) was
+            // an `interiorExposure 4` / `interiorGain 0.7` number, and at 2.5/0.5 that same floor
+            // renders 0.019. The floor's own justification evaporated with the cvars; what remains
+            // of its job is done by the bleed (absolute level) and by this cap (the doorway is a
+            // little brighter than its room), and neither can produce a 15x step at any cvar setting
+            // because one is bounded by the neighbour and the other by 1.5x the fragment's own room.
+            //
+            // 1.5 rather than 2: a threshold plainly reads as the brightest thing in an unlit
+            // vestibule at half again, and at low absolute levels a 2x step across a batch-class
+            // boundary starts to read as an edge rather than as a doorway. Where the bake share is
+            // small the `min` keeps taking it, so a nearly-opaque TRANS batch is unchanged, and an
+            // EXT-class batch of an interior group (`trans_a` forced to 1, bake share exactly 0)
+            // still gets nothing at all — the verified green-cellar-stair fix is untouched.
+            //
+            // BY DAY it is a no-op twice over, as before: at noon this fragment's room law is 0.276,
+            // the blend toward the sunlit reference takes it to 0.562, and the floor is
+            // `min(0.324, 1.5 x 0.276) = 0.324` — under the blend, so `max` keeps the blend.
+            let trans_floor_lift = 1.5;
+            let trans_night_floor = select(
+                vec3<f32>(0.0),
+                min(
+                    // `primary` with `lit_int_base := 0` — literally the reference's own expression
+                    // evaluated against a black sky, so the bake share can never exceed what the
+                    // reference renders, at any hour, and needs no tuning constant of its own.
+                    tex_rgb
+                        * clamp(
+                            vc.rgb * (1.0 - trans_a) + sidn_e,
+                            vec3<f32>(0.0),
+                            vec3<f32>(1.0),
+                        ),
+                    room_rgb * trans_floor_lift,
+                ),
+                class_trans,
+            // MONKEY (trans floor sun gate): x (1 - sun_w). The floor was meant as a NIGHT term and
+            // its comment above calls it a day no-op, but the evaluator that found the diagonal
+            // (MONKEY trans blend continuity) showed it is not: at noon `max(blend, floor)` flips to
+            // the floor from ~5.2 yd inside the vestibule door inward (0.3395 -> 0.3475, a
+            // non-monotone step), and the selector locus is a near-VERTICAL C1 break of ~0.12/yd
+            // running the full width of the floor about 1.5 yd inside p1 - the same class of line
+            // as the diagonal, parallel to the threshold. Gating it on `1 - sun_w` (the exact mirror
+            // of `day_w = trans_a * sun_w`) makes the day no-op true by construction: the floor is
+            // exactly 0 while the sun is up, ramps in over the same dusk clock the blend ramps out
+            // on, and is bit-identical at night (`sun_w = 0`). By day the bake floor
+            // (`interior_bake_floor`, inside the rolloff, not sun-gated) already carries a
+            // fixture-starved TRANS room, so nothing goes dark: the inner end of the vestibule at
+            // noon moves from 0.3475 to the room law (~0.33), a 5 % drop over its last yard.
+            ) * (1.0 - sun_w);
+            // MONKEY (trans blend continuity): `trans_smax` replaces the per-channel `max` here, and
+            // nothing else about this line moves - see the function for the three-locus scar it
+            // removes, the two laws it was measured against, and the night bit-identity.
+            rgb = max(mix(room_rgb, trans_smax(room_rgb, rgb), day_w), trans_night_floor);
+            let idbg = u32(max(wow_light.wmo_fog_params.w - 1.0, 0.0) + 0.5);
+            if (idbg == 2u) {
+                rgb = vec3<f32>(torch_debug_factor(in.world_position.xyz, n_lit));
+            } else {
+                rgb = shadow_hook::interior_debug_override(idbg, rgb, in.world_position, n_lit);
+            }
+        }
+        // MONKEY (ext-class night law): `interiorDebug 4` — the LANE MAP. Every WMO fragment is
+        // painted by which lighting law its GROUP falls under, and nothing else is touched
+        // (terrain, M2 props and entities keep their real shading), so one screenshot of any
+        // building answers "which of these three populations is this surface in?" — the question
+        // every seam in this system reduces to, and the one the offline `wmolights` group table can
+        // only answer by bbox arithmetic.
+        //   GREEN family  interior-class group (MOGP & 0x48 == 0) — always on the room lane, shaded
+        //                   by MOBA BATCH class because that is its own seam: pure green = INT
+        //                   (never took the sky), yellow-green = TRANS (the MOCV-alpha lerp),
+        //                   MINT = an EXT-class batch of an interior group — the population that
+        //                   used to render by the night SKY inside a lit room (the cellar stair).
+        //   BLUE          exterior-class at BUILDING scale — the sky lane by day, the room lane
+        //                   after dark (this fix).
+        //   RED           exterior-class shell/district — the sky lane, always; the room gate
+        //                   refuses its claims (`LIT_ROOM_EXT_DENY`).
+        // A seam between two like-coloured fragments is a CLAIM problem (which fixtures each side
+        // admits); a seam between two different colours is a LAW problem. Read off the record bit
+        // rather than `ext_night`, so the map is the same with the sun up and with `interiorLight`
+        // toggling only whether the overlay runs at all.
+        let lane_dbg = u32(max(wow_light.wmo_fog_params.w - 1.0, 0.0) + 0.5);
+        if (lane_dbg == 4u) {
+            if (interior) {
+                if (class_int) {
+                    rgb = vec3<f32>(0.0, 1.0, 0.0);
+                } else if (class_trans) {
+                    rgb = vec3<f32>(0.55, 1.0, 0.0);
+                } else {
+                    rgb = vec3<f32>(0.0, 1.0, 0.75);
+                }
+            } else if ((rec.w & RECORD_EXT_NIGHT) != 0u) {
+                rgb = vec3<f32>(0.1, 0.35, 1.0);
+            } else {
+                rgb = vec3<f32>(1.0, 0.0, 0.0);
+            }
         }
     } else if ((in.word & WORD_INTERIOR) != 0u) {
         // ---- the interior M2-PROP lane (B4, decision 1433) — wow_model.wgsl's
@@ -391,8 +1929,32 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
-        let primary = clamp(lit_prop + in.point_lit, vec3<f32>(0.0), vec3<f32>(1.0));
+        let primary = clamp(lit_prop + point_lit, vec3<f32>(0.0), vec3<f32>(1.0));
         rgb = folded * primary;
+        // MONKEY (dynamic interiors #A): interior props take the SAME live room light as the
+        // surfaces around them (`interior_room_light`) instead of the baked probe — on the probe a
+        // tavern's tables and barrels stayed bake-bright inside a torch-lit room ("the .m2s ignore
+        // the light"). Same soft rolloff as the surface lane. UNCONDITIONAL for the prove-out; the
+        // probe path above is the faithful baked result the cvar will restore.
+        if (wow_light.wmo_fog_params.w > 0.5) {
+            // MONKEY (room gate): a WMO prop takes its OWNER GROUP's key too, where the bake
+            // could resolve one (a referrer set naming exactly one group); an ADT map doodad and a
+            // multi-room prop pass 0 and stay ungated.
+            let room = interior_room_light(
+                in.world_position.xyz,
+                n_lit,
+                gx_room_inst(),
+                gx_room_group(in.word),
+                false, // the interior lane's gate fails OPEN (see `interior_room_admits`)
+            );
+            rgb = folded * (vec3<f32>(1.0) - exp(-room * wow_light.point_count.w));
+            let idbg = u32(max(wow_light.wmo_fog_params.w - 1.0, 0.0) + 0.5);
+            if (idbg == 2u) {
+                rgb = vec3<f32>(torch_debug_factor(in.world_position.xyz, n_lit));
+            } else {
+                rgb = shadow_hook::interior_debug_override(idbg, rgb, in.world_position, n_lit);
+            }
+        }
     } else {
         // ---- the exterior ADT-doodad lane (slice 1) + the exterior MODD-prop family (B4) --
         // The intensity family: statics are `mat_shade` only (no per-instance ramp byte —
@@ -421,13 +1983,30 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
                     * (dot(wow_light.sh_c10_b.xyz, n_lit) + dot(wow_light.sh_c13_b, quad)
                         + wow_light.sh_c16.z * x2y2),
         );
-        let lit_doodad = clamp(sun_lobe, vec3<f32>(0.0), vec3<f32>(1.0));
+        // The SH lobe's own ambient rows (the .w column) are the doodad lane's ambient share:
+        // subtract-and-restore around the shadow term so only the directional part of the lobe
+        // dims. Guarded like `lit_nl_shadowed` so the no-shadow state stays byte-identical.
+        let sun_ambient = vec3<f32>(
+            wow_light.sh_c10_r.w,
+            wow_light.sh_c10_g.w,
+            wow_light.sh_c10_b.w,
+        );
+        let lit_doodad_plain = clamp(sun_lobe, vec3<f32>(0.0), vec3<f32>(1.0));
+        let lit_doodad = select(
+            lit_doodad_plain,
+            clamp(
+                sun_ambient + (sun_lobe - sun_ambient) * shadow_term,
+                vec3<f32>(0.0),
+                vec3<f32>(1.0),
+            ),
+            world_shadow < 0.999,
+        );
         // Sun disabled (light_sun.w) falls back to the FFP matte, like the entity path.
-        let lit = select(lit_nl, lit_doodad, wow_light.light_sun.w > 0.5);
+        let lit = select(lit_nl_shadowed, lit_doodad, wow_light.light_sun.w > 0.5);
         // FFP combine: the light sum saturates FIRST, the texture (× the baked constant
         // tint, when authored) modulates the clamped result. Statics: inst_tint identity,
         // no highlight, no SIDN.
-        let primary = clamp(lit + in.point_lit, vec3<f32>(0.0), vec3<f32>(1.0));
+        let primary = clamp(lit + point_lit, vec3<f32>(0.0), vec3<f32>(1.0));
         rgb = folded * primary;
     }
     // Unlit fullbright (M2 UNLIT 0x01 / WMO UNLIT on an exterior-group batch): the albedo —
diff --git a/crates/benilla-world/src/shaders/torch_depth.wgsl b/crates/benilla-world/src/shaders/torch_depth.wgsl
new file mode 100644
index 00000000..abe4c935
--- /dev/null
+++ b/crates/benilla-world/src/shaders/torch_depth.wgsl
@@ -0,0 +1,16 @@
+// MONKEY (torch shadows, Phase 1): the vertex-only depth pass for one interior fixture.
+//
+// Renders the retained interior caster geometry (position only, stride 12) from a fixture's
+// down-looking reverse-Z `view_proj` into one layer of the torch depth 2D-array texture. No
+// fragment stage: only depth is written (clear 0.0, GreaterEqual — reverse-Z). See
+// `static_gx/torch_depth.rs` for the pipeline and `static_gx.wgsl` for the sampling side.
+
+struct TorchView {
+    view_proj: mat4x4<f32>,
+}
+@group(0) @binding(0) var<uniform> torch_view: TorchView;
+
+@vertex
+fn vertex(@location(0) position: vec3<f32>) -> @builtin(position) vec4<f32> {
+    return torch_view.view_proj * vec4<f32>(position, 1.0);
+}
diff --git a/crates/benilla-world/src/static_gx/bake.rs b/crates/benilla-world/src/static_gx/bake.rs
index b5fed59f..0eda072c 100644
--- a/crates/benilla-world/src/static_gx/bake.rs
+++ b/crates/benilla-world/src/static_gx/bake.rs
@@ -331,6 +331,9 @@ fn bake_cell(items: &[GxItem], meshes: &mut Assets<Mesh>) -> render::GxCellDraw
             order: item.wmo.as_ref().map_or(0, |w| w.order),
             sidn: item.wmo.as_ref().map_or([0; 3], |w| w.sidn),
             slot: item.prop.as_ref().and_then(|p| p.slot).unwrap_or(0),
+            ext_night: item.wmo.as_ref().is_some_and(|w| w.ext_night),
+            // MONKEY (enclosed day floor): rides the bake exactly as `ext_night` does.
+            enclosed: item.wmo.as_ref().is_some_and(|w| w.enclosed),
         });
     }
     // Recentre for clip-space precision (0974): the shader reconstructs world = v + origin.
@@ -622,6 +625,8 @@ mod tests {
             sidn: Some([10, 20, 30]),
             window: true,
             batch_order: group + 1,
+            ext_night: false,
+            enclosed: false,
         };
         // An INT batch of group 2, pushed FIRST — Matte shade must NOT refuse it…
         let mut b = batch(&g, Vec3::new(1.0, 0.0, 1.0), None, ModelBlend::Opaque);
diff --git a/crates/benilla-world/src/static_gx/mod.rs b/crates/benilla-world/src/static_gx/mod.rs
index f805b0d5..2e5acea7 100644
--- a/crates/benilla-world/src/static_gx/mod.rs
+++ b/crates/benilla-world/src/static_gx/mod.rs
@@ -134,6 +134,21 @@ mod cull;
 mod pick;
 mod pool;
 mod render;
+mod shadow; // MONKEY (world shadows): CPU triangle collection for the static-world shadow caster
+mod torch_depth; // MONKEY (torch shadows Phase 1): the per-fixture depth-map render + its targets
+pub use shadow::CutoutBucket; // MONKEY (world shadows): per-leaf-texture alpha-cutout caster group
+pub use torch_depth::TorchShadowViews; // MONKEY (torch shadows Phase 1): the app→render publication
+// MONKEY (torch owner exclusion): the light→caster ownership key, written at the light spawn
+// sites (`terrain_stream::spawn`, `benilla_app::entities::carried_light`) and read by both
+// torch caster gathers, so a fixture never casts its own body's shadow into its own map.
+pub use torch_depth::{torch_flame_inside_bounds, LightOwner};
+// MONKEY (torch shadows Phase 3A): the shared depth image + table buffer every model material binds,
+// their startup constructor, the one-param main-world accessor, and the always-on wiring — used by
+// the asset foundation (`crate::assets`) and every material-building site; NOT gated on `enabled()`.
+pub use torch_depth::{
+    new_torch_shared, SharedTorchBuffer, TorchDepthImage, TorchShared,
+};
+pub(crate) use torch_depth::register_shared as register_torch_shared;
 
 /// The doodad spatial cell — ¼ ADT tile, the same 133⅓-yd locality key the merge lanes use
 /// (`terrain_stream::merge::CELL`; 1413 round 2 proved the locality load-bearing).
@@ -296,8 +311,11 @@ struct GxItem {
     owner: (i32, i32),
     texture: Option<AssetId<bevy::image::Image>>,
     /// Kept as a live handle so the render world's `GpuImage` can never be dropped from under
-    /// the baked cell (the id alone holds nothing).
-    _texture_handle: Option<Handle<bevy::image::Image>>,
+    /// the baked cell (the id alone holds nothing). Never READ (the bake keys everything off
+    /// [`Self::texture`]'s id) — its whole job is the strong reference held by its own
+    /// existence, so `dead_code` is a false positive here.
+    #[allow(dead_code)]
+    texture_handle: Option<Handle<bevy::image::Image>>,
     cutout: bool,
     two_sided: bool,
     unlit: bool,
@@ -389,6 +407,14 @@ enum FaderState {
 struct GxItemWmo {
     group: u16,
     interior: bool,
+    /// MONKEY (ext-class night law): this batch's group is EXTERIOR-class at BUILDING scale
+    /// ([`benilla_formats::room_claim::ext_building_scale`]) — the record table's bit 27, which
+    /// makes `static_gx.wgsl` blend it onto the interior light law after dark.
+    ext_night: bool,
+    /// MONKEY (enclosed day floor): this batch's group is an INTERIOR room inside a building-scale
+    /// shell ([`benilla_formats::room_claim::enclosed_by_building_shell`]) — the record table's
+    /// bit 28, which gives the room law a sun-driven ambient floor by day.
+    enclosed: bool,
     /// The batch-class lane exactly as `model_render` packs `tint.w`: 0 = EXT law, 1 = INT,
     /// 2 = TRANS — non-zero only on an interior group's batches.
     class_lane: u8,
@@ -542,7 +568,13 @@ pub enum GxSite<'a> {
     Doodad { owner: (i32, i32) },
     /// A WMO placement's group geometry: the pre-spawned `WmoPortalInstance` entity + the
     /// model's per-batch group map (`WmoModel::submesh_group`, index-parallel with batches).
-    Wmo { instance: Entity, groups: &'a [u16] },
+    /// MONKEY (ext-class night law): `bounds` is the model's MOGI group table (`group_bounds`),
+    /// indexed by ABSOLUTE group index — the class + box the per-batch night-law bit is read off.
+    Wmo {
+        instance: Entity,
+        groups: &'a [u16],
+        bounds: &'a [benilla_formats::WmoGroupInfo],
+    },
     /// A WMO doodad prop (B4, decision 1433 — 1418's lane 3, absorbed): the building's
     /// instance entity, the referrer set of rooms that name the prop, and the interior
     /// prop's folded SH-probe slot. Only a placement WITH an instance qualifies (no
@@ -563,6 +595,15 @@ pub struct GxWmoBatch {
     pub group: u16,
     /// This batch's group is a true interior (`MOGI & 0x48 == 0`) — `RenderSubmesh::interior`.
     pub interior: bool,
+    /// MONKEY (ext-class night law): EXTERIOR-class, but at BUILDING scale — an inn's shell or its
+    /// basement stairwell, not a city district's. Resolved at the spawn site from the group's own
+    /// MOGI box ([`benilla_formats::room_claim::ext_building_scale`]), because that is the last
+    /// place the model's group table is in hand; it rides to the shader as a record bit.
+    pub ext_night: bool,
+    /// MONKEY (enclosed day floor): the mirror question — this is an INTERIOR-class group whose
+    /// box centre sits inside such a shell, i.e. a ROOM IN A BUILDING rather than a cave. Resolved
+    /// at the same site off the same table; rides to the shader as bit 28.
+    pub enclosed: bool,
     /// The MOBA batch class (INT/TRANS/EXT) — the lighting-lane selector on interior groups.
     pub class: Option<WmoBatchClass>,
     /// The MOMT SIDN night-glow colour.
@@ -696,6 +737,8 @@ impl StaticGx {
         let wmo = b.wmo.map(|w| GxItemWmo {
             group: w.group,
             interior: w.interior,
+            ext_night: w.ext_night,
+            enclosed: w.enclosed,
             class_lane: match (w.interior, w.class) {
                 (true, Some(WmoBatchClass::Int)) => 1,
                 (true, Some(WmoBatchClass::Trans)) => 2,
@@ -797,7 +840,7 @@ impl StaticGx {
             local_aabb: b.aabb,
             owner: b.owner,
             texture: b.texture.as_ref().map(Handle::id),
-            _texture_handle: b.texture,
+            texture_handle: b.texture,
             cutout: b.blend == ModelBlend::AlphaTest && !crate::model_render::alphatest_disabled(),
             two_sided: b.two_sided,
             unlit: b.unlit,
diff --git a/crates/benilla-world/src/static_gx/render.rs b/crates/benilla-world/src/static_gx/render.rs
index 2ed8c691..d71860b6 100644
--- a/crates/benilla-world/src/static_gx/render.rs
+++ b/crates/benilla-world/src/static_gx/render.rs
@@ -16,9 +16,15 @@
 //! bind groups, never a texture.
 
 use bevy::camera::primitives::Aabb;
+use bevy::core_pipeline::oit::OrderIndependentTransparencySettingsOffset;
 use bevy::ecs::query::QueryItem;
 use bevy::image::Image;
 use bevy::mesh::VertexBufferLayout;
+use bevy::pbr::{
+    MeshPipeline, MeshPipelineViewLayoutKey, MeshViewBindGroup, ViewEnvironmentMapUniformOffset,
+    ViewFogUniformOffset, ViewLightProbesUniformOffset, ViewLightsUniformOffset,
+    ViewScreenSpaceReflectionsUniformOffset,
+};
 use bevy::platform::collections::HashMap;
 use bevy::prelude::*;
 use bevy::render::diagnostic::RecordDiagnostics;
@@ -31,14 +37,12 @@ use bevy::render::render_graph::{
     NodeRunError, RenderGraphContext, RenderGraphExt, RenderLabel, ViewNode, ViewNodeRunner,
 };
 use bevy::render::render_resource::binding_types::{
-    sampler, storage_buffer_read_only_sized, texture_2d_array, uniform_buffer, uniform_buffer_sized,
+    sampler, storage_buffer_read_only_sized, texture_2d_array, uniform_buffer_sized,
 };
 use bevy::render::render_resource::*;
 use bevy::render::renderer::{RenderContext, RenderDevice, RenderQueue};
 use bevy::render::texture::GpuImage;
-use bevy::render::view::{
-    ExtractedView, Msaa, ViewDepthTexture, ViewTarget, ViewUniform, ViewUniformOffset, ViewUniforms,
-};
+use bevy::render::view::{ExtractedView, Msaa, ViewDepthTexture, ViewTarget, ViewUniformOffset};
 use bevy::render::{Render, RenderSystems};
 use bevy::shader::ShaderDefVal;
 use std::ops::Range;
@@ -68,6 +72,14 @@ pub(crate) struct GxItemDraw {
     /// The interior prop's SH-probe slot (B4; 0 elsewhere — read only under the word's
     /// INTERIOR-without-WMO lane). Rides the record table's w column, bits 1..14.
     pub slot: u16,
+    /// MONKEY (ext-class night law): this is an EXTERIOR-class WMO batch at BUILDING scale — the
+    /// record table's bit 27 (see [`RECORD_EXT_NIGHT_BIT`]). False on cells, props and interior
+    /// batches.
+    pub ext_night: bool,
+    /// MONKEY (enclosed day floor): this is an INTERIOR-class WMO batch whose group sits inside a
+    /// building-scale shell — the record table's bit 28 (see [`RECORD_ENCLOSED_BIT`]). False on
+    /// cells, props, exterior batches, and every group of a dungeon (which authors no shell).
+    pub enclosed: bool,
 }
 
 /// One baked cell (or WMO region), published by the main-world flush.
@@ -165,6 +177,47 @@ use super::pool::GxTexturePool;
 /// and bits 1..=13 the interior-prop probe slot, so 14 is the first free bit.
 const RECORD_FOG_BIT: u32 = 1 << 14;
 
+/// MONKEY (room gate): record column `w` bits 15..=26 — the item's ROOM KEY, `group + 1` so that
+/// **0 means "this item names no room"** and the shader's gate lets every fixture through (a
+/// terrain-cell item; a WMO prop whose referrer set is not exactly one group). Bit 14 is the fog
+/// lane, so 15 is the first free bit, and 12 bits covers every shipped WMO (the largest,
+/// Stratholme, has 92 groups). **Keep in sync with `static_gx.wgsl`'s `RECORD_ROOM_SHIFT` /
+/// `RECORD_ROOM_MASK`.**
+const RECORD_ROOM_SHIFT: u32 = 15;
+const RECORD_ROOM_MASK: u32 = 0xfff;
+
+/// MONKEY (ext-class night law): record column `w`, bit 27 — this batch's group is EXTERIOR-class
+/// but at BUILDING scale (an inn's shell, a basement stairwell), so after dark `static_gx.wgsl`
+/// blends it off the sky-lit exterior law and onto the interior room law. The room key occupies
+/// bits 15..=26, so 27 is the first free bit. **Keep in sync with `static_gx.wgsl`'s
+/// `RECORD_EXT_NIGHT`.**
+const RECORD_EXT_NIGHT_BIT: u32 = 1 << 27;
+
+/// MONKEY (enclosed day floor): record column `w`, bit 28 — this batch's group is an INTERIOR room
+/// inside a building-scale exterior shell, so by day `static_gx.wgsl` gives its room law a
+/// sun-driven ambient floor (the daylight a doorway lets in, for the doorways this renderer cannot
+/// locate). Bit 27 is the night law, so 28 is the first free bit; bits 29..=31 remain free.
+/// **Keep in sync with `static_gx.wgsl`'s `RECORD_ENCLOSED`.**
+const RECORD_ENCLOSED_BIT: u32 = 1 << 28;
+
+/// The room key for one baked item: `group + 1` for a WMO surface batch, and for a PROP batch whose
+/// referrer set names exactly one group (a prop in one room — the common case); 0 for a terrain
+/// cell, and for a multi-room prop, which stays ungated because a single key cannot express it.
+fn room_key(item: &GxItemDraw, sets: &[std::sync::Arc<[u16]>]) -> u32 {
+    let Some(sel) = item.group else {
+        return 0; // a cell item: no building, no room
+    };
+    let group = if sets.is_empty() {
+        sel // a WMO region's selection grain IS the group
+    } else {
+        match sets.get(usize::from(sel)).map(|s| &s[..]) {
+            Some([g]) => *g,
+            _ => return 0, // unnamed or multi-room prop
+        }
+    };
+    (u32::from(group) + 1).min(RECORD_ROOM_MASK) << RECORD_ROOM_SHIFT
+}
+
 /// 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
@@ -217,21 +270,47 @@ struct GxGpuCache {
 struct GxPipelines {
     view_layout: BindGroupLayoutDescriptor,
     cell_layout: BindGroupLayoutDescriptor,
+    light_layout: BindGroupLayoutDescriptor,
+    /// MONKEY (torch shadows Phase 1): group 3 — the torch depth array + comparison sampler + the
+    /// ≤16-entry `TorchTable` uniform. Present on every static_gx pipeline (`TORCH_SHADOWS` def).
+    torch_layout: BindGroupLayoutDescriptor,
     sampler: Sampler,
     sampler_clamp: Sampler,
     /// Keyed `(cutout, two_sided)`; specialized for the world view's (samples, format) pair —
     /// re-specialized if that pair ever changes (a window move across displays).
     pipelines: HashMap<(bool, bool), CachedRenderPipelineId>,
-    specialized_for: Option<(u32, TextureFormat)>,
+    /// MONKEY (sun shadow perf): the key now carries the live `shadowFilter` too — the PCF branch
+    /// is a shader DEF, so a change has to re-specialize the family. Once per CHANGE, not per
+    /// frame: exactly the posture the (samples, format) pair beside it already has, and the same
+    /// caveat (a flip re-queues four pipelines rather than reviving the previous four — a cvar
+    /// A/B costs a shader build, a rendered frame costs nothing).
+    specialized_for: Option<(u32, TextureFormat, bool)>,
 }
 
-fn init_pipelines(mut commands: Commands, render_device: Res<RenderDevice>) {
-    let view_layout = BindGroupLayoutDescriptor::new(
-        "static_gx_view_layout",
+fn init_pipelines(
+    mut commands: Commands,
+    mesh_pipeline: Res<MeshPipeline>,
+    render_device: Res<RenderDevice>,
+) {
+    // Use Bevy's real mesh-view layout for the retained pass. Besides the view and light records,
+    // this carries the directional shadow textures and comparison samplers produced for the
+    // world camera. The old two-binding layout could render the city, but it had no legal way for
+    // `static_gx.wgsl` to receive the shadow map.
+    let view_layout = mesh_pipeline
+        .get_view_layout(MeshPipelineViewLayoutKey::empty())
+        .main_layout
+        .clone();
+    // The pass's own extra (group 2): the shared light storage.
+    // MONKEY (room gate): binding 1 is the per-fixture ROOM CLAIM table — which WMO groups each
+    // packed interior fixture may light. Its own buffer, never a `WowLight` extension: that struct
+    // is mirrored by three shaders plus the portrait booth and a resize there vanishes every
+    // building in the world.
+    let light_layout = BindGroupLayoutDescriptor::new(
+        "static_gx_light_layout",
         &BindGroupLayoutEntries::sequential(
             ShaderStages::VERTEX_FRAGMENT,
             (
-                uniform_buffer::<ViewUniform>(true),
+                storage_buffer_read_only_sized(false, None),
                 storage_buffer_read_only_sized(false, None),
             ),
         ),
@@ -261,6 +340,32 @@ fn init_pipelines(mut commands: Commands, render_device: Res<RenderDevice>) {
     // MIXED-wrap batch (repeat one axis, clamp the other) keeps the repeat sampler plus the
     // shader's half-texel inset clamp on its clamped axis — an approximation confined to that
     // class (decision 0763's silhouette concern, honoured per axis).
+    // MONKEY (torch shadows Phase 1): group 3 — the interior torch depth map (a Depth32Float
+    // 2D-array sampled through a `GreaterEqual` comparison sampler) + the ≤16-entry `TorchTable`
+    // uniform (count/positions/view_projs). Fragment-only; declared behind the shader's
+    // `TORCH_SHADOWS` def, which the specialization below always sets for this pipeline family.
+    let torch_layout = BindGroupLayoutDescriptor::new(
+        "static_gx_torch_layout",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::FRAGMENT,
+            (
+                // A depth 2D-array (= WGSL `texture_depth_2d_array`): no dedicated helper, so a
+                // `texture_2d_array` with the Depth sample type.
+                texture_2d_array(TextureSampleType::Depth),
+                sampler(SamplerBindingType::Comparison),
+                // MONKEY (static torch cache): count@0 (16), positions[16]@16 (256),
+                // view_projs[96]@272 (6144) = 6416 bytes. Both shader copies and the shared
+                // material storage buffer use these same bytes; a drift hides every building.
+                uniform_buffer_sized(
+                    false,
+                    Some(
+                        std::num::NonZero::new(super::torch_depth::TORCH_TABLE_BYTES)
+                            .expect("TORCH_TABLE_BYTES is non-zero"),
+                    ),
+                ),
+            ),
+        ),
+    );
     let filter = benilla_assets::tex_filter();
     let make = |label: &'static str, mode: AddressMode| {
         render_device.create_sampler(&SamplerDescriptor {
@@ -274,9 +379,20 @@ fn init_pipelines(mut commands: Commands, render_device: Res<RenderDevice>) {
             ..Default::default()
         })
     };
+    // MONKEY (room gate): the claim table's persistent GPU buffer, written every frame by
+    // `prepare_room_claims`. Created here (RenderStartup) rather than beside the shared light
+    // buffer so the whole binding — layout, buffer, upload — lives with its one reader.
+    commands.insert_resource(GxRoomClaims(render_device.create_buffer(&BufferDescriptor {
+        label: Some("static_gx_room_claims"),
+        size: crate::lighting::room_claim_bytes(),
+        usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    })));
     commands.insert_resource(GxPipelines {
         view_layout,
         cell_layout,
+        light_layout,
+        torch_layout,
         sampler: make("static_gx_repeat", AddressMode::Repeat),
         sampler_clamp: make("static_gx_clamp", AddressMode::ClampToEdge),
         pipelines: HashMap::default(),
@@ -347,9 +463,15 @@ fn prepare_static_gx(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     asset_server: Res<AssetServer>,
+    mesh_pipeline: Res<MeshPipeline>,
     images: Res<RenderAssets<GpuImage>>,
     views: Query<GxViewKey>,
+    // MONKEY (sun shadow perf): the live `shadowFilter`, extracted from the main world. `Option`
+    // because `ExtractResourcePlugin` only publishes it while the lighting plugin is in the app
+    // (a bare static_gx harness has no lighting) — absent reads as the shipped Gaussian.
+    shadow_filter: Option<Res<crate::lighting::ShadowFilterGaussian>>,
 ) {
+    let shadow_gaussian = shadow_filter.map_or(true, |f| f.0);
     let _t = super::gx_perf_guard(3);
     // The world view's pipeline key (the marker keeps booth views out of it).
     let Some((view, msaa, _, _)) = views.iter().next() else {
@@ -360,14 +482,31 @@ fn prepare_static_gx(
     } else {
         TextureFormat::bevy_default()
     };
-    let key = (msaa.samples(), format);
+    let key = (msaa.samples(), format, shadow_gaussian);
     if pipes.specialized_for != Some(key) {
+        pipes.view_layout = mesh_pipeline
+            .get_view_layout(MeshPipelineViewLayoutKey::from(*msaa))
+            .main_layout
+            .clone();
         let shader: Handle<Shader> =
             asset_server.load("embedded://benilla_world/shaders/static_gx.wgsl");
         pipes.pipelines.clear();
         for cutout in [false, true] {
             for two_sided in [false, true] {
                 let mut defs = vec![];
+                // The retained pipeline is custom, so it must opt into the same PCF branch the
+                // world camera's `ShadowFilteringMethod` gives every Bevy-material receiver;
+                // otherwise `shadows::fetch_directional_shadow` falls back to a constant 1.0.
+                // MONKEY (sun shadow perf): that method is now the live `shadowFilter` cvar, so the
+                // def follows it — the ground and the buildings standing on it must filter alike.
+                defs.push(ShaderDefVal::from(if shadow_gaussian {
+                    "SHADOW_FILTER_METHOD_GAUSSIAN"
+                } else {
+                    "SHADOW_FILTER_METHOD_HARDWARE_2X2"
+                }));
+                // MONKEY (torch shadows Phase 1): arm the shader's group-3 torch-map code. Set on
+                // EVERY static_gx pipeline so the group-3 bindings (always bound by the node) match.
+                defs.push(ShaderDefVal::from("TORCH_SHADOWS"));
                 if cutout {
                     defs.push(ShaderDefVal::from("GX_CUTOUT"));
                 }
@@ -375,7 +514,12 @@ fn prepare_static_gx(
                     label: Some(
                         format!("static_gx c{} t{}", u8::from(cutout), u8::from(two_sided)).into(),
                     ),
-                    layout: vec![pipes.view_layout.clone(), pipes.cell_layout.clone()],
+                    layout: vec![
+                        pipes.view_layout.clone(),
+                        pipes.cell_layout.clone(),
+                        pipes.light_layout.clone(),
+                        pipes.torch_layout.clone(),
+                    ],
                     vertex: VertexState {
                         shader: shader.clone(),
                         shader_defs: defs.clone(),
@@ -450,6 +594,7 @@ fn prepare_static_gx(
                 };
                 if let Some(gpu) = assemble_region(
                     draw,
+                    0, // a terrain cell belongs to no building (MONKEY, room gate)
                     &mut pool,
                     &pipes,
                     &pipeline_cache,
@@ -469,6 +614,7 @@ fn prepare_static_gx(
                 };
                 if let Some(gpu) = assemble_region(
                     draw,
+                    entity.index().index(),
                     &mut pool,
                     &pipes,
                     &pipeline_cache,
@@ -490,6 +636,7 @@ fn prepare_static_gx(
         };
         if let Some(gpu) = assemble_region(
             draw,
+            entity.index().index(),
             &mut pool,
             &pipes,
             &pipeline_cache,
@@ -520,7 +667,8 @@ fn prepare_static_gx(
             continue;
         }
         for (i, rec) in gpu.records.iter_mut().enumerate() {
-            // Column w carries the probe slot in the high bits (B4) — rewrite only bit 0.
+            // Column w carries the probe slot (B4) and the room key (MONKEY, room gate) in the
+            // high bits — rewrite only bit 0.
             rec[3] = (rec[3] & !1) | kill_bit(&draw.killed, i);
         }
         render_queue.write_buffer(&gpu.record_table, 0, bytemuck::cast_slice(&gpu.records));
@@ -569,6 +717,9 @@ fn prepare_static_gx(
 /// assigned stay assigned, so the retry finishes cheaper).
 fn assemble_region(
     draw: &GxCellDraw,
+    // MONKEY (room gate): this region's WMO placement instance (entity index), or 0 for a terrain
+    // cell — half of the surface room key the interior lane gates on.
+    room_instance: u32,
     pool: &mut GxTexturePool,
     pipes: &GxPipelines,
     pipeline_cache: &PipelineCache,
@@ -581,6 +732,9 @@ fn assemble_region(
     // distinct BLPs, and neighbouring cells repeat most of them; per-item layers blew the
     // D2-array limit the moment a city root baked, and per-CELL arrays paid the driver churn
     // 1431 measured). Untextured items ride the white class (never sampled — TEXTURED clear).
+    // MONKEY (room gate): whether this region can carry a room key at all (see the cell uniform
+    // below for the 2^24 bound and why both halves of the key must fail open together).
+    let gated = room_instance > 0 && room_instance < (1 << 24);
     let mut white: Option<u16> = None;
     let mut item_class_layer: Vec<(u16, u16)> = Vec::with_capacity(draw.draws.len());
     for item in &draw.draws {
@@ -608,7 +762,19 @@ fn assemble_region(
                 u32::from(item.sidn[0])
                     | (u32::from(item.sidn[1]) << 8)
                     | (u32::from(item.sidn[2]) << 16),
-                kill_bit(&draw.killed, i) | (u32::from(item.slot) << 1),
+                kill_bit(&draw.killed, i)
+                    | (u32::from(item.slot) << 1)
+                    | if gated { room_key(item, &draw.sets) } else { 0 }
+                    // MONKEY (ext-class night law): unconditional on `gated` — the night law is a
+                    // property of the GROUP's authored class and box, not of whether this region
+                    // could carry a room key. An ungated region's ext-class group still must not
+                    // read as night sky; its `interior_room_light` simply falls open, exactly as an
+                    // ungated interior group's already does.
+                    | if item.ext_night { RECORD_EXT_NIGHT_BIT } else { 0 }
+                    // MONKEY (enclosed day floor): unconditional on `gated` for the same reason —
+                    // "is this group a room in a building" is a fact about the authored group
+                    // table, not about whether this region could carry a room key.
+                    | if item.enclosed { RECORD_ENCLOSED_BIT } else { 0 },
             ]
         })
         .collect();
@@ -617,9 +783,27 @@ fn assemble_region(
         contents: bytemuck::cast_slice(&records),
         usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
     });
+    // MONKEY (room gate): the uniform's fourth lane was a hard 0.0 pad and now carries this
+    // REGION's building identity — the WMO placement instance's entity index — so the declared
+    // 16-byte size (and every bind-group layout built against it) does not move. Per REGION rather
+    // than per item, because a region is exactly one placement; that is what keeps the per-item key
+    // down to the group alone.
+    //
+    // As a NUMBER, not as bits: an entity index is a small integer and `f32::from_bits(12345)` is a
+    // DENORMAL, which a driver flushing denormals to zero would collapse to 0 — every building
+    // sharing identity 0, and every gate then a coin toss. An f32 holds every integer below 2^24
+    // exactly, which no live entity index approaches, so `as f32` / `u32()` is lossless. At or above
+    // that bound (and for a terrain cell, index 0) the region is packed UNGATED on BOTH lanes —
+    // identity AND per-item key — because half a key would fail CLOSED and black the building out.
+    let room_instance = if gated { room_instance } else { 0 };
     let cell_uniform = render_device.create_buffer_with_data(&BufferInitDescriptor {
         label: Some("static_gx_cell"),
-        contents: bytemuck::cast_slice(&[draw.origin.x, draw.origin.y, draw.origin.z, 0.0f32]),
+        contents: bytemuck::cast_slice(&[
+            draw.origin.x,
+            draw.origin.y,
+            draw.origin.z,
+            room_instance as f32,
+        ]),
         usage: BufferUsages::UNIFORM,
     });
     // One bind group per DISTINCT pool class this region touches; items collapse to slots.
@@ -705,31 +889,175 @@ fn kill_bit(killed: &[u64], i: usize) -> u32 {
     )
 }
 
-/// The per-frame view bind group (group 0): bevy's view uniform + the shared light buffer —
-/// the SAME `wow_shared_light` storage every material binds (1429: identical lighting by
-/// construction).
+/// The retained pass's extra bind group (group 2): the shared light buffer — the SAME
+/// `wow_shared_light` storage every material binds (1429: identical lighting by construction) —
+/// Group 0 is Bevy's standard mesh-view bind group, which supplies the view matrices,
+/// directional-light records, and shadow textures.
 #[derive(Resource)]
-struct GxViewBind(BindGroup);
+struct GxLightBind(BindGroup);
+
+/// MONKEY (room gate): the persistent room-claim storage buffer (group 2, binding 1). Written whole
+/// every frame from the extracted [`crate::lighting::RoomClaimTable`] — 32 KB since MONKEY (soft
+/// portal claims) widened the record from 8 to 32 words (the per-claim fade), one `write_buffer`,
+/// and the table is rebuilt from scratch by the packer anyway, so there is nothing cheaper to
+/// diff against. Persistent so the per-region bind groups that reference it never need rebuilding.
+#[derive(Resource)]
+struct GxRoomClaims(Buffer);
+
+fn prepare_room_claims(
+    queue: Res<RenderQueue>,
+    buffer: Option<Res<GxRoomClaims>>,
+    claims: Option<Res<crate::lighting::RoomClaimTable>>,
+    // MONKEY (torch lane perf): the words last actually uploaded, keyed by the buffer they went to.
+    mut last: Local<Option<(BufferId, Vec<u32>)>>,
+) {
+    let (Some(buffer), Some(claims)) = (buffer, claims) else {
+        return;
+    };
+    // MONKEY (torch lane perf): skip the write when the table is bit-identical to what is already
+    // in the buffer. The packer does rebuild it from scratch every frame, but the RESULT is
+    // unchanged for as long as the player stands in one room with the same fixtures claiming it —
+    // which is most of the time indoors. A 32 KB `memcmp` costs a fraction of the 32 KB staging
+    // copy it saves, and the comparison is against what we WROTE, so it cannot disagree with the
+    // buffer's real contents.
+    let id = buffer.0.id();
+    if last.as_ref().is_some_and(|(b, w)| *b == id && w[..] == claims.0[..]) {
+        return;
+    }
+    queue.write_buffer(&buffer.0, 0, bytemuck::cast_slice(&claims.0[..]));
+    // Reuse the cache's allocation where there is one — this runs on a frame where the claims
+    // genuinely changed, and a fresh 32 KB `Vec` per such frame would be churn for nothing.
+    if let Some((b, w)) = last.as_mut() {
+        if *b == id {
+            w.copy_from_slice(&claims.0[..]);
+            return;
+        }
+    }
+    *last = Some((id, claims.0.to_vec()));
+}
 
 fn prepare_view_bind(
     mut commands: Commands,
     pipes: Res<GxPipelines>,
     pipeline_cache: Res<PipelineCache>,
     render_device: Res<RenderDevice>,
-    view_uniforms: Res<ViewUniforms>,
     light: Option<Res<crate::lighting::SharedLightBuffer>>,
+    claims: Option<Res<GxRoomClaims>>,
 ) {
-    let (Some(view_binding), Some(light)) = (view_uniforms.uniforms.binding(), light) else {
+    let (Some(light), Some(claims)) = (light, claims) else {
         return;
     };
-    let layout = pipeline_cache.get_bind_group_layout(&pipes.view_layout);
-    commands.insert_resource(GxViewBind(render_device.create_bind_group(
-        "static_gx_view",
+    let layout = pipeline_cache.get_bind_group_layout(&pipes.light_layout);
+    commands.insert_resource(GxLightBind(render_device.create_bind_group(
+        "static_gx_light",
         &layout,
-        &BindGroupEntries::sequential((view_binding, light.0.as_entire_binding())),
+        &BindGroupEntries::sequential((
+            light.0.as_entire_binding(),
+            claims.0.as_entire_binding(),
+        )),
     )));
 }
 
+/// The retained pass's group-3 bind group (MONKEY, torch shadows Phase 1): the interior torch depth
+/// array (Phase 3A: the shared [`super::torch_depth::TorchDepthImage`]'s `GpuImage` D2Array view —
+/// the same texture the entity receiver binds through its material) + static_gx's own comparison
+/// sampler (from [`super::torch_depth::TorchDepthTargets`]) and the `TorchTable` uniform packed from
+/// the extracted [`super::torch_depth::TorchShadowViews`] by the shared
+/// [`super::torch_depth::TorchTableUniform::pack`]. ALWAYS built (with `count = 0` and a zero table
+/// when the lane is off or absent) so the pipeline's group 3 is never left unbound — except while the
+/// shared image is not yet resident, when static_gx skips the frame (the node early-outs on a
+/// missing `GxTorchBind`).
+/// MONKEY (torch lane perf): the bind group is CACHED with the exact table bytes and the depth
+/// texture it was built over. Both used to be rebuilt from scratch every frame — a fresh 6416-byte
+/// uniform buffer plus a fresh `BindGroup` object, for contents that are identical on every frame
+/// the player stands still. Nothing else about the group can change while those two match: the
+/// sampler and the layout are `RenderStartup` singletons, and the texture id covers the one case
+/// where the shared image is ever re-prepared.
+#[derive(Resource)]
+struct GxTorchBind {
+    group: BindGroup,
+    table: super::torch_depth::TorchTableUniform,
+    texture: TextureId,
+}
+
+fn prepare_torch_bind(
+    mut commands: Commands,
+    pipes: Res<GxPipelines>,
+    pipeline_cache: Res<PipelineCache>,
+    render_device: Res<RenderDevice>,
+    targets: Option<Res<super::torch_depth::TorchDepthTargets>>,
+    views: Option<Res<super::torch_depth::TorchShadowViews>>,
+    image: Option<Res<super::torch_depth::TorchDepthImage>>,
+    images: Res<RenderAssets<GpuImage>>,
+    cached: Option<ResMut<GxTorchBind>>,
+) {
+    // The sampler/pipeline are created in RenderStartup; the shared image is prepared by the
+    // render-asset pass (before this set). Without either, group 3 has nothing to bind this frame.
+    let Some(targets) = targets else {
+        return;
+    };
+    let Some(gpu_image) = image.as_ref().and_then(|h| images.get(&h.0)) else {
+        return;
+    };
+    let table = super::torch_depth::TorchTableUniform::pack(views.as_deref());
+    let texture = gpu_image.texture.id();
+    // The compare is on the BYTES, not on the source resource's change tick: `TorchShadowViews` is
+    // republished every frame by the app lane whether or not anything in it moved, so a change
+    // detector here would never fire negative.
+    if let Some(mut cached) = cached {
+        if cached.texture == texture
+            && bytemuck::bytes_of(&cached.table) == bytemuck::bytes_of(&table)
+        {
+            return;
+        }
+        // Rebuild in place — one `Res` write instead of a deferred `insert_resource` per frame.
+        *cached = GxTorchBind {
+            group: build_torch_bind(&pipes, &pipeline_cache, &render_device, gpu_image,
+                targets.sampler(), &table),
+            table,
+            texture,
+        };
+        return;
+    }
+    commands.insert_resource(GxTorchBind {
+        group: build_torch_bind(&pipes, &pipeline_cache, &render_device, gpu_image,
+            targets.sampler(), &table),
+        table,
+        texture,
+    });
+}
+
+/// The group-3 bind group itself (see [`GxTorchBind`]) — the uniform buffer is created here because
+/// its contents ARE the cache key, so a new buffer is only ever made on a frame the table moved.
+fn build_torch_bind(
+    pipes: &GxPipelines,
+    pipeline_cache: &PipelineCache,
+    render_device: &RenderDevice,
+    gpu_image: &GpuImage,
+    sampler: &Sampler,
+    table: &super::torch_depth::TorchTableUniform,
+) -> BindGroup {
+    let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+        label: Some("static_gx_torch_table"),
+        contents: bytemuck::bytes_of(table),
+        usage: BufferUsages::UNIFORM,
+    });
+    let layout = pipeline_cache.get_bind_group_layout(&pipes.torch_layout);
+    render_device.create_bind_group(
+        "static_gx_torch",
+        &layout,
+        &BindGroupEntries::sequential((
+            // MONKEY (live bank rank): the image's default D2Array view spans all 144 layers:
+            // 96 STATIC faces addressed by matrices plus 48 LIVE copies addressed by the
+            // ascending set-bit rank in `count.z`. (wgpu's default view for a
+            // multi-layer 2D texture; `torch_depth.rs` spells out the guarantee).
+            &gpu_image.texture_view,
+            sampler,
+            buffer.as_entire_binding(),
+        )),
+    )
+}
+
 #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
 struct StaticGxLabel;
 
@@ -741,6 +1069,13 @@ impl ViewNode for StaticGxNode {
         &'static ViewTarget,
         &'static ViewDepthTexture,
         &'static ViewUniformOffset,
+        &'static ViewLightsUniformOffset,
+        &'static ViewFogUniformOffset,
+        &'static ViewLightProbesUniformOffset,
+        &'static ViewScreenSpaceReflectionsUniformOffset,
+        &'static ViewEnvironmentMapUniformOffset,
+        Option<&'static OrderIndependentTransparencySettingsOffset>,
+        &'static MeshViewBindGroup,
         // The world camera only — a booth bake must never receive world cells (see the marker).
         &'static StaticGxView,
     );
@@ -749,7 +1084,19 @@ impl ViewNode for StaticGxNode {
         &self,
         _graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (target, depth, view_offset, _marker): QueryItem<'w, '_, Self::ViewQuery>,
+        (
+            target,
+            depth,
+            view_offset,
+            view_lights,
+            view_fog,
+            view_light_probes,
+            view_ssr,
+            view_environment_map,
+            maybe_oit,
+            view_bind,
+            _marker,
+        ): QueryItem<'w, '_, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let _t = super::gx_perf_guard(4);
@@ -760,7 +1107,13 @@ impl ViewNode for StaticGxNode {
         let cache = world.resource::<GxGpuCache>();
         let pipes = world.resource::<GxPipelines>();
         let pipeline_cache = world.resource::<PipelineCache>();
-        let Some(view_bind) = world.get_resource::<GxViewBind>() else {
+        let Some(light_bind) = world.get_resource::<GxLightBind>() else {
+            return Ok(());
+        };
+        // MONKEY (torch shadows Phase 1): group 3 is part of every static_gx pipeline now, so it
+        // must be bound before any draw. `prepare_torch_bind` always builds it (count 0 when the
+        // lane is off); a missing one means the depth targets weren't ready — skip the frame.
+        let Some(torch_bind) = world.get_resource::<GxTorchBind>() else {
             return Ok(());
         };
         let meshes = world.resource::<RenderAssets<RenderMesh>>();
@@ -822,7 +1175,18 @@ impl ViewNode for StaticGxNode {
             occlusion_query_set: None,
         });
         let span = diagnostics.pass_span(&mut pass, "static_gx");
-        pass.set_bind_group(0, &view_bind.0, &[view_offset.offset]);
+        let mut view_offsets = vec![
+            view_offset.offset,
+            view_lights.offset,
+            view_fog.offset,
+            **view_light_probes,
+            **view_ssr,
+            **view_environment_map,
+        ];
+        if let Some(oit) = maybe_oit {
+            view_offsets.push(oit.offset);
+        }
+        pass.set_bind_group(0, &view_bind.main, &view_offsets);
         for (gpu, draw, sel) in &resolved {
             let Some(mesh) = meshes.get(draw.mesh.id()) else {
                 continue;
@@ -851,6 +1215,8 @@ impl ViewNode for StaticGxNode {
                 }
                 pass.set_render_pipeline(ready[&(run.cutout, run.two_sided)]);
                 pass.set_bind_group(1, &gpu.bind_groups[run.slot].1, &[]);
+                pass.set_bind_group(2, &light_bind.0, &[]);
+                pass.set_bind_group(3, &torch_bind.group, &[]);
                 pass.draw_indexed(
                     (islice.range.start + run.index_range.start)
                         ..(islice.range.start + run.index_range.end),
@@ -877,6 +1243,9 @@ pub(super) fn build(app: &mut App) {
     ));
     app.init_resource::<GxWorld>();
     app.add_systems(Update, mark_world_camera);
+    // MONKEY (torch shadows Phase 1): the depth-map targets + node (its own RenderStartup + graph
+    // wiring). Built before we borrow the render app below — the two borrows are sequential.
+    super::torch_depth::build(app);
     let Some(render_app) = app.get_sub_app_mut(bevy::render::RenderApp) else {
         return;
     };
@@ -888,7 +1257,10 @@ pub(super) fn build(app: &mut App) {
             Render,
             (
                 prepare_static_gx.in_set(RenderSystems::PrepareResources),
+                // MONKEY (room gate): before the bind groups, beside the shared light's upload.
+                prepare_room_claims.in_set(RenderSystems::PrepareResources),
                 prepare_view_bind.in_set(RenderSystems::PrepareBindGroups),
+                prepare_torch_bind.in_set(RenderSystems::PrepareBindGroups),
             ),
         )
         .add_render_graph_node::<ViewNodeRunner<StaticGxNode>>(Core3d, StaticGxLabel)
@@ -962,6 +1334,8 @@ mod tests {
             order: 0,
             sidn: [0; 3],
             slot: 0,
+            ext_night: false,
+            enclosed: false,
         }
     }
 
diff --git a/crates/benilla-world/src/static_gx/shadow.rs b/crates/benilla-world/src/static_gx/shadow.rs
new file mode 100644
index 00000000..ed86e130
--- /dev/null
+++ b/crates/benilla-world/src/static_gx/shadow.rs
@@ -0,0 +1,164 @@
+//! MONKEY (world shadows): CPU collection of the RETAINED static world's geometry as shadow-caster
+//! triangles — the same source-submesh reachback `pick.rs` does for ray hits, appended into a
+//! world-space triangle list. The world-shadow lane (`benilla-app::world_shadow`) appends
+//! these into a cached, layer-31 caster mesh so trees and buildings cast into the SAME Bevy
+//! directional shadow map as characters, instead of only their baked shading.
+//!
+//! The retained pass recentres vertices per cell and bakes them into a `RENDER_WORLD`-only mesh
+//! whose CPU data is gone after extract — so we go to the SOURCE the divert kept
+//! ([`super::GxItem::geometry`] + [`super::GxItem::transform`]), exactly as `pick.rs` does, and
+//! reconstruct world space directly: `transform.transform_point(wow_to_bevy(pos))`.
+
+use benilla_assets::coords::wow_to_bevy;
+use bevy::asset::AssetId;
+use bevy::image::Image;
+use bevy::platform::collections::HashMap;
+use bevy::prelude::*;
+
+use super::{GxCell, StaticGx};
+
+/// One alpha-tested foliage caster group: every resident cutout batch that shares a single leaf
+/// texture, merged into one world-space triangle list carrying UVs. The character-shadow system
+/// drives one layer-31 caster entity + [`super::super`]-side `CutoutShadowCasterMaterial` per
+/// bucket, so the shadow pass can sample this texture and discard transparent texels — casting a
+/// leaf-SHAPED silhouette instead of the solid box a positions-only proxy throws.
+pub struct CutoutBucket {
+    /// The grouping key: the leaf sheet's asset id (stable across rebuilds, so the caller keys a
+    /// persistent caster entity off it rather than churning one per rebuild).
+    pub texture_id: AssetId<Image>,
+    /// A live strong handle to the same leaf image the forward pass draws — put straight on the
+    /// caster material so its sampler inherits the image's own clamp/repeat address mode.
+    pub texture: Handle<Image>,
+    /// World-space (Bevy) caster positions.
+    pub positions: Vec<[f32; 3]>,
+    /// Per-vertex UVs, parallel to [`Self::positions`] — what the prepass fragment samples.
+    pub uvs: Vec<[f32; 2]>,
+    pub indices: Vec<u32>,
+}
+
+impl StaticGx {
+    /// Append world-space (Bevy) shadow-caster triangles for resident static geometry whose
+    /// placement anchor is within `reach` of `center`, onto the caller's buffers (the character
+    /// system recycles them across rebuilds). Whole triangles referencing out-of-range indices are
+    /// dropped — a truncated submesh must never rewire a later triangle into garbage (mirrors
+    /// `character_shadow::append_triangles`).
+    ///
+    /// FIRST CUT: a currently-EXILED (distance-faded) static item also draws as an entity, so it is
+    /// collected by both lanes and its geometry lands in the caster twice — harmless (identical
+    /// triangles at identical depth), a follow-up can gate on the fader state.
+    pub fn append_shadow_triangles(
+        &self,
+        center: Vec3,
+        reach: f32,
+        positions: &mut Vec<[f32; 3]>,
+        indices: &mut Vec<u32>,
+    ) {
+        let r2 = reach * reach;
+        let mut push = |cell: &GxCell| {
+            for item in &cell.items {
+                // Distance gate on the placement anchor BEFORE any vertex work.
+                if item.transform.translation.distance_squared(center) > r2 {
+                    continue;
+                }
+                // MONKEY (world shadows): the SOLID caster skips alpha-cutout foliage — a leaf card
+                // is a big flat quad, and cast solid here (this mesh has no texture) it would be an
+                // ugly rectangular BOX on the ground. Trunks/buildings/fences (opaque) cast their
+                // real silhouette here; cutout foliage is collected leaf-shaped by
+                // [`Self::collect_cutout_shadow_triangles`] instead. (`item.cutout` == AlphaTest.)
+                if item.cutout {
+                    continue;
+                }
+                let base = positions.len() as u32;
+                let t = item.transform;
+                positions.extend(
+                    item.geometry
+                        .positions
+                        .iter()
+                        .map(|p| t.transform_point(wow_to_bevy(*p)).to_array()),
+                );
+                let added = positions.len() as u32 - base;
+                for tri in item.geometry.indices.chunks_exact(3) {
+                    if tri.iter().all(|i| *i < added) {
+                        indices.extend(tri.iter().map(|i| base + *i));
+                    }
+                }
+            }
+        };
+        for cell in self.cells.values() {
+            push(cell);
+        }
+        for cell in self.wmos.values() {
+            push(cell);
+        }
+        for cell in self.props.values() {
+            push(cell);
+        }
+    }
+
+    /// Collect the resident ALPHA-CUTOUT geometry (tree canopies, bushes, cattails — the leaf
+    /// cards the solid caster skips) as one [`CutoutBucket`] per distinct leaf texture, each a
+    /// world-space triangle list with UVs. The character-shadow system drives one alpha-tested
+    /// layer-31 caster per bucket, so a canopy discards its transparent texels in the shadow pass
+    /// and casts a leaf-SHAPED silhouette. Grouping by texture is what lets a single draw carry
+    /// one sheet: a zone's canopies draw from only a handful of sheets, so this yields a handful
+    /// of buckets. Range-gates on the placement anchor exactly like [`Self::append_shadow_triangles`].
+    ///
+    /// A cutout batch without a texture handle, or whose UVs don't parallel its positions, is
+    /// skipped (it can't be alpha-tested — better no shadow than a wrong solid box).
+    pub fn collect_cutout_shadow_triangles(&self, center: Vec3, reach: f32) -> Vec<CutoutBucket> {
+        let r2 = reach * reach;
+        let mut buckets: HashMap<AssetId<Image>, CutoutBucket> = HashMap::new();
+        let mut push = |cell: &GxCell| {
+            for item in &cell.items {
+                if !item.cutout {
+                    continue;
+                }
+                let (Some(texture_id), Some(texture)) = (item.texture, item.texture_handle.as_ref())
+                else {
+                    continue;
+                };
+                if item.transform.translation.distance_squared(center) > r2 {
+                    continue;
+                }
+                let geometry = &item.geometry;
+                // UVs must parallel positions to map per-vertex — a cutout card that lost its UVs
+                // (should never happen) can't be sampled, so drop it rather than box it out.
+                if geometry.uvs.len() != geometry.positions.len() {
+                    continue;
+                }
+                let bucket = buckets.entry(texture_id).or_insert_with(|| CutoutBucket {
+                    texture_id,
+                    texture: texture.clone(),
+                    positions: Vec::new(),
+                    uvs: Vec::new(),
+                    indices: Vec::new(),
+                });
+                let base = bucket.positions.len() as u32;
+                let t = item.transform;
+                bucket.positions.extend(
+                    geometry
+                        .positions
+                        .iter()
+                        .map(|p| t.transform_point(wow_to_bevy(*p)).to_array()),
+                );
+                bucket.uvs.extend_from_slice(&geometry.uvs);
+                let added = bucket.positions.len() as u32 - base;
+                for tri in geometry.indices.chunks_exact(3) {
+                    if tri.iter().all(|i| *i < added) {
+                        bucket.indices.extend(tri.iter().map(|i| base + *i));
+                    }
+                }
+            }
+        };
+        for cell in self.cells.values() {
+            push(cell);
+        }
+        for cell in self.wmos.values() {
+            push(cell);
+        }
+        for cell in self.props.values() {
+            push(cell);
+        }
+        buckets.into_values().collect()
+    }
+}
diff --git a/crates/benilla-world/src/static_gx/torch_depth.rs b/crates/benilla-world/src/static_gx/torch_depth.rs
new file mode 100644
index 00000000..0feea3e1
--- /dev/null
+++ b/crates/benilla-world/src/static_gx/torch_depth.rs
@@ -0,0 +1,1352 @@
+//! MONKEY (static torch cache): persistent six-face static maps for up to sixteen fixtures.
+//! Bevy point-light clustering is disabled on the world view, so this dedicated depth lane
+//! supplies both receivers. Static geometry renders only on promotion/residency/fixture changes;
+//! nearest-N fixtures copy their six cached faces into a live bank and overlay moving entities.
+//! With the defaults (12 resident, 4 dynamic), a steady frame records 24 copies, 24 entity draws
+//! and zero static draws. At most two dirty fixtures rebuild per frame; physical slots survive
+//! contribution ranking and cross-fades. See benilla_app::torch_shadow for eligibility and keys.
+//!
+//! **Phase 3A: the depth array is a shared `Image` ASSET**, not a render-world-owned texture. The
+//! entity receiver (`wow_model.wgsl`, every unit/NPC/GameObject/interior prop) has no spare bind
+//! group — a Bevy material draw sets groups 0/1/2 only — so its torch bindings ride the material's
+//! own group as `Handle<Image>` + raw `Buffer` fields (`WowModelExt::torch_depth`/`torch_buf`),
+//! and `AsBindGroup` resolves a `Handle<Image>` through `RenderAssets<GpuImage>`. So the image
+//! ([`TorchDepthImage`]) is created ONCE at app startup in the main world (always — an absent image
+//! would stall every model material's bind group and blank every model), extracted here, and BOTH
+//! receivers read the same `GpuImage`: the depth node renders into per-layer views of its texture,
+//! static_gx binds its D2Array view, the material binds the same view + the image's comparison
+//! sampler. The 16-fixture table gets the same treatment ([`SharedTorchBuffer`]: one raw buffer,
+//! rewritten in place every frame from [`TorchShadowViews`] with the SAME [`TorchTableUniform`]
+//! bytes static_gx's group-3 uniform carries).
+//!
+//! Reverse-Z throughout (the whole engine is — `capture::depth_probe`): the depth pass clears to 0.0
+//! (= far), keeps the nearest surface with `GreaterEqual`, and the comparison sampler is `GreaterEqual`
+//! too. The per-fixture `view_proj` is a reverse-Z perspective built app-side in f64 (fixtures sit at
+//! absolute Bevy world coordinates, ~9,300 out) and downcast to f32.
+
+use std::hash::{Hash, Hasher};
+use std::sync::Mutex;
+
+use bevy::asset::RenderAssetUsages;
+use bevy::core_pipeline::core_3d::graph::{Core3d, Node3d};
+use bevy::ecs::query::QueryItem;
+use bevy::ecs::system::SystemParam;
+use bevy::image::{ImageCompareFunction, ImageFilterMode, ImageSampler, ImageSamplerDescriptor};
+// Bevy's OWNED vertex-buffer layout (the pipeline descriptor wants this, not wgpu's borrowed one).
+use bevy::mesh::VertexBufferLayout;
+use bevy::prelude::*;
+use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
+use bevy::render::mesh::allocator::MeshAllocator;
+use bevy::render::mesh::{RenderMesh, RenderMeshBufferInfo};
+use bevy::render::render_asset::RenderAssets;
+use bevy::render::render_graph::{
+    NodeRunError, RenderGraphContext, RenderGraphExt, RenderLabel, ViewNode, ViewNodeRunner,
+};
+use bevy::render::render_resource::binding_types::uniform_buffer_sized;
+use bevy::render::render_resource::*;
+use bevy::render::renderer::{RenderContext, RenderDevice, RenderQueue};
+use bevy::render::texture::GpuImage;
+use bevy::render::{Render, RenderApp, RenderStartup, RenderSystems};
+use bytemuck::Zeroable;
+
+use super::render::StaticGxView;
+// MONKEY (torch owner exclusion): the placement identity both caster lanes carry, and the
+// subsystem tag that keeps a building's own batches apart from the props standing in it.
+use crate::interact::WorldObject;
+use crate::model_render::ModelKind;
+use bevy::math::Affine3A;
+use benilla_assets::materials::TorchBinds;
+
+/// MONKEY (live bank rank): each 512-square Depth32 face is 1 MiB. Sixteen static cubes plus
+/// eight compact live overlays cost 144 MiB; 384-square faces would cost 81 MiB.
+const TORCH_MAP_EDGE: u32 = 512;
+pub(crate) const MAX_TORCH_MAPS: usize = 16;
+const MAX_TORCH_DYNAMIC: usize = 8;
+/// MONKEY (moving fixture): how many slots may be FULLY DYNAMIC in one frame - re-rendered from
+/// scratch (static geometry AND entities) because their fixture is physically moving. Two, because
+/// each one costs a whole cached slot's work every frame: the CPU gather that the static cache
+/// exists to amortise, plus the render-world depth rebuild. The app lane picks the two by score and
+/// fast-fades the rest ([`benilla_app::torch_shadow`]); the same number bounds the rebuild budget
+/// in [`torch_cache_plan`], so a moving fixture can never starve a resident room's static maps of
+/// their own (separate) two.
+pub(crate) const TORCH_MOVING_MAX: usize = 2;
+pub(crate) const CUBE_FACES: usize = 6;
+/// MONKEY (live bank rank): matrix count stays 96, independent of texture capacity. Static
+/// layers 0..96 stay slot-addressed; live layers 96..144 follow ascending dynamic-mask rank.
+pub(crate) const MAX_TORCH_LAYERS: usize = MAX_TORCH_MAPS * CUBE_FACES;
+const TORCH_TEXTURE_LAYERS: usize = MAX_TORCH_LAYERS + MAX_TORCH_DYNAMIC * CUBE_FACES;
+/// MONKEY (static torch cache): count@0 (16), positions@16 (256), view_projs@272 (6144).
+/// Total 6416 bytes, identical under WGSL uniform/storage alignment. count.z is the live-bank
+/// bit mask, count.w reserved. Both WGSL TorchTable copies and render.rs MUST agree with this.
+pub(crate) const TORCH_TABLE_BYTES: u64 = 6416;
+/// MONKEY (outdoor torch shadows): `count.w` bit 0 — the exterior receiver lane's live gate. Keep
+/// in sync with `TORCH_EXT_LANE` in BOTH `static_gx.wgsl` and `wow_model.wgsl`.
+const TORCH_EXT_LANE: u32 = 1;
+
+/// MONKEY (torch owner exclusion): WHO a light belongs to — the identity a caster gather uses to
+/// drop a fixture's OWN body out of the fixture's OWN shadow map.
+///
+/// The bug this answers. A synthetic fire light is placed AT THE FLAME, and a flame is *inside* the
+/// thing that burns it: inside a lantern's glass housing, inside a campfire's ring of logs, at the
+/// head of a wall torch. Nothing in this lane knew the two belonged together — the light is an ECS
+/// entity, the mesh is either a retained [`super::GxItem`] or a model-part entity, and the
+/// placement that spawned both is not carried on either side — so the fixture was the nearest
+/// occluder on all six of its cube faces and blacked out its own pool. That is the moving bright
+/// WEDGE on the ground under the inn's swinging lantern (the housing shadowing every direction but
+/// one gap), the BLACK SQUARE under the wall torch by the crate, and the dark blotches under the
+/// faire torches.
+///
+/// The first attempt approximated ownership by PROXIMITY (the retired `TORCH_EXT_SELF_EXCLUDE`:
+/// drop an item whose whole bounding sphere lies within 2.5 yd of the flame). That covers a
+/// campfire — a prop that is a ball around its own flame — and essentially nothing else: a lantern
+/// hanging off a 4-yd post, or a torch on a tall bracket, has bounds that run all the way to the
+/// ground and is never "wholly within 2.5 yd" of anything. So ownership is carried EXPLICITLY here,
+/// and proximity is demoted to a bounded fallback ([`torch_bound_contains`]).
+///
+/// Two shapes, because lights reach the world by two routes:
+///  * [`Self::Placement`] — a placed ADT doodad's or WMO prop's own M2 light
+///    (`terrain_stream::spawn`'s `spawn_lights_for`). The key is the placement's
+///    [`WorldObject`] identity, because that is the one identity BOTH caster lanes already carry:
+///    the retained `GxItem` holds it as an `Arc`, and the entity path's parts hold a CLONE of it.
+///    Compared by CONTENT (kind + placement uniqueId + label hash) for exactly that reason — an
+///    `Arc` pointer would match the retained half and never the entity half.
+///  * [`Self::Instance`] — an entity-hosted light (`entities::carried_light`): a GameObject
+///    brazier, a placed campfire, an NPC's torch. Those hang under the host model's FRAME entity,
+///    which no `WorldObject` is available at, so the frame IS the identity and a caster part is
+///    "mine" iff it is a descendant of it.
+///
+/// Deliberately NOT written onto a WMO's authored MOLT fixtures. A MOLT light has no model of its
+/// own, and its placement identity is the BUILDING's — tagging it would exclude every wall, floor
+/// and pillar of the building from its own torch's map, i.e. delete the interior shadow lane.
+#[derive(Component, Clone, Copy, PartialEq, Eq, Debug)]
+pub enum LightOwner {
+    Placement {
+        kind: ModelKind,
+        /// The placement uniqueId (`WorldObject::id`).
+        id: u32,
+        /// A hash of the model path, so two identical lanterns in one building are told apart from
+        /// its barrels and its chairs (WMO props all share their BUILDING's uniqueId).
+        label: u64,
+    },
+    Instance(Entity),
+}
+
+impl LightOwner {
+    /// The placement key of `object` — the value both caster lanes are compared against.
+    pub fn placement(object: &WorldObject) -> Self {
+        Self::Placement {
+            kind: object.kind,
+            id: object.id,
+            label: label_hash(&object.label),
+        }
+    }
+
+    /// Does this owner name `object`? The two SCALAR lanes are tested first and the label hash only
+    /// if they both match: this runs per candidate item inside a 48-yd gather, and hashing a model
+    /// path for every barrel in a city would be real cost for an answer that is almost always "no".
+    pub fn owns(&self, object: &WorldObject) -> bool {
+        match *self {
+            Self::Placement { kind, id, label } => {
+                id == object.id && kind == object.kind && label == label_hash(&object.label)
+            }
+            Self::Instance(_) => false,
+        }
+    }
+
+    /// The host model frame, for the entity lane's ancestry test — `None` for a placed light.
+    pub fn instance(&self) -> Option<Entity> {
+        match *self {
+            Self::Instance(e) => Some(e),
+            Self::Placement { .. } => None,
+        }
+    }
+}
+
+fn label_hash(label: &str) -> u64 {
+    let mut hash = std::collections::hash_map::DefaultHasher::new();
+    label.hash(&mut hash);
+    hash.finish()
+}
+
+/// MONKEY (torch owner exclusion): how far OUTSIDE its own bounds a flame may sit and still count
+/// as being inside the fixture (yd). A synthesised light is positioned from the model's flame
+/// EMITTER, which routinely sits a finger's width proud of the housing it burns in; 0.3 yd closes
+/// that gap without reaching anything the fixture merely stands next to.
+const TORCH_SELF_PAD: f32 = 0.3;
+/// MONKEY (torch owner exclusion): the containment fallback applies only to FIXTURE-SIZED items —
+/// this is the cap on the transformed bounding-sphere radius (yd).
+///
+/// Unbounded containment would be a disaster, and specifically on the lane that works today: a WMO
+/// group's wall batch is a ROOM-sized box, it trivially "contains" every candle in the room, and
+/// excluding it would delete that room's shadows and leak the candle straight through its walls.
+/// 6 yd covers a tall lamp post, a gallows-arm lantern bracket and a bonfire whole, and is an order
+/// of magnitude under any wall, floor, building or terrain batch.
+const TORCH_SELF_MAX_EXTENT: f32 = 6.0;
+/// MONKEY (torch owner exclusion): the last resort, for items whose bounds are DEGENERATE (a candle
+/// flame card, a zero-extent helper) where containment cannot decide anything. An item whose WHOLE
+/// bounding sphere lies inside this of the flame is the flame's own body by construction. This is
+/// the surviving half of the retired `TORCH_EXT_SELF_EXCLUDE`, shrunk from 2.5 yd to 0.6 so that it
+/// can no longer swallow the crate, fence post or barrel standing beside the fire.
+const TORCH_SELF_TINY: f32 = 0.6;
+
+/// **The app→render publication** (`benilla_app::torch_shadow` writes it each frame, extracted here):
+/// the promoted fixtures' cube-face matrices, world positions and static mesh revisions.
+/// `count` is the sparse slot high-water mark (0 when the lane is off).
+#[derive(Resource, Clone, ExtractResource)]
+pub struct TorchShadowViews {
+    pub count: u32,
+    // MONKEY (static torch cache): sparse physical slots; count is the high-water mark, not the
+    // population. Holes have weight zero. ready_mask is assigned only in render preparation.
+    pub dynamic_mask: u32,
+    pub ready_mask: u32,
+    /// MONKEY (torch caster selection): the live PCF tap-radius scale (`interiorShadowSoft`,
+    /// 0.5..3). Carried here rather than in `DynamicInteriors` because it belongs to the shadow
+    /// table's own bytes — [`TorchTableUniform::pack`] puts it in the otherwise-padding `count.y`.
+    pub soft: f32,
+    /// MONKEY (shadow floor): the live torch SHADOW STRENGTH (`torchShadowStrength`, 0..1, default
+    /// 0.7) - how much of the direct term a fully shadowed fragment loses. It rides the same
+    /// `count.y` word as [`Self::soft`] (high half; see [`TorchTableUniform::pack`]) and the
+    /// receivers fold it into the slot's cross-fade weight, so a shadow darkens the direct arm to
+    /// 30 % instead of to nothing. The fill/ambient arms never saw this factor and are untouched.
+    pub strength: f32,
+    /// MONKEY (moving fixture): which slots are MOVING this frame - a carried/unit-hosted fixture
+    /// or one that has drifted off the position its cached map was baked at. They get their own
+    /// rebuild budget in [`torch_cache_plan`] ([`TORCH_MOVING_MAX`]) ahead of the resident slots,
+    /// because a moving fixture's map is WRONG (not merely stale) the moment it is deferred: the
+    /// projections republish from the live position every frame while the depth still holds the
+    /// old one, which is the smeared, lagging pool the imp dragged across the inn floor.
+    pub moving_mask: u32,
+    /// MONKEY (outdoor torch shadows): does the EXTERIOR receiver lane run this frame? The app lane
+    /// sets it when `exteriorShadows` is on, the sun is below the daylight threshold, AND at least
+    /// one promoted slot is an exterior fixture. It rides to the receivers in the table's
+    /// `count.w` bit 0 (the word that has been reserved padding since the table was written), and
+    /// it is the ONE uniform read every exterior-lane cost in `static_gx.wgsl`/`wow_model.wgsl`
+    /// hangs off — by day, or with the cvar off, the receivers are the code they always were.
+    pub exterior: bool,
+    /// `positions[i].xyz` = fixture world position (absolute Bevy), `.w` = the slot's FADE WEIGHT
+    /// `0..1` (MONKEY, torch caster selection). The `.w` lane used to carry the fixture's range,
+    /// which no shader ever read; it now carries the cross-fade, and both receivers return
+    /// `mix(1.0, shadow, w)` so a promoted fixture's shadow ramps in over ~1/3 s and a demoted one
+    /// ramps out before its slot is reused — the fix for the pop this whole change is about.
+    pub positions: [Vec4; MAX_TORCH_MAPS],
+    /// The reverse-Z `view_proj` of cube face `f` of fixture `i` at `[i * CUBE_FACES + f]`
+    /// (identity in unused slots).
+    pub view_projs: [Mat4; MAX_TORCH_LAYERS],
+    /// MONKEY (static torch cache): fresh asset identity per geometry revision/slot owner;
+    /// None while the app's two-rebuild budget defers this slot. Static uploads must be resident
+    /// before depth can be marked valid. Empty resident meshes still clear all six faces.
+    pub caster_meshes: [Option<AssetId<Mesh>>; MAX_TORCH_MAPS],
+    /// MONKEY (static torch cache): moving/skinned entities only, regenerated each frame.
+    pub entity_mesh: Option<AssetId<Mesh>>,
+}
+
+impl TorchShadowViews {
+    /// MONKEY (live bank rank): expose the allocation cap through the existing app resource.
+    pub const MAX_TORCH_DYNAMIC: usize = MAX_TORCH_DYNAMIC;
+    /// MONKEY (moving fixture): ONE definition of the moving budget, shared by the app lane that
+    /// picks the slots and the render plan that rebuilds them.
+    pub const MAX_TORCH_MOVING: usize = TORCH_MOVING_MAX;
+
+    /// MONKEY (live bank rank): WGSL countOneBits(mask & ((1u << slot) - 1u)). Use the
+    /// FINAL ready-filtered mask for rendering; app traces describe only requested ranks.
+    pub fn live_rank(dynamic_mask: u32, slot: usize) -> usize {
+        debug_assert!(slot < MAX_TORCH_MAPS);
+        (dynamic_mask & ((1u32 << slot) - 1)).count_ones() as usize
+    }
+}
+
+/// Hand-written because `[Mat4; 96]` has no `Default` — std only derives array `Default` up to
+/// `N = 32`, so the derive that worked at 24 layers stops compiling at 96. (It also lets `soft`
+/// default to a sane `1.0` rather than a zero tap radius.)
+impl Default for TorchShadowViews {
+    fn default() -> Self {
+        Self {
+            count: 0,
+            dynamic_mask: 0,
+            ready_mask: 0,
+            soft: 1.0,
+            // MONKEY (shadow floor): 1.0 = the pre-feature pitch-black shadow, so a views value
+            // that never went through the cvar cannot silently lighten the world.
+            strength: 1.0,
+            moving_mask: 0,
+            exterior: false,
+            positions: [Vec4::ZERO; MAX_TORCH_MAPS],
+            view_projs: [Mat4::ZERO; MAX_TORCH_LAYERS],
+            caster_meshes: [None; MAX_TORCH_MAPS],
+            entity_mesh: None,
+        }
+    }
+}
+
+/// MONKEY (torch shadows Phase 3A): the ONE shared torch depth array — a `Depth32Float`
+/// MONKEY (live bank rank): 512×512×144-layer `Image` asset (render, sample, copy-src/dst),
+/// no CPU data) whose sampler descriptor carries `compare: Some(GreaterEqual)`, so its `GpuImage`
+/// sampler is a real comparison sampler and its default view is a `D2Array` over all 144 layers
+/// (wgpu's default view dimension for a multi-layer 2D texture). Created ONCE at startup by
+/// [`new_torch_shared`] (always — regardless of the interior-shadow cvars — because every model
+/// material binds it; a missing image would stall every material's bind group), inserted in the
+/// main world so material construction can clone the handle, and cloned into the render world so
+/// the depth node and static_gx's group-3 prepare can look its `GpuImage` up.
+#[derive(Resource, Clone, ExtractResource)]
+pub struct TorchDepthImage(pub Handle<Image>);
+
+/// MONKEY (torch shadows Phase 3A): the shared 16-fixture torch TABLE buffer — 6416 bytes of
+/// [`TorchTableUniform`] (`STORAGE | COPY_DST`), the entity receiver's `torch_table` at material
+/// binding 93. Created once beside [`TorchDepthImage`], cloned into every model material, and
+/// rewritten in place every frame by [`upload_torch_table`] (render world, `PrepareResources`) —
+/// the exact pattern of the shared light buffer (`lighting::global_light::upload_light`).
+#[derive(Resource, Clone, ExtractResource)]
+pub struct SharedTorchBuffer(pub Buffer);
+
+/// The main-world pair of torch resources as the ONE system param a material-building site adds
+/// beside its `SharedLightBuffer` (several of those systems sit at Bevy's 16-param ceiling).
+/// [`Self::binds`] is `None` until [`new_torch_shared`] has run — the same "retry, don't bake
+/// against nothing" contract the light buffer gives those sites.
+#[derive(SystemParam)]
+pub struct TorchShared<'w> {
+    image: Option<Res<'w, TorchDepthImage>>,
+    table: Option<Res<'w, SharedTorchBuffer>>,
+}
+
+impl TorchShared<'_> {
+    /// The receiver bindings to clone into a `WowModelExt`, or `None` before startup created them.
+    pub fn binds(&self) -> Option<TorchBinds> {
+        Some(TorchBinds {
+            depth: self.image.as_ref()?.0.clone(),
+            table: self.table.as_ref()?.0.clone(),
+        })
+    }
+}
+
+/// Create the shared torch depth image + table buffer (main world, `Startup` — `RenderDevice` and
+/// `Assets<Image>` are both live there). Called by the asset foundation next to the shared light
+/// buffer so the pair exists before any material is built, whatever the cvars say.
+pub fn new_torch_shared(
+    device: &RenderDevice,
+    images: &mut Assets<Image>,
+) -> (TorchDepthImage, SharedTorchBuffer) {
+    let image = Image {
+        // A pure GPU render target: no CPU pixels, ever.
+        data: None,
+        texture_descriptor: TextureDescriptor {
+            label: Some("torch_depth"),
+            size: Extent3d {
+                width: TORCH_MAP_EDGE,
+                height: TORCH_MAP_EDGE,
+                depth_or_array_layers: TORCH_TEXTURE_LAYERS as u32,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Depth32Float,
+            // MONKEY (static torch cache): wgpu 27 transfer.rs permits partial ARRAY layers
+            // for depth, provided x/y cover the entire mip. Banks are disjoint subresources.
+            usage: TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING
+                | TextureUsages::COPY_SRC | TextureUsages::COPY_DST,
+            view_formats: &[],
+        },
+        // The receivers' `GreaterEqual` comparison sampler (reverse-Z: lit iff the fragment's own
+        // depth ≥ the stored nearest depth). `ImageSamplerDescriptor::as_wgpu` carries `compare`
+        // through, so `GpuImage::sampler` IS a comparison sampler — which the `AsBindGroup`
+        // derive's `sampler_type = "comparison"` binding hands to the material.
+        sampler: ImageSampler::Descriptor(ImageSamplerDescriptor {
+            label: Some("torch_depth_cmp".into()),
+            mag_filter: ImageFilterMode::Linear,
+            min_filter: ImageFilterMode::Linear,
+            compare: Some(ImageCompareFunction::GreaterEqual),
+            ..Default::default()
+        }),
+        // `None` ⇒ wgpu's default view: the texture's format, all mips/layers, and — for a D2
+        // texture with >1 layers — `D2Array`, exactly the `texture_depth_2d_array` both receivers
+        // declare. (Spelled out rather than relied on silently: it is the one fact the whole
+        // sharing scheme rests on.)
+        texture_view_descriptor: None,
+        asset_usage: RenderAssetUsages::RENDER_WORLD,
+        ..Default::default()
+    };
+    let buffer = device.create_buffer(&BufferDescriptor {
+        label: Some("wow_shared_torch_table"),
+        size: TORCH_TABLE_BYTES,
+        usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    (TorchDepthImage(images.add(image)), SharedTorchBuffer(buffer))
+}
+
+/// MONKEY (static torch cache): byte-identical std140/std430 table in BOTH receiver shaders.
+/// count@0: live high-water mark, (strength*100 << 16 | soft*100), dynamic mask, lane flags (16 B).
+/// positions[16]@16: world xyz + fade weight (256 bytes).
+/// view_projs[96]@272: six static-bank face matrices per physical slot (6144 bytes).
+/// Total 6416. Unready/hole slots have zero weight; no stale owner's depth can be sampled.
+#[repr(C)]
+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
+pub(crate) struct TorchTableUniform {
+    count: u32,
+    /// MONKEY (torch caster selection): `soft x 100` — the PCF tap-radius scale, riding the first
+    /// of the three padding words the `vec4<u32>` alignment already forced us to carry. The
+    /// alternative was a whole new 16-byte row for one dial.
+    ///
+    /// MONKEY (shadow floor): and now `strength x 100` in its HIGH 16 bits, for the same reason
+    /// one level down — the word was carrying one dial in a range (1..300) that needs nine bits,
+    /// and growing the table by a row costs 16 bytes in a struct whose SIZE is the contract with
+    /// three shaders (a mismatch hides every building). Low half `soft`, high half `strength`;
+    /// both receivers mask/shift rather than reading the word whole.
+    soft_strength: u32,
+    dynamic_mask: u32,
+    /// MONKEY (outdoor torch shadows): lane flags, the word that was reserved padding.
+    /// Bit 0 ([`TORCH_EXT_LANE`]) = the EXTERIOR receiver lane is live this frame. Both WGSL
+    /// copies read it as `count.w`; the table's SIZE is untouched, which is what keeps the
+    /// 6416-byte contract (and therefore every building and model on screen) intact.
+    flags: u32,
+    positions: [[f32; 4]; MAX_TORCH_MAPS],
+    view_projs: [[[f32; 4]; 4]; MAX_TORCH_LAYERS],
+}
+
+const _: () = assert!(std::mem::size_of::<TorchTableUniform>() as u64 == TORCH_TABLE_BYTES);
+
+impl TorchTableUniform {
+    /// Pack this frame's table from the extracted views — a zero table (count 0) when the lane is
+    /// off or the resource is absent, so both receivers read "no torches" rather than stale data.
+    pub(crate) fn pack(views: Option<&TorchShadowViews>) -> Self {
+        let mut table = Self::zeroed();
+        let Some(views) = views else {
+            return table;
+        };
+        let count = (views.count as usize).min(MAX_TORCH_MAPS);
+        table.count = count as u32;
+        table.dynamic_mask = views.dynamic_mask & views.ready_mask;
+        // MONKEY (torch caster selection): 0 would mean a zero tap radius (four identical taps =
+        // a hard edge), so a table published without a scale reads as the neutral 1.0.
+        let soft = if views.soft > 0.01 { views.soft } else { 1.0 };
+        // MONKEY (shadow floor): the cvar is clamped 0..1 on the way in, so the pack only has to
+        // keep the two halves from colliding - `soft` is capped at 3.0 (300, nine bits) by its own
+        // cvar clamp and belt-and-braces here, and `strength` cannot exceed 100. A strength of 0 is
+        // MEANINGFUL (shadows off) and must survive the pack, which is why it gets no `max(1)`.
+        let soft_pct = ((soft * 100.0).round() as i64).clamp(1, 0xffff) as u32;
+        let strength_pct = ((views.strength.clamp(0.0, 1.0) * 100.0).round() as i64)
+            .clamp(0, 100) as u32;
+        table.soft_strength = (strength_pct << 16) | soft_pct;
+        // MONKEY (outdoor torch shadows): the exterior receiver lane's live gate. Packed even when
+        // `count` is 0 costs nothing and is simpler to reason about than a conditional flag.
+        table.flags = if views.exterior { TORCH_EXT_LANE } else { 0 };
+        for i in 0..count {
+            table.positions[i] = views.positions[i].to_array();
+            if views.ready_mask & (1 << i) == 0 { table.positions[i][3] = 0.0; }
+            // Six cube faces per fixture: layer = fixture * 6 + face (the depth node renders and
+            // the shaders' `torch_face` pick by the same index).
+            for f in 0..CUBE_FACES {
+                table.view_projs[i * CUBE_FACES + f] =
+                    views.view_projs[i * CUBE_FACES + f].to_cols_array_2d();
+            }
+        }
+        table
+    }
+}
+
+/// Render-world: rewrite the shared torch table in place every frame, before any draw reads it
+/// (`RenderSystems::PrepareResources` — the same stage `upload_light` writes the light blob). One
+/// MONKEY (static torch cache): 6416-byte upload per frame, independent of material count. static_gx's group-3 uniform is packed
+/// from the same [`TorchTableUniform::pack`] in `render.rs`, so the two receivers can never
+/// disagree on a fixture.
+fn upload_torch_table(
+    queue: Res<RenderQueue>,
+    buffer: Option<Res<SharedTorchBuffer>>,
+    views: Option<Res<TorchShadowViews>>,
+    // MONKEY (torch lane perf): the last bytes actually uploaded, keyed by the buffer they went to
+    // (so a recreated buffer can never inherit another one's "already current" verdict), plus the
+    // trace counters for the second in progress.
+    mut last: Local<Option<(BufferId, TorchTableUniform)>>,
+    mut trace: Local<TorchUploadTrace>,
+) {
+    let Some(buffer) = buffer else {
+        return;
+    };
+    let table = TorchTableUniform::pack(views.as_deref());
+    // MONKEY (torch lane perf): skip the upload when the packed bytes are identical to the ones
+    // already in the buffer. A standing player in a lit room republishes the SAME 6416 bytes every
+    // frame — the fixtures have not moved, the cross-fades have saturated at 1 and the projections
+    // are rebuilt from unchanged positions — so this is a staging-belt allocation and a copy with
+    // nothing to say. A `memcmp` of 6 KB is far cheaper than the copy it replaces, and the compare
+    // is against what we WROTE, so it can never disagree with the buffer's real contents.
+    let id = buffer.0.id();
+    let current = last.as_ref().is_some_and(|(b, t)| {
+        *b == id && bytemuck::bytes_of(t) == bytemuck::bytes_of(&table)
+    });
+    if !current {
+        queue.write_buffer(&buffer.0, 0, bytemuck::bytes_of(&table));
+        *last = Some((id, table));
+        trace.uploads += 1;
+    }
+    trace.frames += 1;
+    trace.report();
+}
+
+/// MONKEY (torch lane perf): `WOW_TORCH_TRACE` accounting for [`upload_torch_table`] — the render
+/// world's half of the lane's per-second perf line (the app's half is `torch-perf:` in
+/// `benilla_app::torch_shadow`). `uploads` well below `frames` is the dedup working.
+struct TorchUploadTrace {
+    uploads: u32,
+    frames: u32,
+    since: std::time::Instant,
+}
+
+impl Default for TorchUploadTrace {
+    fn default() -> Self {
+        Self { uploads: 0, frames: 0, since: std::time::Instant::now() }
+    }
+}
+
+impl TorchUploadTrace {
+    fn report(&mut self) {
+        if self.since.elapsed().as_secs_f32() < 1.0 {
+            return;
+        }
+        if std::env::var_os("WOW_TORCH_TRACE").is_some() {
+            info!("torch-perf: table uploads {}/{} frames", self.uploads, self.frames);
+        }
+        *self = Self::default();
+    }
+}
+
+/// The persistent render-world state that does NOT depend on the image: the comparison sampler
+/// static_gx's group 3 binds (kept as its own `GreaterEqual` sampler — unchanged behaviour; the
+/// material binds the image's, which is built from the same descriptor), the depth-only pipeline
+/// and its per-fixture view-uniform layout. Built once in [`RenderStartup`].
+#[derive(Resource)]
+pub(crate) struct TorchDepthTargets {
+    sampler: Sampler,
+    pipeline: CachedRenderPipelineId,
+    view_layout: BindGroupLayoutDescriptor,
+}
+
+impl TorchDepthTargets {
+    /// The `GreaterEqual` comparison sampler for the static_gx group-3 shadow lookup.
+    pub(crate) fn sampler(&self) -> &Sampler {
+        &self.sampler
+    }
+}
+
+/// The per-layer D2 render-attachment views over the shared image's texture, cached by that
+/// texture's id: rebuilt only if the `GpuImage` is ever re-prepared (it is created once and never
+/// modified, so in practice exactly once), never per frame. Empty until the image is resident.
+#[derive(Resource, Default)]
+struct TorchLayerViews {
+    texture: Option<TextureId>,
+    /// MONKEY (live bank rank): static slot `i / 6`; live rank `(i - 96) / 6`; face `i % 6`.
+    views: Vec<TextureView>,
+}
+
+/// MONKEY (static torch cache): only a completed six-face command recording certifies a cache
+/// entry. Preparation may run while there is no world view or the pipeline is still compiling;
+/// such a frame must not mark a never-rendered map cached. Texture recreation resets all keys.
+#[derive(Resource, Default)]
+struct TorchStaticCache(Mutex<[Option<AssetId<Mesh>>; MAX_TORCH_MAPS]>);
+
+// MONKEY (static torch cache): the app logs requests; this records actual GPU cache work.
+#[derive(Resource, Default)]
+struct TorchCacheTrace(Mutex<Option<std::time::Instant>>);
+
+/// This frame's per-fixture view-uniform bind groups (one per live map), rebuilt in
+/// MONKEY (static torch cache): retained across frames; refreshed in PrepareResources.
+#[derive(Resource, Default)]
+struct TorchDepthDraw {
+    view_projs: Vec<Mat4>,
+    count: usize,
+    rebuild_mask: u32,
+    /// `bind_groups[i]` binds layer `i`'s `view_proj` at group 0 of the depth pipeline.
+    bind_groups: Vec<BindGroup>,
+}
+
+fn init_torch_depth(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    pipeline_cache: Res<PipelineCache>,
+    asset_server: Res<AssetServer>,
+) {
+    let sampler = render_device.create_sampler(&SamplerDescriptor {
+        label: Some("torch_depth_cmp"),
+        min_filter: FilterMode::Linear,
+        mag_filter: FilterMode::Linear,
+        compare: Some(CompareFunction::GreaterEqual),
+        ..Default::default()
+    });
+    // Group 0: the single per-fixture `view_proj` (a mat4, 64 bytes), vertex-only.
+    let view_layout = BindGroupLayoutDescriptor::new(
+        "torch_depth_view_layout",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::VERTEX,
+            (uniform_buffer_sized(false, Some(std::num::NonZero::new(64).unwrap())),),
+        ),
+    );
+    let shader: Handle<Shader> =
+        asset_server.load("embedded://benilla_world/shaders/torch_depth.wgsl");
+    let pipeline = pipeline_cache.queue_render_pipeline(RenderPipelineDescriptor {
+        label: Some("torch_depth".into()),
+        layout: vec![view_layout.clone()],
+        vertex: VertexState {
+            shader,
+            shader_defs: vec![],
+            entry_point: Some("vertex".into()),
+            // The caster mesh (`shadow_core::empty_shadow_mesh`) carries ONLY position — stride 12.
+            buffers: vec![VertexBufferLayout {
+                array_stride: 12,
+                step_mode: VertexStepMode::Vertex,
+                attributes: vec![VertexAttribute {
+                    format: VertexFormat::Float32x3,
+                    offset: 0,
+                    shader_location: 0,
+                }],
+            }],
+        },
+        // Depth only — no fragment, no color targets.
+        fragment: None,
+        primitive: PrimitiveState {
+            // Cull none is safest for the mixed-winding WMO/static caster geometry.
+            cull_mode: None,
+            ..Default::default()
+        },
+        depth_stencil: Some(DepthStencilState {
+            format: TextureFormat::Depth32Float,
+            depth_write_enabled: true,
+            depth_compare: CompareFunction::GreaterEqual,
+            stencil: StencilState::default(),
+            bias: DepthBiasState::default(),
+        }),
+        multisample: MultisampleState {
+            count: 1,
+            ..Default::default()
+        },
+        ..default()
+    });
+    commands.insert_resource(TorchDepthTargets {
+        sampler,
+        pipeline,
+        view_layout,
+    });
+}
+
+/// Build one view-uniform bind group per live layer from the extracted [`TorchShadowViews`], and
+/// (re)build the per-layer attachment views whenever the shared image's texture changes identity.
+fn prepare_torch_depth(
+    mut draw: ResMut<TorchDepthDraw>,
+    targets: Option<Res<TorchDepthTargets>>,
+    mut views: Option<ResMut<TorchShadowViews>>,
+    cache: Res<TorchStaticCache>,
+    meshes: Res<RenderAssets<RenderMesh>>,
+    allocator: Res<MeshAllocator>,
+    image: Option<Res<TorchDepthImage>>,
+    images: Res<RenderAssets<GpuImage>>,
+    mut layers: ResMut<TorchLayerViews>,
+    pipeline_cache: Res<PipelineCache>,
+    render_device: Res<RenderDevice>,
+) {
+    draw.count = 0;
+    draw.rebuild_mask = 0;
+    // MONKEY (static torch cache): fail closed until every prerequisite for this frame exists.
+    if let Some(views) = views.as_mut() { views.ready_mask = 0; }
+    // MONKEY (static torch cache): attachment views are allocated once per texture identity.
+    let gpu_image = image.as_ref().and_then(|h| images.get(&h.0));
+    match gpu_image {
+        Some(gpu) if layers.texture != Some(gpu.texture.id()) => {
+            *cache.0.lock().unwrap() = [None; MAX_TORCH_MAPS];
+            layers.views = (0..TORCH_TEXTURE_LAYERS as u32)
+                .map(|i| {
+                    gpu.texture.create_view(&TextureViewDescriptor {
+                        label: Some("torch_depth_layer"),
+                        format: Some(TextureFormat::Depth32Float),
+                        dimension: Some(TextureViewDimension::D2),
+                        aspect: TextureAspect::DepthOnly,
+                        base_mip_level: 0,
+                        mip_level_count: Some(1),
+                        base_array_layer: i,
+                        array_layer_count: Some(1),
+                        ..default()
+                    })
+                })
+                .collect();
+            layers.texture = Some(gpu.texture.id());
+        }
+        Some(_) => {}
+        None => {
+            // Not resident (yet): nothing to render into this frame.
+            layers.views.clear();
+            layers.texture = None;
+        }
+    }
+    let Some(targets) = targets else {
+        return;
+    };
+    let count = views
+        .as_ref()
+        .map_or(0, |v| (v.count as usize).min(MAX_TORCH_MAPS));
+    if count == 0 {
+        return;
+    }
+    let mut views = views.expect("count > 0 implies views present");
+    if layers.texture.is_none() || pipeline_cache.get_render_pipeline(targets.pipeline).is_none() {
+        return;
+    }
+    let cached = cache.0.lock().unwrap();
+    let (ready_mask, rebuild_mask, dynamic_mask) = torch_cache_plan(
+        &*cached, &views.caster_meshes[..count], views.dynamic_mask, views.moving_mask,
+        |id| torch_mesh_ready(id, &meshes, &allocator));
+    views.ready_mask = ready_mask;
+    views.dynamic_mask = dynamic_mask;
+    // If entity upload is late, bind the static bank for this frame, never last frame's overlay.
+    if !views.entity_mesh.is_some_and(|id| torch_mesh_ready(id, &meshes, &allocator)) {
+        views.dynamic_mask = 0;
+    }
+    let layout = pipeline_cache.get_bind_group_layout(&targets.view_layout);
+    // Six cube faces per live fixture: layer = fixture * CUBE_FACES + face.
+    let layer_count = count * CUBE_FACES;
+    for i in 0..layer_count {
+        // MONKEY (static torch cache): fixture projections do not move with the camera.
+        // Keep their buffers/bind groups too: zero resource allocation on a steady frame.
+        if draw.view_projs.get(i) == Some(&views.view_projs[i]) { continue; }
+        let vp = views.view_projs[i].to_cols_array();
+        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("torch_depth_view"),
+            contents: bytemuck::cast_slice(&vp),
+            usage: BufferUsages::UNIFORM,
+        });
+        // The wgpu bind group keeps the buffer alive; the local handle can drop.
+        let bind_group = render_device.create_bind_group(
+            "torch_depth_view",
+            &layout,
+            &BindGroupEntries::sequential((buffer.as_entire_binding(),)),
+        );
+        if i < draw.bind_groups.len() {
+            draw.bind_groups[i] = bind_group;
+            draw.view_projs[i] = views.view_projs[i];
+        } else {
+            draw.bind_groups.push(bind_group);
+            draw.view_projs.push(views.view_projs[i]);
+        }
+    }
+    draw.count = layer_count;
+    draw.rebuild_mask = rebuild_mask;
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+struct TorchDepthLabel;
+
+#[derive(Default)]
+struct TorchDepthNode;
+
+impl ViewNode for TorchDepthNode {
+    // Run only for the world view — the same marker the retained pass gates on, so a portrait-booth
+    // bake never renders torch depth with the booth's matrices.
+    type ViewQuery = &'static StaticGxView;
+
+    fn run<'w>(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext<'w>,
+        _view: QueryItem<'w, '_, Self::ViewQuery>,
+        world: &'w World,
+    ) -> Result<(), NodeRunError> {
+        let Some(views) = world.get_resource::<TorchShadowViews>() else {
+            return Ok(());
+        };
+        let Some(draw) = world.get_resource::<TorchDepthDraw>() else {
+            return Ok(());
+        };
+        let Some(targets) = world.get_resource::<TorchDepthTargets>() else {
+            return Ok(());
+        };
+        // The shared image's per-layer attachment views — empty while the GpuImage is not resident.
+        let Some(layers) = world.get_resource::<TorchLayerViews>() else {
+            return Ok(());
+        };
+        // `count` is LAYERS here: six cube faces per live fixture.
+        let count = draw
+            .count
+            .min(views.count as usize * CUBE_FACES)
+            .min(MAX_TORCH_LAYERS)
+            .min(layers.views.len());
+        if count == 0 {
+            return Ok(());
+        }
+        let pipeline_cache = world.resource::<PipelineCache>();
+        let Some(pipeline) = pipeline_cache.get_render_pipeline(targets.pipeline) else {
+            return Ok(());
+        };
+        let meshes = world.resource::<RenderAssets<RenderMesh>>();
+        let allocator = world.resource::<MeshAllocator>();
+        let image = world.resource::<TorchDepthImage>();
+        let images = world.resource::<RenderAssets<GpuImage>>();
+        let Some(gpu) = images.get(&image.0) else { return Ok(()) };
+        let cache = world.resource::<TorchStaticCache>();
+        let mut cached = cache.0.lock().unwrap();
+        let trace = world.resource::<TorchCacheTrace>();
+        let trace_on = std::env::var_os("WOW_TORCH_TRACE").is_some();
+        let mut last_trace = trace.0.lock().unwrap();
+        let trace_due = trace_on && last_trace.is_none_or(|t| t.elapsed().as_secs_f32() >= 1.0);
+        if trace_due { *last_trace = Some(std::time::Instant::now()); }
+        for slot in 0..count / CUBE_FACES {
+            if views.ready_mask & (1 << slot) == 0 { continue; }
+            // MONKEY (moving fixture): same reasoning as `torch_cache_plan` — a live slot's mesh
+            // id is stable by design, so the id comparison would veto every rebuild the plan just
+            // granted it and freeze the map at the fixture's first position.
+            let moving = views.moving_mask & (1 << slot) != 0;
+            let rebuild = draw.rebuild_mask & (1 << slot) != 0
+                && (moving || cached[slot] != views.caster_meshes[slot]);
+            let dynamic = views.dynamic_mask & (1 << slot) != 0;
+            let live_rank = dynamic.then(|| TorchShadowViews::live_rank(views.dynamic_mask, slot));
+            // MONKEY (static torch cache): render static once, then copy to the disjoint live
+            // bank BEFORE each entity pass. GreaterEqual + Load preserves the nearest surface.
+            for face in 0..CUBE_FACES {
+                let layer = slot * CUBE_FACES + face;
+                if rebuild {
+                    let mut pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
+                        label: Some("torch_static_rebuild"),
+                        color_attachments: &[],
+                        depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                            view: &layers.views[layer],
+                            depth_ops: Some(Operations { load: LoadOp::Clear(0.0), store: StoreOp::Store }),
+                            stencil_ops: None,
+                        }),
+                        timestamp_writes: None,
+                        occlusion_query_set: None,
+                    });
+                    pass.set_render_pipeline(pipeline);
+                    pass.set_bind_group(0, &draw.bind_groups[layer], &[]);
+                    draw_torch_mesh(&mut pass, views.caster_meshes[slot], meshes, allocator);
+                }
+                if let Some(rank) = live_rank {
+                    // MONKEY (live bank rank): matrices remain slot-addressed; only the copy
+                    // destination/overlay attachment follows count.z's compact ready-set rank.
+                    let live = MAX_TORCH_LAYERS + rank * CUBE_FACES + face;
+                    render_context.command_encoder().copy_texture_to_texture(
+                        TexelCopyTextureInfo {
+                            texture: &gpu.texture, mip_level: 0,
+                            origin: Origin3d { x: 0, y: 0, z: layer as u32 },
+                            aspect: TextureAspect::DepthOnly,
+                        },
+                        TexelCopyTextureInfo {
+                            texture: &gpu.texture, mip_level: 0,
+                            origin: Origin3d { x: 0, y: 0, z: live as u32 },
+                            aspect: TextureAspect::DepthOnly,
+                        },
+                        Extent3d { width: TORCH_MAP_EDGE, height: TORCH_MAP_EDGE, depth_or_array_layers: 1 },
+                    );
+                    let mut pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
+                        label: Some("torch_dynamic_overlay"),
+                        color_attachments: &[],
+                        depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+                            view: &layers.views[live],
+                            depth_ops: Some(Operations { load: LoadOp::Load, store: StoreOp::Store }),
+                            stencil_ops: None,
+                        }),
+                        timestamp_writes: None,
+                        occlusion_query_set: None,
+                    });
+                    pass.set_render_pipeline(pipeline);
+                    pass.set_bind_group(0, &draw.bind_groups[layer], &[]);
+                    draw_torch_mesh(&mut pass, views.entity_mesh, meshes, allocator);
+                }
+            }
+            if rebuild { cached[slot] = views.caster_meshes[slot]; }
+            if trace_on && (trace_due || rebuild) {
+                info!("torch-cache: slot {slot} static {} dynamic {} live_rank {:?} live_base {:?}",
+                    if rebuild { "rebuilt" } else { "cached" },
+                    if dynamic { "yes" } else { "no" }, live_rank,
+                    live_rank.map(|rank| MAX_TORCH_LAYERS + rank * CUBE_FACES));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Wire the ALWAYS-ON half (MONKEY, Phase 3A): the extract plugins for the shared image + table
+/// (so the render world can look up the `GpuImage` and write the buffer), and the per-frame table
+/// upload. Registered by the asset foundation next to the shared light buffer — NOT gated on the
+/// retained pass (`static_gx::enabled`), because every model material binds these whether or not
+/// static_gx draws. With the depth node off the table reads count 0 and the image stays at its
+/// zero-initialised (= reverse-Z far ⇒ unshadowed) contents, so entities simply receive no shadow.
+pub(crate) fn register_shared(app: &mut App) {
+    app.add_plugins((
+        ExtractResourcePlugin::<TorchDepthImage>::default(),
+        ExtractResourcePlugin::<SharedTorchBuffer>::default(),
+    ));
+    if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+        render_app.add_systems(
+            Render,
+            upload_torch_table.in_set(RenderSystems::PrepareResources),
+        );
+    }
+}
+
+/// Wire the render half: the persistent targets (RenderStartup), the per-frame view bind groups, and
+/// the depth node between the prepass and the main opaque pass.
+pub(super) fn build(app: &mut App) {
+    let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+        return;
+    };
+    render_app
+        .init_resource::<TorchLayerViews>()
+        .init_resource::<TorchStaticCache>()
+        .init_resource::<TorchDepthDraw>()
+        .init_resource::<TorchCacheTrace>()
+        .add_systems(RenderStartup, init_torch_depth)
+        .add_systems(
+            Render,
+            // MONKEY (static torch cache): ready/dynamic masks must be final before BOTH
+            // the shared storage upload and static_gx's PrepareBindGroups uniform pack.
+            prepare_torch_depth.in_set(RenderSystems::PrepareResources).before(upload_torch_table),
+        )
+        .add_render_graph_node::<ViewNodeRunner<TorchDepthNode>>(Core3d, TorchDepthLabel)
+        .add_render_graph_edges(
+            Core3d,
+            // After all prepasses complete, before the main opaque pass — so the depth maps are
+            // ready when `StaticGxNode` (between opaque and transparent) samples them.
+            (
+                Node3d::EndPrepasses,
+                TorchDepthLabel,
+                Node3d::MainOpaquePass,
+            ),
+        );
+}
+
+// MONKEY (static torch cache): planning does not commit residency. A missing upload cannot
+// certify an empty map, and the two-rebuild budget also covers GPU texture recreation.
+//
+// MONKEY (moving fixture): `moving_mask`'s slots draw from a SEPARATE budget of
+// [`TORCH_MOVING_MAX`], and they draw from it first. Two reasons it cannot be one shared budget:
+// a moving slot asks for a rebuild EVERY frame (its mesh id changes every frame by construction),
+// so sharing would let two moving fixtures own the budget forever and freeze every resident room's
+// static map at whatever it last held; and a deferred moving rebuild is not a stale map but a
+// wrong one — the table republishes its six projections from the live fixture position each frame
+// while the depth still holds the old one, i.e. a shadow drawn from where the light no longer is.
+fn torch_cache_plan<T: Copy + Eq>(cached: &[Option<T>], requested: &[Option<T>], dynamic_mask: u32,
+    moving_mask: u32, mut mesh_ready: impl FnMut(T) -> bool) -> (u32, u32, u32) {
+    let (mut ready, mut rebuild) = (0u32, 0u32);
+    let mut budget = 2usize;
+    let mut moving_budget = TORCH_MOVING_MAX;
+    for (i, requested) in requested.iter().take(MAX_TORCH_MAPS).enumerate() {
+        let Some(id) = *requested else { continue };
+        let moving = moving_mask & (1 << i) != 0;
+        // MONKEY (moving fixture): a live slot MUTATES its caster mesh in place and keeps its asset
+        // id (an asset added this frame would not be certified resident until the next one, and the
+        // slot would lose its ready bit — a zero weight — on every frame its fixture moved). So the
+        // usual "same id ⇒ the cached depth is still good" shortcut is exactly wrong here: the id
+        // is the same and the CONTENTS are a frame old. A live slot always takes the rebuild path.
+        if !moving && cached[i] == Some(id) {
+            ready |= 1 << i;
+            continue;
+        }
+        let lane = if moving { &mut moving_budget } else { &mut budget };
+        if *lane > 0 && mesh_ready(id) {
+            *lane -= 1;
+            rebuild |= 1 << i;
+            ready |= 1 << i;
+        }
+    }
+    // MONKEY (live bank rank): remove unready holes BEFORE ranking, exactly as table.count.z
+    // does. Bound even malformed resource masks to eight cubes so no copy can escape the bank.
+    let eligible = dynamic_mask & ready;
+    let dynamic = (0..MAX_TORCH_MAPS).fold(0, |mask, slot| {
+        if eligible & (1 << slot) != 0 && TorchShadowViews::live_rank(eligible, slot) < MAX_TORCH_DYNAMIC {
+            mask | (1 << slot)
+        } else { mask }
+    });
+    (ready, rebuild, dynamic)
+}
+
+// MONKEY (static torch cache): an empty mesh is a valid all-clear cube. A nonempty mesh without
+// allocator slices is still uploading, and MUST NOT become a permanently cached empty shadow.
+fn torch_mesh_ready(id: AssetId<Mesh>, meshes: &RenderAssets<RenderMesh>, allocator: &MeshAllocator) -> bool {
+    let Some(mesh) = meshes.get(id) else { return false };
+    match mesh.buffer_info {
+        RenderMeshBufferInfo::Indexed { count, .. } => count == 0
+            || (allocator.mesh_vertex_slice(&id).is_some() && allocator.mesh_index_slice(&id).is_some()),
+        _ => false,
+    }
+}
+
+fn draw_torch_mesh<'a>(
+    pass: &mut bevy::render::render_phase::TrackedRenderPass<'a>, id: Option<AssetId<Mesh>>,
+    meshes: &'a RenderAssets<RenderMesh>, allocator: &'a MeshAllocator,
+) {
+    let Some(id) = id else { return };
+    let Some(mesh) = meshes.get(id) else { return };
+    let RenderMeshBufferInfo::Indexed { index_format, count } = mesh.buffer_info else { return };
+    if count == 0 { return; }
+    let (Some(v), Some(i)) = (allocator.mesh_vertex_slice(&id), allocator.mesh_index_slice(&id)) else { return };
+    pass.set_vertex_buffer(0, v.buffer.slice(..));
+    pass.set_index_buffer(i.buffer.slice(..), index_format);
+    pass.draw_indexed(i.range.clone(), i32::try_from(v.range.start).unwrap_or(0), 0..1);
+}
+
+impl super::StaticGx {
+    /// MONKEY (static torch cache): fixture-local static collection uses batch bounds, not the
+    /// building's placement origin. A distant Abbey room is still part of a WMO anchored more
+    /// than 48 yards away. The key and the mesh MUST use this identical admission predicate.
+    ///
+    /// MONKEY (torch owner exclusion): returns how many in-range items were dropped as the
+    /// FIXTURE'S OWN BODY — the `WOW_TORCH_TRACE` counter, and the one number that says whether
+    /// this fix is doing anything for a given slot.
+    pub fn append_torch_triangles(&self, center: Vec3, reach: f32, owner: Option<LightOwner>,
+        positions: &mut Vec<[f32; 3]>, indices: &mut Vec<u32>) -> u32 {
+        let mut excluded = 0;
+        for cell in self.cells.values().chain(self.wmos.values()).chain(self.props.values()) {
+            for item in &cell.items {
+                if !torch_item_in_range(item, center, reach) { continue; }
+                if torch_item_is_emitter(item, center, owner) { excluded += 1; continue; }
+                let base = positions.len() as u32;
+                positions.extend(item.geometry.positions.iter().map(|p|
+                    item.transform.transform_point(benilla_assets::coords::wow_to_bevy(*p)).to_array()));
+                let added = positions.len() as u32 - base;
+                for tri in item.geometry.indices.chunks_exact(3) {
+                    if tri.iter().all(|i| *i < added) { indices.extend(tri.iter().map(|i| base + *i)); }
+                }
+            }
+        }
+        excluded
+    }
+
+    /// MONKEY (torch lane perf): a CHEAP stamp of "has the retained scene changed at all" —
+    /// O(regions), where [`Self::torch_geometry_key`] is O(items) and is run per fixture.
+    ///
+    /// It folds each region's own `last_change` frame together with its population, which between
+    /// them cover every way the source set of ANY fixture can move: an item is only ever pushed
+    /// (`push_item` stamps `last_change`) or dropped (`release_owner` stamps it and changes the
+    /// count), and a whole region arriving or being culled changes the fold because the region set
+    /// itself is folded. Order-independent, so `HashMap` iteration order is invisible. A baker's
+    /// in-place SORT of a region's items is deliberately not covered and does not need to be: the
+    /// geometry key it guards is an order-independent sum too.
+    ///
+    /// This is a GATE, not a key: the app lane skips a fixture's expensive walk while this and the
+    /// entity-part census are both unchanged, and still computes the real per-fixture key whenever
+    /// either of them moves.
+    pub fn torch_residency_generation(&self) -> u64 {
+        let mut sum = 0u64;
+        for cell in self.cells.values().chain(self.wmos.values()).chain(self.props.values()) {
+            let mut hash = std::collections::hash_map::DefaultHasher::new();
+            cell.last_change.hash(&mut hash);
+            cell.items.len().hash(&mut hash);
+            sum = sum.wrapping_add(hash.finish());
+        }
+        sum
+    }
+
+    /// MONKEY (static torch cache): residency fingerprint of the exact opaque source set used
+    /// by append_torch_triangles. Order-independent per-item hashing ignores HashMap reordering
+    /// and camera/portal/fader bookkeeping. Arrival, unload, replacement or transform edits in
+    /// THIS fixture's sphere invalidate it even when neither camera nor fixture moves.
+    pub fn torch_geometry_key(&self, center: Vec3, reach: f32, owner: Option<LightOwner>) -> u64 {
+        let mut sum = 0u64;
+        for cell in self.cells.values().chain(self.wmos.values()).chain(self.props.values()) {
+            for item in &cell.items {
+                if !torch_item_in_range(item, center, reach) { continue; }
+                if torch_item_is_emitter(item, center, owner) { continue; }
+                let mut hash = std::collections::hash_map::DefaultHasher::new();
+                // MONKEY (static torch cache): source residency stamp prevents allocator address
+                // reuse after unload/reload from impersonating the previous geometry Arc.
+                cell.last_change.hash(&mut hash);
+                (std::sync::Arc::as_ptr(&item.geometry) as usize).hash(&mut hash);
+                item.transform.to_matrix().to_cols_array().map(f32::to_bits).hash(&mut hash);
+                sum = sum.wrapping_add(hash.finish());
+            }
+        }
+        sum
+    }
+}
+
+/// MONKEY (torch owner exclusion): EMITTER-OWNER EXCLUSION — is this item the fixture's own body?
+///
+/// Three tests, cheapest and most exact first. Only the first is IDENTITY; the other two are the
+/// fallback for a light whose owner could not be plumbed (a server-placed GameObject fire, a light
+/// whose placement tag has not landed yet) and for one whose own model is split across placements.
+///
+///  1. OWNERSHIP. `owner` names a placement and this item belongs to it — see [`LightOwner`]. This
+///     is the case the lantern-on-a-post and the tall wall torch need: their bounds reach the
+///     ground, so no proximity rule of any radius could have found them.
+///  2. CONTAINMENT of the FLAME. The item's own bounds hold the light position (padded by
+///     [`TORCH_SELF_PAD`]) and the item is FIXTURE-SIZED ([`TORCH_SELF_MAX_EXTENT`]). A lamp
+///     housing contains its own flame; a crate a yard and a half away does not. The size cap is
+///     load-bearing, not tidiness — see the constant.
+///  3. The DEGENERATE case: the item's whole bounding sphere lies within [`TORCH_SELF_TINY`] of the
+///     flame, i.e. it is a flame card or a helper sitting on top of the light and can cast nothing
+///     but self-shadow. This is all that survives of the old 2.5-yd proximity rule.
+///
+/// An item with no bounds is never excluded by 2 or 3: the failure direction of a heuristic here
+/// must be "keeps a caster", not "loses a wall".
+fn torch_item_is_emitter(item: &super::GxItem, center: Vec3, owner: Option<LightOwner>) -> bool {
+    if owner.is_some_and(|o| o.owns(&item.object)) {
+        return true;
+    }
+    item.local_aabb.is_some_and(|aabb| {
+        let (c, h) = (Vec3::from(aabb.center), Vec3::from(aabb.half_extents));
+        torch_bound_contains(&item.transform, c, h, center)
+            || torch_bound_contained(&item.transform, c, h, center, TORCH_SELF_TINY)
+    })
+}
+
+/// MONKEY (torch owner exclusion): does this bound CONTAIN the flame? Tested in MODEL space (the
+/// inverse transform), so a rotated lamp post is measured against its own box rather than against
+/// the circumsphere a world-space test would have to use — the difference between "the lantern
+/// housing" and "a 3-yd ball centred on the lantern" that would swallow the porch it hangs from.
+/// The size cap is applied FIRST and on the cheap sphere radius, so the inverse is only ever paid
+/// by the handful of fixture-sized items standing at a flame.
+///
+/// `pub` and taking an `Affine3A` because BOTH caster lanes need the identical rule and they hold
+/// their pose in different shapes: the retained lane has a `Transform`, the entity lane a
+/// `GlobalTransform`. Two copies of a heuristic that decides "does this cast" would drift.
+pub fn torch_flame_inside_bounds(world_from_local: Affine3A, local_center: Vec3,
+    half_extents: Vec3, light: Vec3) -> bool {
+    let m = world_from_local.matrix3;
+    // The basis columns' lengths ARE the scale, whatever rotation is folded in with them.
+    let scale = Vec3::new(m.x_axis.length(), m.y_axis.length(), m.z_axis.length());
+    if (half_extents * scale).length() > TORCH_SELF_MAX_EXTENT {
+        return false;
+    }
+    let local = world_from_local.inverse().transform_point3(light);
+    // A world-space pad has to be expressed in model units, hence the divide; the floor keeps a
+    // degenerate (zero-scale) placement from producing an infinite pad that contains the world.
+    let pad = Vec3::splat(TORCH_SELF_PAD) / scale.max(Vec3::splat(1e-4));
+    (local - local_center).abs().cmple(half_extents + pad).all()
+}
+
+/// The retained lane's shape of [`torch_flame_inside_bounds`].
+fn torch_bound_contains(transform: &Transform, local_center: Vec3, half_extents: Vec3,
+    light: Vec3) -> bool {
+    torch_flame_inside_bounds(transform.compute_affine(), local_center, half_extents, light)
+}
+
+/// The proximity half of [`torch_item_is_emitter`], split out exactly as `torch_bound_in_range`
+/// is: the transformed bounding sphere lies WHOLLY inside `radius` of the fixture. `radius <= 0`
+/// contains nothing.
+fn torch_bound_contained(transform: &Transform, local_center: Vec3, half_extents: Vec3,
+    center: Vec3, radius: f32) -> bool {
+    if radius <= 0.0 {
+        return false;
+    }
+    let origin = transform.transform_point(local_center);
+    let r = (half_extents * transform.scale.abs()).length();
+    origin.distance(center) + r <= radius
+}
+
+// MONKEY (static torch cache): a conservative transformed bounding sphere, independent of
+// portal visibility. Missing bounds admit the source rather than silently losing a wall.
+fn torch_item_in_range(item: &super::GxItem, center: Vec3, reach: f32) -> bool {
+    !item.cutout && item.local_aabb.is_none_or(|aabb| torch_bound_in_range(
+        &item.transform, aabb.center.into(), aabb.half_extents.into(), center, reach))
+}
+
+fn torch_bound_in_range(transform: &Transform, local_center: Vec3, half_extents: Vec3,
+    center: Vec3, reach: f32) -> bool {
+    let origin = transform.transform_point(local_center);
+    let radius = (half_extents * transform.scale.abs()).length();
+    origin.distance_squared(center) <= (reach + radius) * (reach + radius)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // MONKEY (static torch cache): unchanged owners do no work; replacement, streaming,
+    // absent uploads, sparse holes and texture recreation cannot certify stale depth.
+    #[test]
+    fn cache_plan_reuses_and_limits_rebuilds() {
+        let cached = [Some(10), Some(11), None, Some(13)];
+        assert_eq!(torch_cache_plan(&cached, &cached, 0xf, 0, |_| false), (0b1011, 0, 0b1011));
+        let requested = [Some(20), Some(11), Some(12), Some(23)];
+        assert_eq!(torch_cache_plan(&cached, &requested, 0xf, 0, |_| true), (0b0111, 0b0101, 0b0111));
+        assert_eq!(torch_cache_plan(&cached, &requested, 0xf, 0, |id| id == 23), (0b1010, 0b1000, 0b1010));
+        assert_eq!(torch_cache_plan(&cached, &[None, Some(11)], 0xf, 0, |_| true), (0b10, 0, 0b10));
+        assert_eq!(torch_cache_plan(&[None; 4], &requested, 0, 0, |_| true), (0b11, 0b11, 0));
+    }
+
+    // MONKEY (moving fixture): a moving slot rebuilds out of its OWN budget, so two moving
+    // fixtures cannot consume the resident slots' two - the failure that would freeze a room's
+    // static shadows for as long as a pet walked around in it.
+    #[test]
+    fn moving_slots_rebuild_on_a_separate_budget() {
+        let cached = [None, None, None, None];
+        let requested = [Some(1), Some(2), Some(3), Some(4)];
+        // No moving slots: the historical two-rebuild ceiling, untouched.
+        assert_eq!(torch_cache_plan(&cached, &requested, 0, 0, |_| true).1, 0b0011);
+        // Slots 0 and 1 moving: they take the moving budget and slots 2/3 still get the static one.
+        assert_eq!(torch_cache_plan(&cached, &requested, 0, 0b0011, |_| true).1, 0b1111);
+        // Three moving: the third waits (it fast-fades app-side rather than showing a wrong map).
+        assert_eq!(torch_cache_plan(&cached, &requested, 0, 0b0111, |_| true).1, 0b1011);
+    }
+
+    // MONKEY (shadow floor): the two dials share one word; neither may corrupt the other, and a
+    // strength of 0 (shadows off) must survive the pack as a real 0 rather than a floored 1.
+    #[test]
+    fn count_y_packs_soft_low_and_strength_high() {
+        for (soft, strength, soft_pct, strength_pct) in [
+            (1.5f32, 0.7f32, 150u32, 70u32),
+            (3.0, 1.0, 300, 100),
+            (0.5, 0.0, 50, 0),
+            // Out-of-range inputs are clamped, never wrapped into the other half.
+            (0.0, 2.0, 100, 100),
+            (0.5, -1.0, 50, 0),
+        ] {
+            let views = TorchShadowViews { count: 1, soft, strength, ..Default::default() };
+            let word = TorchTableUniform::pack(Some(&views)).soft_strength;
+            assert_eq!(word & 0xffff, soft_pct, "soft {soft}");
+            assert_eq!(word >> 16, strength_pct, "strength {strength}");
+        }
+    }
+
+    #[test]
+    fn live_bank_rank_matches_count_one_bits() {
+        // MONKEY (live bank rank): independently enumerate lower set bits, including holes,
+        // slot 15 and eight sparse overlays; every face must fit the compact allocation.
+        for mask in [0u32, 1, 1 << 15, 0x8085, 0xaaaa, 0xff] {
+            for slot in 0..MAX_TORCH_MAPS {
+                let expected = (0..slot).filter(|bit| mask & (1 << bit) != 0).count();
+                let rank = TorchShadowViews::live_rank(mask, slot);
+                assert_eq!(rank, expected, "mask {mask:#x}, slot {slot}");
+                if mask & (1 << slot) != 0 {
+                    assert!(MAX_TORCH_LAYERS + rank * CUBE_FACES + 5 < TORCH_TEXTURE_LAYERS);
+                }
+            }
+        }
+        let cached = [Some(1); MAX_TORCH_MAPS];
+        let (_, _, capped) = torch_cache_plan(&cached, &cached, 0xffff, 0, |_| false);
+        assert_eq!(capped, 0xff);
+        let mut requested = cached;
+        requested[0] = None;
+        let (ready, _, dynamic) = torch_cache_plan(&cached, &requested, 0x8001, 0, |_| false);
+        let views = TorchShadowViews { count: 16, ready_mask: ready, dynamic_mask: dynamic, ..Default::default() };
+        let table = TorchTableUniform::pack(Some(&views));
+        assert_eq!(dynamic, 0x8000);
+        assert_eq!(table.dynamic_mask, dynamic);
+        assert_eq!(TorchShadowViews::live_rank(table.dynamic_mask, 15), 0);
+    }
+
+    #[test]
+    fn torch_bounds_include_remote_building_batches() {
+        let transform = Transform::from_xyz(200.0, 0.0, 0.0).with_scale(Vec3::splat(2.0));
+        assert!(torch_bound_in_range(&transform, Vec3::new(-100.0, 0.0, 0.0),
+            Vec3::splat(10.0), Vec3::ZERO, 48.0));
+        assert!(!torch_bound_in_range(&transform, Vec3::ZERO,
+            Vec3::splat(10.0), Vec3::ZERO, 48.0));
+    }
+
+    // MONKEY (static torch cache): protect uniform/storage byte agreement and sparse-slot bank
+    // selection, including the highest slot and an upload that has not reached the GPU yet.
+    #[test]
+    fn torch_table_layout_and_readiness() {
+        assert_eq!(std::mem::size_of::<TorchTableUniform>(), 6416);
+        assert_eq!(std::mem::offset_of!(TorchTableUniform, positions), 16);
+        assert_eq!(std::mem::offset_of!(TorchTableUniform, view_projs), 272);
+        let mut views = TorchShadowViews { count: 16, dynamic_mask: (1 << 15) | 1,
+            ready_mask: 1 << 15, ..Default::default() };
+        views.positions[0] = Vec4::ONE;
+        views.positions[15] = Vec4::ONE;
+        let table = TorchTableUniform::pack(Some(&views));
+        assert_eq!(table.dynamic_mask, 1 << 15);
+        assert_eq!(table.positions[0][3], 0.0);
+        assert_eq!(table.positions[15][3], 1.0);
+        assert_eq!(MAX_TORCH_LAYERS, 96);
+        assert_eq!(MAX_TORCH_DYNAMIC, 8);
+        assert_eq!(TORCH_TEXTURE_LAYERS, 144);
+        // MONKEY (outdoor torch shadows): the exterior lane rides `count.w`, the word that was
+        // reserved padding. The SIZE must not move with it — a table that disagrees with either
+        // WGSL copy blanks every building and model on screen.
+        assert_eq!(std::mem::offset_of!(TorchTableUniform, flags), 12);
+        assert_eq!(table.flags, 0, "not exterior by default");
+        views.exterior = true;
+        assert_eq!(TorchTableUniform::pack(Some(&views)).flags, TORCH_EXT_LANE);
+        assert_eq!(TorchTableUniform::pack(None).flags, 0, "no resource = no lane");
+    }
+
+    // MONKEY (outdoor torch shadows): EMITTER-OWNER EXCLUSION. A campfire's own logs must leave
+    // its caster gather (they are the nearest occluder on all six faces and would black out the
+    // fire's own pool); a crate beside it must not. The test is CONTAINMENT of the whole bounding
+    // sphere, so "near the fire" is not enough to be excluded — which is what keeps a long wall or
+    // a fence that merely passes the fire casting normally.
+    #[test]
+    fn only_the_fire_s_own_body_leaves_its_caster_gather() {
+        let excluded = |x: f32, half: f32, radius: f32| torch_bound_contained(
+            &Transform::from_xyz(x, 0.0, 0.0), Vec3::ZERO, Vec3::splat(half), Vec3::ZERO, radius);
+        // The campfire prop itself: centred on the flame, ~1 yd across.
+        assert!(excluded(0.2, 0.5, 2.5));
+        // A crate two yards off: its centre is inside 2.5, its sphere is not.
+        assert!(!excluded(2.0, 0.6, 2.5));
+        // A wall passing right by the fire: a huge sphere, never contained.
+        assert!(!excluded(0.0, 30.0, 2.5));
+        // The INTERIOR lane passes 0 and excludes nothing at all - its gather is untouched.
+        assert!(!excluded(0.0, 0.1, 0.0));
+        // Scale is applied to the extents, exactly as `torch_bound_in_range` applies it.
+        let scaled = Transform::from_xyz(0.0, 0.0, 0.0).with_scale(Vec3::splat(4.0));
+        assert!(!torch_bound_contained(&scaled, Vec3::ZERO, Vec3::splat(0.5), Vec3::ZERO, 2.5));
+    }
+
+    // MONKEY (torch owner exclusion): the IDENTITY key. Both caster lanes have to agree on it while
+    // holding the placement identity in two different shapes — the retained `GxItem` owns an `Arc`,
+    // the entity path's parts own a CLONE — so the comparison must be by CONTENT, never by pointer.
+    // And WMO props all share their building's uniqueId, which is why the model path is in the key:
+    // without it a candelabra's light would drop every barrel and chair in the building.
+    #[test]
+    fn a_light_owner_names_one_placement_by_content() {
+        let lantern = WorldObject {
+            kind: ModelKind::Doodad,
+            label: "world/generic/lantern01.m2".into(),
+            id: 4242,
+            detail: "emitters: 1".into(),
+        };
+        let owner = LightOwner::placement(&lantern);
+        // The entity lane's CLONE of the same identity still matches (a pointer key would not).
+        assert!(owner.owns(&lantern.clone()));
+        // Same building, different prop model — a WMO prop shares its building's uniqueId.
+        let barrel = WorldObject { label: "world/generic/barrel01.m2".into(), ..lantern.clone() };
+        assert!(!owner.owns(&barrel));
+        // Same model, different placement: the lantern down the street still casts.
+        let other = WorldObject { id: 4243, ..lantern.clone() };
+        assert!(!owner.owns(&other));
+        // The BUILDING itself is a different subsystem, so a prop light can never delete its shell.
+        let building = WorldObject { kind: ModelKind::Wmo, ..lantern.clone() };
+        assert!(!owner.owns(&building));
+        // An entity-hosted light names a frame, and never claims a placement by accident.
+        assert!(!LightOwner::Instance(Entity::from_raw_u32(7).unwrap()).owns(&lantern));
+        assert_eq!(owner.instance(), None);
+    }
+
+    // MONKEY (torch owner exclusion): the CONTAINMENT fallback, for a light whose owner could not
+    // be plumbed. The housing that holds the flame is excluded; the crate beside it is not; and —
+    // the rule that keeps the shipped interior lane intact — a room-sized batch is never excluded
+    // however deep inside it the candle sits.
+    #[test]
+    fn only_a_fixture_sized_bound_may_contain_its_own_flame() {
+        let at = |x: f32, y: f32| Transform::from_xyz(x, y, 0.0);
+        // A lantern housing 3 yd up a post: the placement's box runs from the ground to the lamp,
+        // so its CENTRE is 1.5 yd below the flame and no proximity rule of any radius finds it —
+        // the exact case `TORCH_EXT_SELF_EXCLUDE = 2.5` could not exclude.
+        let post = Vec3::new(0.0, 1.5, 0.0);
+        let post_half = Vec3::new(0.4, 1.6, 0.4);
+        let flame = Vec3::new(0.0, 3.0, 0.0);
+        assert!(torch_bound_contains(&at(0.0, 0.0), post, post_half, flame));
+        assert!(!torch_bound_contained(&at(0.0, 0.0), post, post_half, flame, TORCH_SELF_TINY),
+            "the retired proximity rule never saw it");
+        // The crate 1.5 yd away keeps casting — that shadow is the whole point of the feature.
+        assert!(!torch_bound_contains(&at(1.5, 0.3), Vec3::ZERO, Vec3::splat(0.5), flame));
+        // A room-sized wall batch holds the candle but is NOT fixture-sized: excluding it would
+        // delete the room's shadows and leak the candle through its own walls.
+        assert!(!torch_bound_contains(&at(0.0, 0.0), Vec3::ZERO, Vec3::splat(20.0), flame));
+        assert!(!torch_bound_contains(&at(0.0, 0.0), Vec3::ZERO,
+            Vec3::splat(TORCH_SELF_MAX_EXTENT), flame), "at the cap, still a building");
+        // The pad reaches a flame sitting just proud of its housing, and stops well short of the
+        // next prop along.
+        let head = Vec3::new(0.0, 0.0, 0.0);
+        let head_half = Vec3::splat(0.25);
+        assert!(torch_bound_contains(&at(0.0, 0.0), head, head_half, Vec3::new(0.0, 0.5, 0.0)));
+        assert!(!torch_bound_contains(&at(0.0, 0.0), head, head_half, Vec3::new(0.0, 0.9, 0.0)));
+        // Scale applies to the box AND to the pad (a world-space pad in model units).
+        let big = Transform::from_xyz(0.0, 0.0, 0.0).with_scale(Vec3::splat(4.0));
+        assert!(torch_bound_contains(&big, Vec3::ZERO, Vec3::splat(0.3), Vec3::new(0.0, 1.2, 0.0)));
+        assert!(!torch_bound_contains(&big, Vec3::ZERO, Vec3::splat(2.0), Vec3::ZERO),
+            "scaled past the fixture cap");
+        // A rotated post is tested against its own box, not its circumsphere.
+        let spun = Transform::from_xyz(0.0, 0.0, 0.0)
+            .with_rotation(Quat::from_rotation_y(std::f32::consts::FRAC_PI_2));
+        assert!(torch_bound_contains(&spun, Vec3::new(0.0, 1.5, 2.0), post_half,
+            Vec3::new(2.0, 3.0, 0.0)));
+        assert!(!torch_bound_contains(&spun, Vec3::new(0.0, 1.5, 2.0), post_half, flame));
+    }
+}
diff --git a/crates/benilla-world/src/terrain_stream.rs b/crates/benilla-world/src/terrain_stream.rs
index fdfa3fdd..e507f16b 100644
--- a/crates/benilla-world/src/terrain_stream.rs
+++ b/crates/benilla-world/src/terrain_stream.rs
@@ -62,7 +62,10 @@ pub use spawn::prop_light::{fold_interior_probe, hex_word, interior_light_up, Pr
 // doodad-prop path's spawner (`crate::entities`' `wmo_props`: the ship's sails ride the streamed
 // gameobject entity, and its cargo hulls ride the boat's kinematic body).
 pub use collider::{build_collider_task, placement_collider_data, PendingCollider};
-pub use spawn::{m2_anim_bound, m2_fade, point_light, spawn_model_entities, SpawnedModel};
+pub use spawn::{
+    carried_light_claims, m2_anim_bound, m2_fade, point_light, spawn_model_entities,
+    CarriedClaimSet, SpawnedModel,
+};
 // The position queries + area authority (their home is `queries`; paths stay `terrain_stream::X`).
 use queries::update_current_area;
 pub use queries::{
@@ -634,6 +637,11 @@ fn stream_terrain(
         Res<Assets<WdtIndex>>,
         Res<Time>,
         ResMut<StreamActivity>,
+        // MONKEY (outdoor torch shadows: terrain): the shared torch depth array + table every tile
+        // material binds (91/92/93). Nested here for the same 16-param reason as the rest of the
+        // tuple - this system is already AT Bevy's ceiling - and beside the material store because
+        // that is what it is: an input to the one `TerrainExtension` built below.
+        crate::static_gx::TorchShared<'_>,
     ),
     liquid_assets: Option<Res<LiquidAssets>>,
     clutter: Option<Res<GroundClutter>>,
@@ -662,11 +670,18 @@ fn stream_terrain(
     ),
 ) {
     let (mut welds, mut static_merge, mut staticgx) = batchers;
-    let (mut materials, mut meshes, wdts, _time, mut activity) = asset_stores;
+    let (mut materials, mut meshes, wdts, _time, mut activity, torch) = asset_stores;
     let (current_map, map_catalog, view) = location;
     // The shared light buffer + map catalog are set up by other plugins' startup; until they exist
     // there's nothing to stream against, so idle.
-    let (Some(shared_light), Some(map_catalog)) = (shared_light, map_catalog) else {
+    // MONKEY (outdoor torch shadows: terrain): the torch binds join that same gate. They are born in
+    // the SAME Startup system as the light buffer (`assets::open_world_assets`), so in practice the
+    // two are never split - but a tile material built against a missing depth image would never get
+    // a bind group at all, so this retries next frame exactly as `shared_light` does rather than
+    // baking a default that would blank the ground.
+    let (Some(shared_light), Some(map_catalog), Some(torch)) =
+        (shared_light, map_catalog, torch.binds())
+    else {
         return;
     };
     let t0 = Instant::now();
@@ -962,6 +977,12 @@ fn stream_terrain(
                 shadow_array: adt.shadow_array.clone(),
                 params: Vec4::new(tiling, 0.0, 0.0, 0.0),
                 light_buf: shared_light.0.clone(),
+                // MONKEY (outdoor torch shadows: terrain): cloned per tile like the light buffer -
+                // a handle + a `Buffer` (an Arc), so the per-tile cost is two refcount bumps and
+                // every tile ends up pointing at the one image and the one table the depth node
+                // rewrites each frame.
+                torch_depth: torch.depth.clone(),
+                torch_buf: torch.table.clone(),
             },
         });
         // Terrain collider (decision 0009): ONE static trimesh per tile, welded from the same decoded
diff --git a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
index ec7af3c8..898e5b7f 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
@@ -20,7 +20,7 @@ use crate::mesh_tag::alpha_bits;
 use crate::model_fade::DoodadFade;
 use crate::model_render::{model_material, MaterialCache, ShadeSel};
 use crate::model_render::{ModelKind, ModelPart};
-use benilla_assets::materials::WowModelMaterial;
+use benilla_assets::materials::{TorchBinds, WowModelMaterial};
 
 /// What one placement's animation host armed, for the consumers that spawn alongside its submeshes.
 /// All fields are *per placement*, not per model: the anchors are this instance's, and `arm` is
@@ -87,6 +87,8 @@ pub fn spawn_model_entities(
     mat_cache: &mut MaterialCache,
     materials: &mut Assets<WowModelMaterial>,
     light: &Buffer,
+    // MONKEY (torch shadows Phase 3A): the shared torch bindings, beside the light buffer.
+    torch: &TorchBinds,
     submeshes: &[ModelSubmesh],
     // The model's app-built render forms (decision 0834), index-parallel with `submeshes`: the
     // static handle + its build-time `Aabb` per batch, and the skinned twins when this model's
@@ -337,6 +339,7 @@ pub fn spawn_model_entities(
             sub.window,
             false, // the world streamer never spawns a skybox
             light,
+            torch,
             seq_owner,
         );
         // The blend twin for the distance-fade feather pass (reuse the cutout when already blend, or when
@@ -381,6 +384,7 @@ pub fn spawn_model_entities(
                 sub.window,
                 false, // the world streamer never spawns a skybox
                 light,
+                torch,
                 seq_owner,
             )
         };
@@ -495,8 +499,11 @@ pub fn spawn_model_entities(
                         (class.never_fade || fade_seed.is_some())
                             .then_some((*owner, None, None, fade_seed))
                     }
-                    crate::static_gx::GxSite::Wmo { instance, groups }
-                        if is_wmo && class.merges() =>
+                    crate::static_gx::GxSite::Wmo {
+                        instance,
+                        groups,
+                        bounds,
+                    } if is_wmo && class.merges() =>
                     {
                         groups.get(batch_idx).map(|&g| {
                             (
@@ -505,6 +512,22 @@ pub fn spawn_model_entities(
                                     instance: *instance,
                                     group: g,
                                     interior,
+                                    // MONKEY (ext-class night law): EXTERIOR-class at BUILDING
+                                    // scale — the same eligibility the exterior lane's strict
+                                    // claim term uses, so a group that may be lit by a room's
+                                    // fixtures is exactly the group that stops reading as sky.
+                                    ext_night: bounds
+                                        .get(usize::from(g))
+                                        .is_some_and(benilla_formats::room_claim::ext_building_scale),
+                                    // MONKEY (enclosed day floor): this batch's group is a ROOM
+                                    // INSIDE A BUILDING -- an interior-class group whose centre
+                                    // sits in a building-scale exterior shell of the same root.
+                                    // Same place, same table, same argument as `ext_night` above:
+                                    // this is the last point at which the model's group table is
+                                    // in hand, and the answer rides to the shader as a record bit.
+                                    enclosed: benilla_formats::room_claim::enclosed_by_building_shell(
+                                        bounds, g,
+                                    ),
                                     class: sub.wmo_batch,
                                     sidn: sub.sidn,
                                     window: sub.window,
diff --git a/crates/benilla-world/src/terrain_stream/spawn/fx.rs b/crates/benilla-world/src/terrain_stream/spawn/fx.rs
index a4e40dae..637ff272 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/fx.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/fx.rs
@@ -3,9 +3,10 @@
 //! trails). A transport prop takes the entity-owned shapes instead (`crate::entities`' `wmo_props`,
 //! decision 0474) — riding owners and prop-local children, never a world bake.
 
-use benilla_assets::coords::wow_to_bevy;
-use benilla_assets::{ModelEmitter, ModelLight};
-use benilla_formats::WmoLight;
+use benilla_assets::coords::{bevy_to_wow, wow_to_bevy};
+use benilla_assets::{ModelEmitter, ModelLight, WmoModel};
+use benilla_formats::room_claim::{self, PortalGraph};
+use benilla_formats::{WmoBatchClass, WmoGroupInfo, WmoLight};
 use bevy::prelude::*;
 
 use crate::lighting::WorldPointLight;
@@ -24,6 +25,12 @@ const POINT_LIGHT_INTENSITY: f32 = 4.0 * std::f32::consts::PI;
 /// invisible). Generous so a hall-scale WMO group whose center sits ~20 yd from its wall fixtures
 /// still gathers them — erring wide only ever admits negligible candidates.
 const POINT_LIGHT_RANGE: f32 = 48.0;
+/// MONKEY (wmo exterior points): how close an authored MOLT fixture has to stand to a prop's flame
+/// (yd) for that flame's SYNTHESISED light to be dropped as a duplicate. The vanilla convention is
+/// a MOLT authored at the flame itself, so the real pairs sit well under a yard apart; 2.5 yd
+/// covers a bracket-mounted torch whose fixture the artist put at the wall instead, without
+/// reaching the next prop along a street (Stormwind's street lamps are ≥ 8 yd apart).
+const MODD_SYNTH_DEDUPE: f32 = 2.5;
 
 /// The one [`WorldPointLight`] recipe for an authored WoW light source (M2 or WMO MOLT). The light only
 /// carries position + colour into the shared packed table; every lit surface — terrain, M2
@@ -54,6 +61,28 @@ fn spawn_point_light(
     // a culled room is one the reference never instantiated, so it lights nothing
     // ([`crate::lighting::LightRooms`], decision 0689).
     room: Option<crate::wmo_portal::WmoGroupVis>,
+    // MONKEY (fire GO lights): tag a SYNTHESISED source so the packer can ride the live
+    // `fireLightGain` cvar over it without respawning the world
+    // ([`crate::lighting::SyntheticFireLight`]).
+    synthetic: bool,
+    // MONKEY (flame flicker): the fire this source IS, or `None` for anything that merely shines
+    // (a lamp behind glass, a neutral fill light). Decided once by
+    // [`crate::lighting::flame_kind_for`] — one rule, every lane — and the phase SEED is taken here
+    // from the light's own world position, so two candles on one table are never in step and a
+    // fixture keeps its phase across a stream-out/stream-in.
+    flame: Option<crate::lighting::FlameKind>,
+    // MONKEY (interior attenuation): the source's AUTHORED attenuation end (yd) where the record
+    // carries a usable one — i.e. a WMO MOLT fixture, and nothing else. `None` for every M2 light,
+    // whose authored pair is a template default rather than a reach; the packer buckets those from
+    // intensity instead ([`crate::lighting::m2_light_reach`], and see [`crate::lighting::LightReach`]
+    // for the corpus evidence).
+    reach: Option<f32>,
+    // MONKEY (room gate): the rooms this source may LIGHT, over and above the ones that must be
+    // visible for it to exist ([`crate::lighting::LightLitRooms`] carries the whole argument).
+    // MONKEY (review fixes): MOLT and MODD claims keep their placement even with no MOLR/MODR.
+    // MONKEY (soft portal claims): the component, built whole by [`lit_rooms`] — the group ids
+    // and their per-claim fades travel together or not at all.
+    lit_rooms: Option<crate::lighting::LightLitRooms>,
     out: &mut Vec<Entity>,
 ) {
     let mut e = commands.spawn((
@@ -63,6 +92,21 @@ fn spawn_point_light(
     if let Some(room) = room {
         e.insert(crate::lighting::LightRooms(room));
     }
+    if let Some(lit) = lit_rooms.filter(|l| !l.rooms.groups.is_empty()) {
+        e.insert(lit);
+    }
+    if synthetic {
+        e.insert(crate::lighting::SyntheticFireLight);
+    }
+    if let Some(kind) = flame {
+        e.insert(crate::lighting::FlameFlicker::new(
+            kind,
+            crate::lighting::flicker_seed(world),
+        ));
+    }
+    if let Some(reach) = reach.filter(|r| *r > 0.5) {
+        e.insert(crate::lighting::LightReach(reach));
+    }
     out.push(e.id());
 }
 
@@ -74,29 +118,342 @@ fn spawn_point_light(
 /// `room` is the prop's own rooms for a WMO prop (`None` for an ADT map doodad) — taken straight off
 /// the [`emitter_fade`] built for this placement, so the prop's mesh, its flames, its streamers and
 /// its glow are all admitted or refused by one value.
+///
+/// MONKEY (fire GO lights): `synthetic` says whether this lane accepts lights DERIVED from a
+/// model's flame emitter ([`benilla_assets::ModelLight::synthetic`]). The ADT map-doodad lane does
+/// — an outdoor campfire or wall torch has nothing else to light it.
+///
+/// MONKEY (wmo exterior points) / MONKEY (interior prop lights): the **WMO MODD prop lane now does
+/// too — everywhere, indoors included.** It was first opened for EXTERIOR-class groups only (a
+/// street, a courtyard, a porch), on the reasoning that a building's artists put a companion MOLT
+/// fixture at each of its indoor torch flames, so a synthesised twin would double-light exactly the
+/// rooms the interior lane is calibrated against. That assumption is FALSE for most buildings: the
+/// `benilla-extract wmolamps` sweep counts 14,937 props across 506 roots whose model would
+/// synthesise a light, and only 4,477 of them (30%) have an authored MOLT fixture within
+/// [`MODD_SYNTH_DEDUPE`]. The Stormwind Bank's ceiling lanterns, the Crawford Winery's lanterns and
+/// the Wizard's Sanctum's candelabras are all in the other 70%, and they lit nothing at all — the
+/// reported bug. The DEDUPE, not the group class, is what stops the double-lighting where the
+/// assumption did hold (the abbey pairs 41 of its 42 flames with a fixture; the inn 8 of 33).
+///
+/// `molt_world` is the same placement's authored MOLT fixtures in world space — that DUPLICATE
+/// GUARD, applied to the synthesised light's own world position (the flame, not the prop origin,
+/// which is why the check is here and not at resolve time).
+///
+/// MONKEY (portal claims): `claims` is the owning WMO's claim inputs (`None` for an ADT map
+/// doodad). With it, a synthesised prop light gets the SAME room-claim set an authored MOLT fixture
+/// gets — its own MODR rooms, unioned with the groups whose MOGI box holds the flame and the ones
+/// one portal away — so the room gate admits a hanging lantern in the room it hangs in. Without it
+/// the light would be packed with the prop's MODR rooms alone, which for a prop no group names is
+/// no claim at all, i.e. UNGATED: one lantern lighting every room of the building through its
+/// floors. That is why the claims travel with the lane rather than being optional dressing.
 pub(super) fn spawn_lights_for(
     commands: &mut Commands,
     lights: &[ModelLight],
     transform: Transform,
     room: Option<&crate::wmo_portal::WmoGroupVis>,
+    synthetic: bool,
+    molt_world: &[Vec3],
+    claims: Option<&PropClaims<'_>>,
     out: &mut Vec<Entity>,
 ) {
-    for l in lights.iter().map(|l| &l.def) {
-        if !l.casts() {
+    // MONKEY (spell light): `l.spell.is_none()` keeps the PLACED lane exactly as it was. The spell
+    // route (`fire_light::synthesize_spell_light`) lights effect models and fireworks, whose whole
+    // premise — a light that exists for the length of one cast, budgeted and enveloped — belongs to
+    // the entity lanes that reap it with its effect. A spell model placed as scenery must not enter
+    // a table built for fixtures that stand still for minutes.
+    for l in lights
+        .iter()
+        .filter(|l| (synthetic || !l.synthetic) && l.spell.is_none())
+    {
+        let def = &l.def;
+        if !def.casts() {
             continue; // directional lights feed an ambient term; a static `0` visibility key is dark
         }
-        let world = transform.transform_point(wow_to_bevy(l.position));
+        let world = transform.transform_point(wow_to_bevy(def.position));
+        if l.synthetic
+            && molt_world
+                .iter()
+                .any(|p| p.distance_squared(world) < MODD_SYNTH_DEDUPE * MODD_SYNTH_DEDUPE)
+        {
+            continue; // an authored MOLT fixture already stands at this flame
+        }
         spawn_point_light(
             commands,
             world,
-            l.diffuse_color,
-            l.diffuse_intensity,
+            def.diffuse_color,
+            def.diffuse_intensity,
             room.cloned(),
+            l.synthetic,
+            // MONKEY (flame flicker): the flame route burns whatever colour it is; the lamp route
+            // never does; an authored block burns iff it was authored warm.
+            crate::lighting::flame_kind_for(
+                l.flame,
+                l.synthetic,
+                def.diffuse_color,
+                def.diffuse_intensity,
+            ),
+            None, // an M2 light authors no usable reach — the packer buckets it
+            // MONKEY (portal claims): the same claim set a MOLT fixture gets, measured at the
+            // FLAME. An M2 source's reach is the intensity bucket (`room_claim::m2_light_reach`,
+            // the packer's own ladder), scaled by the default `interiorAttenScale` — the portal
+            // hop has to be decided at spawn, and the live cvar is not knowable here.
+            claims.map(|c| {
+                c.claim_set(
+                    world,
+                    room_claim::claim_reach(room_claim::m2_light_reach(def.diffuse_intensity)),
+                    room.map_or(&[][..], |r| &r.groups[..]),
+                )
+            }),
             out,
         );
     }
 }
 
+/// The claim inputs of one placed WMO, borrowed straight off the loaded asset — no clone, because
+/// this is rebuilt every spawn wave while a city's props are still landing.
+pub(super) struct PropClaims<'a> {
+    // MONKEY (review fixes): lighting identity must survive an empty MODR relation.
+    instance: Entity,
+    groups: &'a [WmoGroupInfo],
+    portals: PortalGraph<'a>,
+    /// World (Bevy) → this placement's WMO model space, so a prop light's WORLD position (the
+    /// flame, resolved through the prop's own transform) can be asked the model-space question the
+    /// MOGI boxes and MOPT polygons answer.
+    to_model: bevy::math::Affine3A,
+    /// MONKEY (soft portal claims): and back out again — a claim's fade centre is a PORTAL, which
+    /// the rule answers in model space and the shader can only use in world space.
+    to_world: Transform,
+}
+
+impl<'a> PropClaims<'a> {
+    /// The claim inputs of `model`, with `slices` the caller-owned per-group portal-ref ranges
+    /// ([`portal_slices`] — owned outside because [`PortalGraph`] borrows them).
+    pub(super) fn new(
+        model: &'a WmoModel,
+        slices: &'a [(u16, u16)],
+        transform: Transform,
+        instance: Entity,
+    ) -> Self {
+        Self {
+            instance,
+            groups: &model.group_bounds,
+            portals: PortalGraph {
+                vertices: &model.portal_vertices,
+                infos: &model.portal_infos,
+                refs: &model.portal_refs,
+                slices,
+            },
+            to_model: transform.compute_affine().inverse(),
+            to_world: transform,
+        }
+    }
+
+    /// The claim set of a source at `world` (Bevy) with effective radius `reach`, in the packed
+    /// [`crate::lighting::LightLitRooms`] form.
+    fn claim_set(&self, world: Vec3, reach: f32, molr: &[u16]) -> crate::lighting::LightLitRooms {
+        let pos = bevy_to_wow(self.to_model.transform_point3(world));
+        lit_rooms(
+            self.instance,
+            &room_claim::room_claims(self.groups, self.portals, pos, reach, molr),
+            self.to_world,
+        )
+    }
+}
+
+/// MONKEY (GO room claims): the claim set of ONE **carried** light — a server-placed brazier
+/// GameObject, a campfire, an NPC's torch — standing inside a placed WMO, in the packed
+/// [`crate::lighting::LightLitRooms`] form its caller applies.
+///
+/// The same rule the placed lanes above run ([`benilla_formats::room_claim::room_claims`]), reached
+/// from the OTHER side. A MOLT fixture and a MODD prop are authored INSIDE the building, so the
+/// spawner already holds the model, the placement transform and the instance entity when it makes
+/// the light. A GameObject is not: it walks (or is `.gobject add`-ed) into a building the WMO's own
+/// MODR/MOLR tables know nothing about, and until now the only room it could ever claim was the
+/// single one the interior classifier's down-ray put its BEARER in
+/// (`benilla_app::entities::carried_light`'s [`crate::lighting::LightRooms`]). One room is one
+/// group: the brazier lit the room it stood in and stopped dead at every doorway, and standing in
+/// an EXTERIOR-class group (Orgrimmar's canyon "rooms", MOGP `& 0x48`) it named no room at all.
+///
+/// So the app asks HERE instead, with the light's own WORLD position, and gets the identical
+/// containment/MOLR/portal-hop set an authored fixture gets. `molr` is empty by construction — no
+/// group's MOLR can name a light that is not in the file — which is exactly the case the
+/// containment source was added for (`room_claim`'s module doc: the dense supplement to the sparse
+/// relation).
+///
+/// `None` when no group's authored MOGI box holds the light. That is not merely "the set is empty":
+/// containment is the ONLY base source available here, and with no base claim the portal hop has
+/// nothing to seed from, so the answer could not be anything else — returning `None` lets the
+/// caller move on to the next resident placement with one test instead of a wasted allocation.
+pub fn carried_light_claims(
+    model: &WmoModel,
+    instance: Entity,
+    // The placement's Bevy model→world (`WmoPortalInstance::world_from_local`). Inverted here, per
+    // call: a carried light's claims are rebuilt only on the gates its caller change-gates on
+    // (settle / 0.5 yd drift / residency generation / bearer room), never per frame, so caching the
+    // inverse would be state kept for an operation that does not repeat.
+    world_from_local: bevy::math::Affine3A,
+    world: Vec3,
+    reach: f32,
+) -> Option<CarriedClaimSet> {
+    let pos = bevy_to_wow(world_from_local.inverse().transform_point3(world));
+    let slices = portal_slices(model);
+    let claims = room_claim::room_claims(
+        &model.group_bounds,
+        PortalGraph {
+            vertices: &model.portal_vertices,
+            infos: &model.portal_infos,
+            refs: &model.portal_refs,
+            slices: &slices,
+        },
+        pos,
+        reach,
+        &[],
+    );
+    if !claims
+        .iter()
+        .any(|c| c.how == room_claim::ClaimHow::Contains)
+    {
+        return None; // not in this building at all
+    }
+    Some(CarriedClaimSet {
+        instance,
+        any_interior: claims.iter().any(|c| c.interior),
+        groups: pack_claims(&claims),
+        // MONKEY (soft portal claims): the placement's own transform, rebuilt from the affine the
+        // caller already holds — the fade centres are portals of THIS building and must reach the
+        // shader in world space (see [`crate::lighting::ClaimFade`]).
+        fades: pack_fades(&claims, Transform::from_matrix(world_from_local.into())),
+    })
+}
+
+/// MONKEY (GO room claims): what [`carried_light_claims`] hands back — the packed claim list plus
+/// the two facts the caller's LANE decision needs, which the packed ids alone cannot answer.
+#[derive(Clone)]
+pub struct CarriedClaimSet {
+    /// The claiming placement's [`crate::wmo_portal::WmoPortalInstance`] entity — the head word of
+    /// the GPU claim record, and the identity a claim is worthless without.
+    pub instance: Entity,
+    /// The packed group ids (`group | `[`crate::lighting::LIT_ROOM_EXT_DENY`]) — the
+    /// [`crate::lighting::LightLitRooms`] payload. Exposed raw so the caller can change-gate its
+    /// component write against the set it applied last time (a `LightLitRooms` cannot be read back:
+    /// its field is crate-private, and re-inserting an identical one would churn the archetype).
+    pub groups: std::sync::Arc<[u16]>,
+    /// MONKEY (soft portal claims): index-parallel with `groups` — each claim's doorway + fade
+    /// (world space). Exposed for the same change-gate reason `groups` is: a light that drifts
+    /// without changing WHICH rooms it claims still changes HOW FAR past each doorway it reaches,
+    /// and re-applying an identical component would churn the archetype for nothing.
+    pub fades: std::sync::Arc<[crate::lighting::ClaimFade]>,
+    /// Does the set name at least one INTERIOR-class group? The lane question: claims are read by
+    /// `interior_room_light` alone, and that function is only ever reached by a light the packer
+    /// filed on the INTERIOR lane (`static_gx.wgsl` skips every entry whose colour-row `.w < 0.5`).
+    /// So a light that claims a real room has to be moved onto that lane for its claims to mean
+    /// anything at all — see the caller for why an all-exterior set is deliberately left alone.
+    pub any_interior: bool,
+}
+
+impl CarriedClaimSet {
+    /// The component form.
+    pub fn component(&self) -> crate::lighting::LightLitRooms {
+        crate::lighting::LightLitRooms {
+            rooms: crate::wmo_portal::WmoGroupVis {
+                instance: self.instance,
+                groups: self.groups.clone(),
+            },
+            fades: self.fades.clone(),
+        }
+    }
+
+    /// Is EVERY claim exterior-lane eligible — i.e. does the strict exterior-batch room term
+    /// (`static_gx.wgsl`, `interior_room_admits(strict = true)`) admit this light on all of them?
+    ///
+    /// The caller's safety condition for moving a light onto the interior lane. A
+    /// [`crate::lighting::LIT_ROOM_EXT_DENY`] claim is a district-scale EXTERIOR shell, whose
+    /// surfaces the strict term refuses; moving such a light off the exterior lane would take its
+    /// pool off the very cobbles it stands on and give nothing back that reached them.
+    pub fn all_ext_ok(&self) -> bool {
+        self.groups
+            .iter()
+            .all(|g| g & crate::lighting::LIT_ROOM_EXT_DENY == 0)
+    }
+}
+
+/// The per-group `(portal_ref_start, portal_ref_count)` ranges of a WMO's MOPR list — the shape
+/// [`PortalGraph`] wants, which the loaded asset carries spread across [`WmoGroupNav`]
+/// (`benilla_assets`). One small Vec per placement per spawn wave; the graph itself is borrowed.
+pub(super) fn portal_slices(model: &WmoModel) -> Vec<(u16, u16)> {
+    model
+        .group_nav
+        .iter()
+        .map(|n| (n.ref_start, n.ref_count))
+        .collect()
+}
+
+/// MONKEY (portal claims): fold each claim's EXTERIOR-LANE eligibility into its group id — bit 15,
+/// which no group index can reach (the record's room key is 12 bits). A district-scale exterior
+/// shell must stay in the set (dropping it would leave some fixtures with no claims at all, and the
+/// packer's no-claims arm fails OPEN) while being invisible to the exterior batch lane, and one
+/// `Arc<[u16]>` carrying both facts is cheaper than a second parallel component.
+/// **Decoded by `RoomClaim::write` → `static_gx.wgsl`'s `CLAIM_EXT_OK`.**
+fn pack_claims(claims: &[room_claim::Claim]) -> std::sync::Arc<[u16]> {
+    claims
+        .iter()
+        .map(|c| c.group | if c.ext_ok { 0 } else { crate::lighting::LIT_ROOM_EXT_DENY })
+        .collect()
+}
+
+/// MONKEY (soft portal claims): the per-claim FADE array, index-parallel with [`pack_claims`].
+///
+/// The rule answers in the WMO's own model space (WoW axes) because that is where the MOGI boxes
+/// and MOPT polygons live; the shader has only a Bevy WORLD fragment position. So the doorway is
+/// converted here, once per claim at spawn, rather than by handing the shader a matrix to invert
+/// per fragment. A HARD claim (containment/MOLR, `fade_radius == 0`) converts to `ClaimFade`'s
+/// default and reads as "weight 1 everywhere" — the binary gate, preserved exactly where it was
+/// right.
+///
+/// The SLACK is a length and the transform is a rigid placement plus a uniform scale, so it scales
+/// with `transform.scale.x` rather than riding the full affine: a WMO placement's scale is uniform
+/// by construction (ADT/WDT store one factor), and taking the x component keeps the doorway's
+/// tolerance in the same units as the world distance the shader measures against it.
+fn pack_fades(
+    claims: &[room_claim::Claim],
+    transform: Transform,
+) -> std::sync::Arc<[crate::lighting::ClaimFade]> {
+    let scale = transform.scale.x.abs().max(1e-4);
+    claims
+        .iter()
+        .map(|c| {
+            if c.fade_radius <= 0.0 {
+                return crate::lighting::ClaimFade::default();
+            }
+            crate::lighting::ClaimFade {
+                center: transform.transform_point(wow_to_bevy(c.fade_center)),
+                slack: c.fade_slack * scale,
+                radius: c.fade_radius * scale,
+                // Dimensionless — the placement's scale does not touch it.
+                entry: c.fade_entry,
+            }
+        })
+        .collect()
+}
+
+/// MONKEY (soft portal claims): the whole [`crate::lighting::LightLitRooms`] component of one
+/// claim set — ids and fades built in one place so the two arrays cannot be produced at different
+/// lengths (the shader indexes them at a fixed stride: a short fade array would gate a claim by
+/// another claim's doorway).
+fn lit_rooms(
+    instance: Entity,
+    claims: &[room_claim::Claim],
+    transform: Transform,
+) -> crate::lighting::LightLitRooms {
+    crate::lighting::LightLitRooms {
+        rooms: crate::wmo_portal::WmoGroupVis {
+            instance,
+            groups: pack_claims(claims),
+        },
+        fades: pack_fades(claims, transform),
+    }
+}
+
 /// Spawn a [`WorldPointLight`] for each omni (`type==0`) **WMO MOLT** light at the building's `transform` (the
 /// interior fixture sources — forge fire, inn fireplaces, chapel candles/chandeliers). These radiate onto
 /// the NPCs/doodads near each fixture and onto the building's own walls/floor (decision 0273). Position
@@ -107,12 +464,30 @@ pub(super) fn spawn_lights_for(
 /// A fixture belongs to the rooms whose **MOLR** names it (`group_light_refs`, per absolute group
 /// index — the same list an interior GameObject's committed light folds), so a dungeon's brazier
 /// stops lighting the hillside above it the moment the flood leaves its room. The refs are inverted
-/// here, once per placement: a MOLT light no group names keeps no rooms and stays ungated, the same
-/// fail-open arm the prop path's empty MODR list takes.
+/// here, once per placement. MONKEY (review fixes): a MOLT light no group names keeps no VISIBILITY
+/// rooms (the prop path's empty-MODR fail-open PVS arm); its lighting claims below still gate which
+/// rooms it may illuminate, keyed to the placement independently of that sparse MOLR relation.
+///
+/// MONKEY (room gate) / MONKEY (portal claims): the rooms a fixture may LIGHT are a wider set than
+/// that, and it is built by [`benilla_formats::room_claims`] — the one rule, shared with the
+/// `benilla-extract wmolights`/`wmolamps` audits so what the instrument prints is what the shader
+/// enforces. Containment (the interior groups whose authored MOGI box holds the fixture) is the
+/// dense supplement the sparse MOLR relation needs — the Goldshire inn authors a MOLR on 2 of its
+/// 12 groups and NSabbey leaves seven rooms unnamed, so a MOLR-only gate blacks both buildings out;
+/// the PORTAL hop is what carries a fixture's light through an open doorway into the next room,
+/// without which a continuous floor changes brightness in a straight line at the group boundary.
+/// See that module for the whole argument, including why a district-scale exterior shell is kept in
+/// the set but barred from the exterior lane.
 pub(super) fn spawn_wmo_lights_for(
     commands: &mut Commands,
     lights: &[WmoLight],
     group_light_refs: &[Vec<u16>],
+    // MONKEY (room gate) / MONKEY (portal claims): the root's group table + portal graph, for
+    // [`benilla_formats::room_claims`]. A MOLT record's position is already in the space they are
+    // in, so this lane needs no inverse transform (the prop lane, whose flame is resolved in world
+    // space, does — see [`PropClaims`]).
+    groups: &[WmoGroupInfo],
+    portals: PortalGraph<'_>,
     instance: Option<Entity>,
     transform: Transform,
     out: &mut Vec<Entity>,
@@ -122,7 +497,7 @@ pub(super) fn spawn_wmo_lights_for(
             continue; // spot/directional/ambient MOLT types are not point sources
         }
         let i = i as u16;
-        let groups: std::sync::Arc<[u16]> = group_light_refs
+        let molr: std::sync::Arc<[u16]> = group_light_refs
             .iter()
             .enumerate()
             .filter(|(_, refs)| refs.contains(&i))
@@ -135,13 +510,139 @@ pub(super) fn spawn_wmo_lights_for(
             l.color,
             l.intensity,
             instance
-                .filter(|_| !groups.is_empty())
-                .map(|instance| crate::wmo_portal::WmoGroupVis { instance, groups }),
+                .filter(|_| !molr.is_empty())
+                .map(|instance| crate::wmo_portal::WmoGroupVis {
+                    instance,
+                    groups: molr.clone(),
+                }),
+            false, // a MOLT fixture is authored, never synthesised
+            // MONKEY (flame flicker): an authored fixture burns iff it was authored WARM. The MOLT
+            // corpus is overwhelmingly candles and wall torches at that hue; what the warmth test
+            // holds back is the neutral-white fill lights artists park in halls (which must stay
+            // dead steady) and the cold magic sources.
+            crate::lighting::flame_kind_for(false, false, l.color, l.intensity),
+            // MONKEY (interior attenuation): the fixture's authored `attenuation_end` (`+0x2c`) —
+            // the reference's own fold window (wow-re `trace-forensics-abbey-interior-d3d` §4), and
+            // the number that turns a 10-candle inn from a uniform warm wash into ten pools. The
+            // 48 yd `PointLight::range` beside it stays what it always was: candidacy, not reach.
+            Some(l.attenuation_end),
+            // MONKEY (room gate) / MONKEY (portal claims): the rooms this fixture may LIGHT — its
+            // MOLR rooms, the ones whose authored box holds it, and the ones one open doorway away
+            // within its reach, in that priority. Dropped when the placement has no portal instance
+            // — without one there is nothing for a claim to be keyed to, and the packer leaves the
+            // fixture ungated.
+            instance.map(|instance| {
+                lit_rooms(
+                    instance,
+                    &room_claim::room_claims(
+                        groups,
+                        portals,
+                        l.position,
+                        room_claim::claim_reach(l.attenuation_end),
+                        &molr,
+                    ),
+                    transform,
+                )
+            }),
             out,
         );
     }
 }
 
+/// MONKEY (daylight fixtures): spawn one interior-lane point light per EXTERIOR-FACING OPENING of
+/// this placement — the doorways and windows whose sunlit threshold the room law otherwise meets
+/// with a hard line (see `crate::lighting`'s `daylight` module for the whole argument, the two
+/// seeds and the corpus measurement behind them).
+///
+/// It is deliberately the SAME entity shape a MOLT fixture gets — [`crate::lighting::LightRooms`]
+/// for the visibility gate, the `room_claims` claim set through [`lit_rooms`],
+/// [`crate::lighting::LightReach`] for the packer's window, an interior `LightLane` — so the
+/// packer, the claim table, the shader and the std430 layout all need no knowledge that this source
+/// is the sun rather than a candle. What it does NOT get is a `FlameFlicker` (daylight is steady)
+/// or `SyntheticFireLight` (`fireLightGain` must not be able to dim the sun).
+///
+/// The `PointLight` itself is NOT spawned here: `update_daylight_fixtures` inserts it on the first
+/// frame it is day, with the sun-calibrated colour and intensity. A placeholder would pack one
+/// uncalibrated frame — a flash of the wrong brightness in every doorway of a building that just
+/// streamed in — and a placement streaming in at night would spawn a light only to have it removed.
+///
+/// `instance` absent (a placement with no portal instance) means there is nothing to key a room
+/// claim to, and an unclaimed interior fixture is packed UNGATED, which fails OPEN — one doorway
+/// lighting every room of the building through its walls. Such a placement gets no daylight at all,
+/// exactly as the MOLT lane drops its own claims there.
+pub(super) fn spawn_daylight_fixtures_for(
+    commands: &mut Commands,
+    model: &WmoModel,
+    portals: PortalGraph<'_>,
+    instance: Option<Entity>,
+    transform: Transform,
+    out: &mut Vec<Entity>,
+) {
+    let Some(instance) = instance else {
+        return;
+    };
+    // The APERTURE seed's input: every render batch of the root as `(group, EXT-class?, points)`,
+    // borrowed straight off the loaded asset's two parallel arrays. The selection rule consumes it
+    // lazily, so a root whose groups are all exterior walks the batches once and allocates nothing.
+    let batches = model
+        .submeshes
+        .iter()
+        .zip(model.submesh_group.iter())
+        .map(|(s, g)| {
+            (
+                *g,
+                matches!(s.wmo_batch, Some(WmoBatchClass::Ext)),
+                &s.geometry.positions[..],
+            )
+        });
+    // MONKEY (portal bleed): one selection call for both lanes -- the exterior-facing openings that
+    // get the SUN and the interior<->interior doorways that get the ROOM NEXT DOOR -- ranked by area
+    // against each other, so the eight slots go to this building's biggest openings whichever kind
+    // they are.
+    let (day, bleed) = crate::lighting::placement_openings(&model.group_bounds, portals, batches);
+    for seed in day {
+        let fixture = seed.fixture(instance);
+        let claims = crate::lighting::daylight_claims(&model.group_bounds, portals, &seed);
+        let e = commands
+            .spawn((
+                Transform::from_translation(transform.transform_point(wow_to_bevy(seed.pos))),
+                fixture,
+                crate::lighting::daylight_rooms(instance, seed.group),
+                lit_rooms(instance, &claims, transform),
+                crate::lighting::LightReach(fixture.reach),
+                crate::lighting::daylight_lane(),
+            ))
+            .id();
+        out.push(e);
+    }
+    // MONKEY (portal bleed): the doorway fixtures. Deliberately the SAME bundle as above plus one
+    // component -- a bleed IS a daylight fixture as far as the packer, the claim table, the shader
+    // and `torch_shadow` are concerned, and `BleedFixture` only names the two rooms it joins and the
+    // plane it is calibrated at (in WORLD space: the per-frame evaluation has world positions and no
+    // placement matrix). Its visibility gate takes BOTH rooms, not one. The `PointLight` is again NOT
+    // spawned here -- a doorway between two unlit rooms never gets one at all.
+    for seed in bleed {
+        let fixture = seed.fixture(instance);
+        let claims = seed.claims(&model.group_bounds, portals);
+        let world = transform.transform_point(wow_to_bevy(seed.pos));
+        let e = commands
+            .spawn((
+                Transform::from_translation(world),
+                fixture,
+                crate::lighting::BleedFixture {
+                    sides: seed.sides,
+                    probe: world,
+                },
+                seed.rooms(instance),
+                lit_rooms(instance, &claims, transform),
+                crate::lighting::LightReach(fixture.reach),
+                crate::lighting::daylight_lane(),
+            ))
+            .id();
+        out.push(e);
+    }
+}
+
 /// The **one draw-set gate a placed model's emitters share** — the quad clouds and the ribbon
 /// trails alike, built once per placement so the two families can never be handed different
 /// answers about whether their model is in the frame's scene.
@@ -284,3 +785,137 @@ pub(super) fn spawn_ribbons_for(
         );
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{carried_light_claims, pack_claims};
+    use benilla_formats::room_claim::{room_claims, PortalGraph};
+    use benilla_formats::WmoGroupInfo;
+    use benilla_assets::WmoModel;
+    use bevy::prelude::*;
+
+    fn g(interior: bool, min: [f32; 3], max: [f32; 3]) -> WmoGroupInfo {
+        WmoGroupInfo {
+            interior,
+            show_skybox: false,
+            bbox_min: min,
+            bbox_max: max,
+        }
+    }
+
+    /// MONKEY (room gate): the Goldshire inn's real numbers — the measurement the whole gate rests
+    /// on. Its ground-floor fixture L0 stands at model-space `(-9.13, -1.13, 4.48)`; the basement
+    /// (`room03`, `z -6.76 .. 0.45`) does not contain it and so takes no claim, which is exactly
+    /// the reported leak (a basement lit bright through its own floor). The `kitchen` group, whose
+    /// authored box does contain it, gets it — first, because it is the tightest box that does.
+    ///
+    /// MONKEY (portal claims): the building's `upstairs` SHELL is claimed too now, and that is the
+    /// change. It is EXTERIOR-flagged, so it can never call the interior lane; the claim exists for
+    /// the exterior batch lane, which is what stops that shell reading night-sky green a step away
+    /// from a candle-lit room. At `57.7 x 32.2 yd` it is building-scale, so it is exterior-lane
+    /// eligible (no `LIT_ROOM_EXT_DENY` bit) — a city's district shell would not be.
+    #[test]
+    fn a_fixture_claims_the_rooms_whose_authored_box_holds_it() {
+        let groups = [
+            g(true, [14.11, -4.86, 0.40], [20.47, -0.38, 4.37]),      // g0, far corner room
+            g(true, [-17.07, -11.08, -0.21], [14.39, 15.54, 16.32]),  // g1 (inn "kitchen")
+            g(true, [-36.75, -8.67, -6.76], [-17.01, 12.68, 0.45]),   // g2 (inn "room03", basement)
+            g(false, [-37.77, -13.53, -0.18], [19.91, 18.68, 23.28]), // g3 (inn "upstairs" SHELL)
+        ];
+        let claim = |p: [f32; 3]| room_claims(&groups, PortalGraph::default(), p, 11.2, &[]);
+        assert_eq!(
+            &pack_claims(&claim([-9.13, -1.13, 4.48]))[..],
+            &[1, 3],
+            "the room it stands in first, then the shell around it — and NOT the basement"
+        );
+        assert!(
+            claim([-31.84, 1.48, -3.0]).iter().any(|c| c.group == 2),
+            "a fixture actually IN the basement does claim it"
+        );
+        assert!(
+            claim([500.0, 0.0, 0.0]).is_empty(),
+            "a fixture outside every box claims nothing (the packer then leaves it ungated)"
+        );
+    }
+
+    /// MONKEY (portal claims): a DISTRICT-scale exterior shell (Stormwind's, 200-660 yd) still
+    /// gates the fixture — dropping it would leave some fixtures claimless, and no claims fails
+    /// OPEN — but carries the deny bit so the exterior lane cannot light a whole city block from
+    /// one tavern candle.
+    #[test]
+    fn a_district_shell_is_claimed_but_barred_from_the_exterior_lane() {
+        let groups = [g(false, [-510.81, -82.83, -5.78], [-315.12, 101.35, 126.18])];
+        let packed = pack_claims(&room_claims(
+            &groups,
+            PortalGraph::default(),
+            [-400.0, 0.0, 10.0],
+            11.2,
+            &[],
+        ));
+        assert_eq!(&packed[..], &[crate::lighting::LIT_ROOM_EXT_DENY]);
+    }
+
+    /// GOLDEN — MONKEY (GO room claims). A CARRIED light (a brazier GameObject) asks the placed
+    /// lanes' claim rule from the outside, at its own WORLD position, and gets the identical
+    /// answer an authored MOLT fixture standing there would: the tightest containing room first,
+    /// then the shell around it. It also reports the two facts the caller's LANE decision needs and
+    /// the packed ids cannot carry — whether any claim is on an INTERIOR-class group, and whether
+    /// every claim is exterior-lane eligible.
+    ///
+    /// `None` outside every authored box is the contract the caller's placement scan rides: with no
+    /// containment there is no base claim, so the portal hop has nothing to seed from and the
+    /// answer could not have been anything else. One test, and the scan moves to the next building.
+    #[test]
+    fn a_carried_light_claims_the_building_it_stands_in() {
+        // The Goldshire inn again (the numbers the whole gate was measured on), placed 100 yd east
+        // so the world→model inverse is doing real work rather than being identity.
+        let mut model = WmoModel {
+            group_bounds: vec![
+                g(true, [-17.07, -11.08, -0.21], [14.39, 15.54, 16.32]), // g0 "kitchen"
+                g(true, [-36.75, -8.67, -6.76], [-17.01, 12.68, 0.45]),  // g1 "room03", basement
+                g(false, [-37.77, -13.53, -0.18], [19.91, 18.68, 23.28]), // g2 "upstairs" SHELL
+            ],
+            ..default()
+        };
+        let placement = Transform::from_xyz(100.0, 0.0, 0.0);
+        let world_from_local = placement.compute_affine();
+        // Model-space (-9.13, -1.13, 4.48) — the inn's real ground-floor fixture L0.
+        let at = placement.transform_point(benilla_assets::coords::wow_to_bevy([
+            -9.13, -1.13, 4.48,
+        ]));
+        let inst = Entity::from_raw_u32(12).unwrap();
+
+        let set = carried_light_claims(&model, inst, world_from_local, at, 11.2)
+            .expect("the inn's authored boxes hold it");
+        assert_eq!(set.instance, inst);
+        assert_eq!(
+            &set.groups[..],
+            &[0, 2],
+            "the room it stands in, then the building shell — never the basement below it"
+        );
+        assert!(set.any_interior, "g0 is interior-class: the lane may move");
+        assert!(
+            set.all_ext_ok(),
+            "the inn's shell is building-scale, so the strict exterior term still admits it"
+        );
+
+        // A light 500 yd away is in no building: the caller tries the next placement.
+        assert!(
+            carried_light_claims(&model, inst, world_from_local, at + Vec3::X * 500.0, 11.2)
+                .is_none()
+        );
+
+        // A DISTRICT-scale exterior shell (a city's canyon) still gates the light — dropping the
+        // claim would pack it UNGATED, which fails open — but it is barred from the exterior lane,
+        // so `all_ext_ok` is false and the caller leaves the light on the EXTERIOR lane rather than
+        // taking its pool off the very cobbles it stands on.
+        model.group_bounds = vec![g(false, [-510.81, -82.83, -5.78], [-315.12, 101.35, 126.18])];
+        let canyon = placement.transform_point(benilla_assets::coords::wow_to_bevy([
+            -400.0, 0.0, 10.0,
+        ]));
+        let set = carried_light_claims(&model, inst, world_from_local, canyon, 11.2)
+            .expect("the district shell contains it");
+        assert!(!set.any_interior);
+        assert!(!set.all_ext_ok());
+    }
+}
diff --git a/crates/benilla-world/src/terrain_stream/spawn/mod.rs b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
index 5838d886..16c38d00 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/mod.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
@@ -8,7 +8,9 @@ mod fx;
 pub(crate) mod prop_light;
 
 pub use assemble::{spawn_model_entities, SpawnedModel};
-pub use fx::point_light;
+// MONKEY (GO room claims): `carried_light_claims` is the placed lanes' claim rule reached from
+// the app side, for a light a WMO's own tables never named (a brazier GameObject).
+pub use fx::{carried_light_claims, point_light, CarriedClaimSet};
 use fx::{
     emitter_fade, spawn_emitters_for, spawn_lights_for, spawn_ribbons_for, spawn_wmo_lights_for,
 };
@@ -69,6 +71,9 @@ type SpawnTables<'w> = (
     // `None` only under `WOW_STATIC_GX=0` (the resource exists whenever the retained pass
     // is armed — the default since 1434).
     Option<ResMut<'w, crate::static_gx::StaticGx>>,
+    // MONKEY (torch shadows Phase 3A): the shared torch bindings every spawned material takes
+    // (nested here for the same 16-param reason as the rest of the tuple).
+    crate::static_gx::TorchShared<'w>,
 );
 
 pub(super) fn spawn_loaded_placements(
@@ -96,10 +101,15 @@ pub(super) fn spawn_loaded_placements(
     // model-forms cache (decision 0834).
     tables: SpawnTables,
 ) {
-    let (mut probes, mut activity, focus, mut forms, mut welds, mut merge, mut staticgx) = tables;
+    let (mut probes, mut activity, focus, mut forms, mut welds, mut merge, mut staticgx, torch) =
+        tables;
     let Some(shared_light) = shared_light else {
         return;
     };
+    let Some(torch) = torch.binds() else {
+        return; // created in the same startup system as the light buffer — retry like it
+    };
+    let torch = &torch;
     // Steady state is everything spawned, and the walk below still visits every placement and
     // every WMO prop to find that out — the pending count (kept by the register/handoff/release
     // sites) makes that frame free.
@@ -145,7 +155,19 @@ pub(super) fn spawn_loaded_placements(
             let entities = match &p.model {
                 ModelHandle::M2(h) => {
                     let Some(m) = m2s.get(h) else {
-                        continue; // model still loading (or missing) — try next frame
+                        // MONKEY (missing model): a placement whose M2 the client doesn't ship
+                        // (`Path not found`) can never spawn — left pending it holds the loading
+                        // screen's scene term down FOREVER (Stormwind harbour's
+                        // `alliancebrasscannon_flat.m2`, 2026-09-08). Retire it as an empty
+                        // spawn so the accounting completes; the reference draws nothing there
+                        // either.
+                        if matches!(asset_server.load_state(h), bevy::asset::LoadState::Failed(_)) {
+                            warn!("placement {unique_id}: its model failed to load — spawning nothing");
+                            p.spawned = true;
+                            *pending_spawns -= 1;
+                            activity.placements_spawned += 1;
+                        }
+                        continue; // model still loading — try next frame
                     };
                     // The model's app-built render forms (decision 0834): request static — plus
                     // the skinned twins iff the anim host will rig this model — and wait for the
@@ -212,6 +234,7 @@ pub(super) fn spawn_loaded_placements(
                         mat_cache,
                         materials,
                         light,
+                        torch,
                         &m.submeshes,
                         FormSlices {
                             stat: forms.static_meshes(key).unwrap_or(&[]),
@@ -303,7 +326,28 @@ pub(super) fn spawn_loaded_placements(
                         ents.first().copied(),
                         &fade,
                     );
-                    spawn_lights_for(&mut commands, &m.lights, p.transform, None, &mut ents);
+                    // MONKEY (fire GO lights): `true` — an ADT map doodad's campfire/wall
+                    // torch/brazier takes a SYNTHESISED light when it authors none; outdoors
+                    // there is no MOLT fixture beside it and nothing else would light it.
+                    // Empty dedupe list: an ADT map doodad belongs to no WMO, so there is no MOLT
+                    // table its flame could be duplicating.
+                    // MONKEY (torch owner exclusion): where this placement's own lights start in
+                    // `ents`, so they — and ONLY they — can be tagged with its identity below.
+                    let lights_from = ents.len();
+                    spawn_lights_for(
+                        &mut commands,
+                        &m.lights,
+                        p.transform,
+                        None,
+                        true,
+                        &[],
+                        // MONKEY (portal claims): an ADT map doodad belongs to no building, so
+                        // there is no group table to claim a room in — the packer leaves its
+                        // light ungated, exactly as before.
+                        None,
+                        &mut ents,
+                    );
+                    tag_light_owner(&mut commands, &ents[lights_from..], &object);
                     tag_world_object(&mut commands, &ents, &object);
                     if let Some((target, r)) = fade_near_target() {
                         let pos = p.transform.translation;
@@ -324,6 +368,14 @@ pub(super) fn spawn_loaded_placements(
                 }
                 ModelHandle::Wmo(h) => {
                     let Some(m) = wmos.get(h) else {
+                        // MONKEY (missing model): see the M2 arm — a WMO the client lacks
+                        // retires as an empty spawn rather than pinning the loading screen.
+                        if matches!(asset_server.load_state(h), bevy::asset::LoadState::Failed(_)) {
+                            warn!("placement {unique_id}: its WMO failed to load — spawning nothing");
+                            p.spawned = true;
+                            *pending_spawns -= 1;
+                            activity.placements_spawned += 1;
+                        }
                         continue;
                     };
                     // The building's app-built render forms (0834): static only — WMO group
@@ -397,6 +449,7 @@ pub(super) fn spawn_loaded_placements(
                         mat_cache,
                         materials,
                         light,
+                        torch,
                         &m.submeshes,
                         FormSlices {
                             stat: forms.static_meshes(key).unwrap_or(&[]),
@@ -434,6 +487,9 @@ pub(super) fn spawn_loaded_placements(
                                     crate::static_gx::GxSite::Wmo {
                                         instance: i,
                                         groups: &m.submesh_group,
+                                        // MONKEY (ext-class night law): the MOGI table, so the
+                                        // assembler can read each batch's group CLASS + BOX.
+                                        bounds: &m.group_bounds,
                                     },
                                 )
                             })
@@ -626,10 +682,37 @@ pub(super) fn spawn_loaded_placements(
                     // Interior MOLT lights (forge fire, inn fireplaces, chapel candles) — the radiating
                     // sources that light nearby NPCs/doodads AND the building's own walls/floor over
                     // their baked MOCV (decision 0273).
+                    // MONKEY (portal claims): the per-group MOPR ranges the claim rule's portal
+                    // hop indexes — one small Vec per placement, built here because the graph it
+                    // completes is borrowed from the asset.
+                    let slices = fx::portal_slices(m);
                     spawn_wmo_lights_for(
                         &mut commands,
                         &m.lights,
                         &m.group_light_refs,
+                        &m.group_bounds,
+                        benilla_formats::PortalGraph {
+                            vertices: &m.portal_vertices,
+                            infos: &m.portal_infos,
+                            refs: &m.portal_refs,
+                            slices: &slices,
+                        },
+                        p.portal_instance,
+                        p.transform,
+                        &mut ents,
+                    );
+                    // MONKEY (daylight fixtures): …and one interior-lane light per exterior-facing
+                    // opening, so the room law has a sun to find at the threshold instead of
+                    // meeting the sky-lit doorway with a hard line (`lighting::daylight`).
+                    fx::spawn_daylight_fixtures_for(
+                        &mut commands,
+                        m,
+                        benilla_formats::PortalGraph {
+                            vertices: &m.portal_vertices,
+                            infos: &m.portal_infos,
+                            refs: &m.portal_refs,
+                            slices: &slices,
+                        },
                         p.portal_instance,
                         p.transform,
                         &mut ents,
@@ -661,11 +744,47 @@ pub(super) fn spawn_loaded_placements(
         // Copied out before the loop borrows `p.doodads`: the props tag onto the same portal
         // instance their building's groups did (decision 0689).
         let portal_instance = p.portal_instance;
+        // MONKEY (wmo exterior points): this placement's authored MOLT fixtures in world space —
+        // the duplicate guard for the synthesised prop lights below (`spawn_lights_for`). Built
+        // here, once per placement per spawn wave, and only while props are still landing: it is
+        // read by the prop loop, which cannot reach `p.model`/`p.transform` while it holds
+        // `p.doodads` mutably. Empty for an M2 placement, and for a WMO whose root isn't resident.
+        //
+        // MONKEY (interior prop lights): the owning WMO asset itself is held alongside, for the
+        // ROOM CLAIMS a synthesised prop light now needs (`fx::PropClaims`). It borrows `wmos`
+        // (a `Res`), never the placement, so it survives the `&mut p.doodads` below — which is
+        // exactly why `p.transform` and the fixture list are copied out here instead.
+        let wmo: Option<&WmoModel> = match &p.model {
+            ModelHandle::Wmo(h) if p.doodads.iter().any(|d| !d.spawned) => wmos.get(h),
+            _ => None,
+        };
+        let placement = p.transform;
+        let molt_world: Vec<Vec3> = wmo
+            .map(|w| {
+                w.lights
+                    .iter()
+                    .filter(|l| l.is_omni())
+                    .map(|l| placement.transform_point(wow_to_bevy(l.position)))
+                    .collect()
+            })
+            .unwrap_or_default();
+        let slices = wmo.map(fx::portal_slices).unwrap_or_default();
+        // MONKEY (review fixes): the claim list owns its placement even when no MODR names it.
+        let claims = wmo.zip(portal_instance)
+            .map(|(w, instance)| fx::PropClaims::new(w, &slices, placement, instance));
         for d in &mut p.doodads {
             if d.spawned {
                 continue;
             }
             let Some(m) = m2s.get(&d.handle) else {
+                // MONKEY (missing model): a prop whose M2 the client doesn't ship would hold its
+                // BUILDING un-"up" (`placements_pending`) for the loading screen's whole life —
+                // the 2371 s Stormwind hang on `alliancebrasscannon_flat.m2`. Retire the prop.
+                if matches!(asset_server.load_state(&d.handle), bevy::asset::LoadState::Failed(_)) {
+                    warn!("placement {unique_id}: a WMO prop's model failed to load — skipping it");
+                    d.spawned = true;
+                    *pending_spawns -= 1;
+                }
                 continue; // this prop's M2 still loading
             };
             // The prop's app-built render forms (0834) — same gate as its owning placement's.
@@ -756,6 +875,7 @@ pub(super) fn spawn_loaded_placements(
                 mat_cache,
                 materials,
                 light,
+                torch,
                 &m.submeshes,
                 FormSlices {
                     stat: forms.static_meshes(key).unwrap_or(&[]),
@@ -893,13 +1013,34 @@ pub(super) fn spawn_loaded_placements(
                 ents.first().copied(),
                 &fade,
             );
+            // MONKEY (torch owner exclusion): as at the ADT site — the prop's OWN lights only.
+            let lights_from = ents.len();
             spawn_lights_for(
                 &mut commands,
                 &m.lights,
                 d.transform,
                 fade.room.as_ref(), // the prop's glow rides its rooms like its mesh (0689)
+                // MONKEY (interior prop lights): a synthesised flame/lamp light is accepted for
+                // EVERY WMO prop now, indoors included. This was `matches!(d.light,
+                // PropLight::Exterior)` — exterior-group props only — on the reasoning that a
+                // building's artists put a MOLT fixture at each of its indoor flames, so a
+                // synthesised twin would double-light the interiors the lane is calibrated
+                // against. The `wmolamps` sweep measures that assumption at 30% true: of the
+                // 14,937 props corpus-wide whose model would synthesise a light, only 4,477 have
+                // an authored fixture within `MODD_SYNTH_DEDUPE`. The Stormwind Bank's ceiling
+                // lanterns, the Crawford Winery's lanterns and the Wizard's Sanctum's candelabras
+                // are all in the other 70% and lit nothing at all. The DEDUPE below, not the
+                // group class, is what holds the double-lighting back where the assumption is
+                // true (NSabbey pairs 41 of its 42 flames with a fixture, and keeps 0).
+                true,
+                // …so skip a flame an authored fixture already stands at.
+                &molt_world,
+                // MONKEY (portal claims): and give the kept ones the same room claims a MOLT
+                // fixture gets, or the gate would refuse a lantern in the room it hangs in.
+                claims.as_ref(),
                 &mut ents,
             );
+            tag_light_owner(&mut commands, &ents[lights_from..], &object);
             tag_world_object(&mut commands, &ents, &object);
             p.entities.extend(ents);
             d.spawned = true;
@@ -1062,6 +1203,27 @@ fn tag_world_object(commands: &mut Commands, ents: &[Entity], object: &Arc<World
     }
 }
 
+/// MONKEY (torch owner exclusion): stamp a placement's OWN M2 lights with its identity, so the
+/// torch-shadow caster gathers can drop the fixture's own body out of its own shadow map
+/// (`static_gx::LightOwner` carries the whole argument).
+///
+/// Narrow on purpose — this takes the slice of `ents` that [`fx::spawn_lights_for`] just appended,
+/// never the placement's whole entity list, and it is NOT folded into [`tag_world_object`]. The
+/// WMO lane runs `tag_world_object` over its authored MOLT fixtures too, and a MOLT fixture's
+/// placement identity is the BUILDING's: tagged, an inn's hearth would name every wall, floor and
+/// pillar of the inn as its own body and the interior shadow lane would go dark. A MOLT light has
+/// no model of its own, so it needs no exclusion at all — only a light SYNTHESISED from (or
+/// authored inside) a model does, and those are exactly the ones `spawn_lights_for` makes.
+fn tag_light_owner(commands: &mut Commands, lights: &[Entity], object: &Arc<WorldObject>) {
+    if lights.is_empty() {
+        return;
+    }
+    let owner = crate::static_gx::LightOwner::placement(object);
+    for &e in lights {
+        commands.entity(e).insert(owner);
+    }
+}
+
 /// The **animated cull bound** for an M2 placement: the model's authored header bounding box
 /// (`M2Header.bounding_box_min/max`), in Bevy model-local space. `None` when the model carries no
 /// authored bounds.
diff --git a/crates/benilla-world/src/wmo_portal/mod.rs b/crates/benilla-world/src/wmo_portal/mod.rs
index ff7fc4ce..d3afd34d 100644
--- a/crates/benilla-world/src/wmo_portal/mod.rs
+++ b/crates/benilla-world/src/wmo_portal/mod.rs
@@ -170,6 +170,22 @@ pub struct WmoGroupVis {
 }
 
 impl WmoGroupVis {
+    /// MONKEY (fire GO lights): a claim on exactly ONE room, for a rider whose membership comes
+    /// from the interior CLASSIFIER's down-ray ([`crate::interior::InteriorAnchor::room`]) rather
+    /// than from a building's own MODR/MOLR tables — an entity's carried light, whose owner walked
+    /// in through the door and is named by no chunk.
+    ///
+    /// One group, not the referrer set the table-driven path builds, and that is the honest shape:
+    /// the ray answers "which group is this standing in", singular. The `Arc` is a one-element
+    /// allocation per claim, which is nothing beside the per-frame ray it replaces — and it is
+    /// re-made only when the anchor's room actually changes (the claim system is change-gated).
+    pub fn single(instance: Entity, group: u16) -> Self {
+        Self {
+            instance,
+            groups: std::sync::Arc::from([group]),
+        }
+    }
+
     /// The portal verdict: drawn iff **any** referencing group is in this frame's PVS. An index
     /// past the instance's visible set (a stale or short set) reads as visible — the same fail-open
     /// the rest of the cull takes, so a lookup miss can never blank a building.