diff --git a/crates/benilla-app/src/character_shadow.rs b/crates/benilla-app/src/character_shadow.rs
index 56a8209a..149dda4a 100644
--- a/crates/benilla-app/src/character_shadow.rs
+++ b/crates/benilla-app/src/character_shadow.rs
@@ -17,7 +17,7 @@ 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, ShadowDemand, ShadowFrame, ShadowSet,
+    spawn_solid_caster, take_mesh_buffers, RebuildRate, ShadowDemand, ShadowFrame, ShadowSet,
 };
 use crate::video::VideoConfig;
 
@@ -37,11 +37,15 @@ struct CharacterLane {
     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>,
@@ -73,6 +77,8 @@ fn collect_character_shadows(
         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 {
@@ -80,12 +86,30 @@ fn collect_character_shadows(
     };
 
     // Animated rigs re-skin every frame and creatures spawn/despawn under lifecycles this lane
-    // can't cheaply observe — so the caster is collected fresh every frame.
+    // 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) {
diff --git a/crates/benilla-app/src/cvars.rs b/crates/benilla-app/src/cvars.rs
index 701cb66d..d291827a 100644
--- a/crates/benilla-app/src/cvars.rs
+++ b/crates/benilla-app/src/cvars.rs
@@ -600,6 +600,35 @@ pub(crate) const REGISTERED: &[Registered] = &[
         "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 —
@@ -660,6 +689,14 @@ pub(crate) const REGISTERED: &[Registered] = &[
         "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",
@@ -671,6 +708,17 @@ pub(crate) const REGISTERED: &[Registered] = &[
         "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.
@@ -682,7 +730,7 @@ pub(crate) const REGISTERED: &[Registered] = &[
     ours(
         "interiorDebug",
         "0",
-        "benilla's own: interior diagnostic overlay — 1 classification, 2 shadow, 3 caster count",
+        "benilla's own: interior diagnostic overlay — 1 classification, 2 shadow, 3 caster count, 4 WMO lane map",
     ),
     // 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
@@ -694,6 +742,16 @@ pub(crate) const REGISTERED: &[Registered] = &[
         "1",
         "benilla's own: brightness of lights synthesised from fire props' flame emitters (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
@@ -1179,6 +1237,34 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
             knobs.video.shadow_distance =
                 v.clamp(*SHADOW_DISTANCE_RANGE.start(), *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" => {
+            knobs.video.shadow_map_size =
+                crate::shadow_core::clamp_shadow_map_size(v.max(0.0) as u32);
+        }
+        "shadowfilter" => {
+            knobs.video.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" => {
+            knobs.video.character_shadow_rate =
+                (v.max(0.0) as u32).min(crate::shadow_core::MAX_SHADOW_RATE);
+        }
+        "worldshadowrate" => {
+            knobs.video.world_shadow_rate =
+                (v.max(0.0) as u32).min(crate::shadow_core::MAX_SHADOW_RATE);
+        }
+        "shadowcasterreach" => {
+            knobs.video.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" => knobs.video.interior_light = v != 0.0,
@@ -1190,6 +1276,10 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
         "interiorattenscale" => knobs.video.interior_atten_scale = v.clamp(0.0, 8.0),
         "interiorroomgate" => knobs.video.interior_room_gate = v != 0.0,
         "interiorshadows" => knobs.video.interior_shadows = v != 0.0,
+        // 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" => knobs.video.exterior_shadows = v != 0.0,
         // 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.
@@ -1197,11 +1287,21 @@ fn apply_to_knobs(name: &str, value: &str, knobs: &mut Knobs) -> bool {
             knobs.video.interior_shadow_casters = (v.max(1.0) as u32).clamp(1, 16);
         }
         // MONKEY (static torch cache): zero is useful for static-only rooms.
-        "interiorshadowdynamic" => knobs.video.interior_shadow_dynamic = (v.max(0.0) as u32).min(16),
+        "interiorshadowdynamic" => knobs.video.interior_shadow_dynamic = (v.max(1.0) as u32).clamp(1, crate::torch_shadow::MAX_TORCH_DYNAMIC as u32), // MONKEY (live bank rank): 1..8.
+        // 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" => {
+            knobs.video.interior_shadow_entity_rate = (v.max(0.0) as u32).min(240);
+        }
         "interiorshadowsoft" => knobs.video.interior_shadow_soft = v.clamp(0.5, 3.0),
-        "interiordebug" => knobs.video.interior_debug = (v.max(0.0) as u32).min(3),
+        "interiordebug" => knobs.video.interior_debug = (v.max(0.0) as u32).min(4),
         // MONKEY (fire GO lights): the synthesised-fire gain, clamped at the edge like the rest.
         "firelightgain" => knobs.video.fire_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" => knobs.video.fire_flicker = v.clamp(0.0, 2.0),
         // Display mode (1627) — a flag like every other checkbox here, and the reference's own
         // polarity: `1` is WINDOWED (the row is "Windowed Mode"). `video::apply_window_mode`
         // watches the value and pushes it to the window; nothing else reads it.
@@ -1504,7 +1604,7 @@ fn sync_cvars(
                 .collect(),
         );
         let flag = |b: bool| if b { "1" } else { "0" }.to_string();
-        let session: [(&str, String); 59] = [
+        let session: [(&str, String); 67] = [
             ("MasterVolume", sound.master.to_string()),
             ("SoundVolume", sound.sfx.to_string()),
             ("MusicVolume", sound.music.to_string()),
@@ -1553,6 +1653,11 @@ fn sync_cvars(
             ("worldShadows", flag(video.world_shadows)),
             ("characterShadows", flag(video.character_shadows)),
             ("shadowDistance", video.shadow_distance.to_string()),
+            ("shadowMapSize", video.shadow_map_size.to_string()),
+            ("shadowFilter", video.shadow_filter.to_string()),
+            ("characterShadowRate", video.character_shadow_rate.to_string()),
+            ("worldShadowRate", video.world_shadow_rate.to_string()),
+            ("shadowCasterReach", video.shadow_caster_reach.to_string()),
             ("interiorLight", flag(video.interior_light)),
             ("interiorAmbient", video.interior_ambient.to_string()),
             ("interiorFill", video.interior_fill.to_string()),
@@ -1560,14 +1665,20 @@ fn sync_cvars(
             ("interiorAttenScale", video.interior_atten_scale.to_string()),
             ("interiorRoomGate", flag(video.interior_room_gate)),
             ("interiorShadows", flag(video.interior_shadows)),
+            ("exteriorShadows", flag(video.exterior_shadows)),
             (
                 "interiorShadowCasters",
                 video.interior_shadow_casters.to_string(),
             ),
             ("interiorShadowDynamic", video.interior_shadow_dynamic.to_string()),
+            (
+                "interiorShadowEntityRate",
+                video.interior_shadow_entity_rate.to_string(),
+            ),
             ("interiorShadowSoft", video.interior_shadow_soft.to_string()),
             ("interiorDebug", video.interior_debug.to_string()),
             ("fireLightGain", video.fire_light_gain.to_string()),
+            ("fireFlicker", video.fire_flicker.to_string()),
             // The reference's polarity: the CVar is `gxWindow`, so `1` is the WINDOWED state.
             (
                 "gxWindow",
@@ -1985,6 +2096,15 @@ mod tests {
             d["characterShadows"] != 0.0,
             VideoConfig::default().character_shadows
         );
+        // MONKEY (sun shadow perf): the five cost dials weld to the video knob's shipped defaults
+        // exactly like the two flags above — a registered row that drifts from what the rig
+        // actually runs is a setting that reads one way in the config and behaves another.
+        let shadows = VideoConfig::default();
+        assert_eq!(d["shadowMapSize"], shadows.shadow_map_size as f32);
+        assert_eq!(d["shadowFilter"], shadows.shadow_filter as f32);
+        assert_eq!(d["characterShadowRate"], shadows.character_shadow_rate as f32);
+        assert_eq!(d["worldShadowRate"], shadows.world_shadow_rate as f32);
+        assert_eq!(d["shadowCasterReach"], shadows.shadow_caster_reach);
         // 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/dynamic_interior.rs b/crates/benilla-app/src/dynamic_interior.rs
index d4ad633c..cd3565d7 100644
--- a/crates/benilla-app/src/dynamic_interior.rs
+++ b/crates/benilla-app/src/dynamic_interior.rs
@@ -53,6 +53,10 @@ fn bridge(
         // `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,
     };
     if *out != want {
         *out = want;
diff --git a/crates/benilla-app/src/entities.rs b/crates/benilla-app/src/entities.rs
index 833a0bd9..3b1bb462 100644
--- a/crates/benilla-app/src/entities.rs
+++ b/crates/benilla-app/src/entities.rs
@@ -50,6 +50,9 @@ use carried_light::spawn_carried_lights;
 // 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
diff --git a/crates/benilla-app/src/entities/attach/mod.rs b/crates/benilla-app/src/entities/attach/mod.rs
index afdbd801..46a07354 100644
--- a/crates/benilla-app/src/entities/attach/mod.rs
+++ b/crates/benilla-app/src/entities/attach/mod.rs
@@ -924,7 +924,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 401041a6..02434592 100644
--- a/crates/benilla-app/src/entities/carried_light.rs
+++ b/crates/benilla-app/src/entities/carried_light.rs
@@ -44,10 +44,32 @@ use benilla_world::wmo_portal::{WmoGroupVis, WmoPortalInstance, WmoRoom};
 ///
 /// 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 {
@@ -100,6 +122,30 @@ pub(super) fn spawn_carried_lights(
         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 (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);
     }
@@ -593,6 +639,7 @@ mod tests {
             },
             bone_pivot: [1.0, 0.0, 0.5],
             synthetic: false,
+            flame: false,
         }
     }
 
@@ -615,7 +662,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)
             });
         });
@@ -656,6 +703,33 @@ mod tests {
         );
     }
 
+    /// 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::<(&PointLight, 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
@@ -669,10 +743,11 @@ mod tests {
         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, move |bone| {
+            spawn_carried_lights(&mut q, &lights, frame, true, move |bone| {
                 (bone == 3).then_some(joint)
             });
         });
diff --git a/crates/benilla-app/src/entities/equipment/spawn.rs b/crates/benilla-app/src/entities/equipment/spawn.rs
index d09393e9..dabef77e 100644
--- a/crates/benilla-app/src/entities/equipment/spawn.rs
+++ b/crates/benilla-app/src/entities/equipment/spawn.rs
@@ -744,7 +744,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/wmo_props.rs b/crates/benilla-app/src/entities/wmo_props.rs
index 7c68b355..3970e147 100644
--- a/crates/benilla-app/src/entities/wmo_props.rs
+++ b/crates/benilla-app/src/entities/wmo_props.rs
@@ -423,11 +423,10 @@ pub(super) fn spawn_wmo_gameobject_props(
                     if !l.def.casts() {
                         continue; // directional lights feed an ambient term; a static `0` visibility key is dark
                     }
+                    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(
-                            prop.local.transform_point(wow_to_bevy(l.def.position)),
-                        ),
+                        Transform::from_translation(local),
                         Visibility::default(),
                     ));
                     // MONKEY (fire GO lights): a transport prop takes SYNTHESISED lights like the
@@ -436,6 +435,19 @@ pub(super) fn spawn_wmo_gameobject_props(
                     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/portrait/glue_booth.rs b/crates/benilla-app/src/portrait/glue_booth.rs
index ab61a9db..c1f4571f 100644
--- a/crates/benilla-app/src/portrait/glue_booth.rs
+++ b/crates/benilla-app/src/portrait/glue_booth.rs
@@ -2036,6 +2036,7 @@ mod tests {
             },
             bone_pivot: [0.0; 3],
             synthetic: false,
+            flame: false,
         }
     }
 
diff --git a/crates/benilla-app/src/shadow_core.rs b/crates/benilla-app/src/shadow_core.rs
index ec677271..9028d4df 100644
--- a/crates/benilla-app/src/shadow_core.rs
+++ b/crates/benilla-app/src/shadow_core.rs
@@ -29,6 +29,7 @@ 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};
@@ -44,7 +45,7 @@ use benilla_assets::materials::WowModelMaterial;
 use benilla_formats::ModelBlend;
 use benilla_world::billboard::BillboardCard;
 use benilla_world::interact::PickMesh;
-use benilla_world::lighting::{ShadowDistance, WowLighting};
+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;
@@ -62,14 +63,114 @@ pub(crate) const PLAYER_SHADOW_LAYER: usize = 31;
 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 fixed 4096 shadow map spreads thinner (softer) over a larger area and the caster-collection
-/// cost grows with distance.
+/// 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;
@@ -200,6 +301,10 @@ struct ShadowRigState {
     /// `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;
@@ -230,14 +335,96 @@ impl Material for ShadowCasterMaterial {
 
 impl Plugin for ShadowCorePlugin {
     fn build(&self, app: &mut App) {
-        app.insert_resource(DirectionalLightShadowMap { size: 4096 }) // MONKEY: crisper shadow edges
+        // 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())
-            .add_systems(Last, manage_rig.in_set(ShadowSet::Rig));
+            // 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);
+        }
     }
 }
 
@@ -373,8 +560,15 @@ fn manage_rig(
 
     // MONKEY (moving sun): aim at the VISIBLE celestial sun (rises/sets), clamped in elevation.
     let sun_direction = shadow_sun_travel(lighting.celestial_dir());
-    let entity_reach = distance + STATIC_REBUILD_STEP;
-    let tall_reach = static_collection_reach(sun_direction, distance);
+    // 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).
@@ -605,10 +799,11 @@ fn append_skinned(
 #[cfg(test)]
 mod tests {
     use super::{
-        append_triangles, casts_realtime_shadow, shadow_reach_extension, shadow_sun_travel,
-        static_collection_reach, sun_snap_due, DEFAULT_SHADOW_DISTANCE, MAX_CASTER_HEIGHT,
-        MAX_SHADOW_SUN_ELEVATION, MIN_SHADOW_SUN_ELEVATION, SHADOW_REACH_CAP, STATIC_REBUILD_STEP,
-        SUN_SNAP_RADIANS,
+        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;
@@ -685,4 +880,54 @@ mod tests {
         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
index 5abb7dce..f053866c 100644
--- a/crates/benilla-app/src/torch_shadow.rs
+++ b/crates/benilla-app/src/torch_shadow.rs
@@ -30,7 +30,19 @@
 //! 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, measured from the player) overlay creatures/animated parts.
+//! 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};
 
@@ -47,10 +59,11 @@ use benilla_world::billboard::BillboardCard;
 use benilla_world::interact::PickMesh;
 use benilla_world::lighting::{
     interior_reach, m2_light_reach, DynamicInteriors, FireLightGain, LightLane, LightLitRooms,
-    LightReach, LightRooms, ShadowDistance, SyntheticFireLight,
+    LightReach, LightRooms, ShadowDistance, ShadowProxyLight, SyntheticFireLight, WowLighting,
 };
 // MONKEY (carried light stability): the settle verdict a carried light earns by standing still.
-use crate::entities::CarriedLightMotion;
+// 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::{StaticGx, TorchShadowViews};
@@ -68,6 +81,8 @@ use crate::video::VideoConfig;
 /// `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;
@@ -105,9 +120,28 @@ const CUBE_FACES: usize = 6;
 /// 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). Four slots, cursor-rotated, still notices any streaming change within
-/// three frames — under a tenth of a second, and the map it then rebuilds is the same one.
-const TORCH_SCAN_PER_FRAME: usize = 4;
+/// 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
@@ -117,6 +151,23 @@ const TORCH_SCAN_PER_FRAME: usize = 4;
 /// 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 (outdoor torch shadows): EMITTER-OWNER EXCLUSION radius for an exterior slot (yd) — any
+/// retained item whose whole bounding sphere sits inside this of the flame is the fire's OWN body
+/// and is dropped from its caster gather (`StaticGx::append_torch_triangles`). Indoors this is 0
+/// (the interior gather is untouched): an authored MOLT fixture stands clear of its bracket, so
+/// nothing was ever wrong there. Outdoors the light sits INSIDE the campfire prop's opaque logs, and
+/// left in they are the nearest occluder on all six faces — the fire blacks out its own pool.
+/// 2.5 yd covers a campfire/brazier prop whole; a crate or fence post two yards away has its centre
+/// inside that but not its sphere, so it still casts (containment, not centre distance — see
+/// `torch_item_is_emitter`).
+const TORCH_EXT_SELF_EXCLUDE: f32 = 2.5;
 /// 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;
@@ -154,6 +205,24 @@ struct TorchSlot {
     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,
     /// The cross-fade weight, published as `positions[i].w` and applied as `mix(1, shadow, w)` by
     /// both receivers.
     w: f32,
@@ -177,6 +246,38 @@ struct TorchLane {
     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`
@@ -186,6 +287,11 @@ struct TorchLane {
 /// 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)`. 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.
+type Candidate = (Entity, Vec3, f32, bool, f32);
+
 /// 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.
@@ -212,6 +318,82 @@ fn candidate_score(
     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.
@@ -237,7 +419,37 @@ 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)));
-    nearest.iter().take(budget.min(MAX_TORCH_CASTERS)).fold(0, |mask, (i, _)| mask | (1 << i))
+    // 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: &[(usize, Vec3, f32)], origin: Vec3) -> bool {
+    fixtures.iter().any(|(_, p, r)| p.distance_squared(origin) <= r * r)
+}
+
+/// 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`.
@@ -264,13 +476,33 @@ struct EntityCasters<'w, 's> {
     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 lane is active when the dynamic-interior lane is on AND its shadow toggle is on.
+/// 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 {
@@ -331,11 +563,19 @@ fn update_torch_shadows(
     // 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.
     torches: Query<
         (Entity, &GlobalTransform, &PointLight, Option<&LightReach>, Option<&LightLane>,
-         Has<LightRooms>, Has<SyntheticFireLight>, Has<ChildOf>,
-         Option<&crate::entities::CarriedLightMotion>),
-        Or<(With<LightRooms>, With<LightLitRooms>)>,
+         Has<LightRooms>, Has<LightLitRooms>, Has<SyntheticFireLight>, Has<ChildOf>,
+         Has<HeldLight>, Option<&crate::entities::CarriedLightMotion>),
+        Without<ShadowProxyLight>,
     >,
     // 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
@@ -349,7 +589,12 @@ fn update_torch_shadows(
     mut last_trace: Local<f64>,
 ) {
     // Declare demand so the shared rig stays up while on.
-    let on = interior_shadows_on(&video) && *state.get() == ClientState::InWorld;
+    // 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) {
@@ -389,9 +634,11 @@ fn update_torch_shadows(
 
     // (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.
-    let mut cands: Vec<(Entity, Vec3, f32)> = torches
+    // 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, synthetic, carried, motion)| {
+        .filter_map(|(e, gt, pl, reach, light_lane, has_rooms, has_lit, synthetic, carried,
+                      held, motion)| {
             // MONKEY (carried light stability): a CARRIED light (`ChildOf` — a pet's hand flame,
             // an NPC's torch, a transport's deck brazier) casts only while it is STANDING STILL.
             //
@@ -426,28 +673,68 @@ fn update_torch_shadows(
                 .filter(|r| *r > 0.5)
                 .unwrap_or_else(|| m2_light_reach(base));
             let r = interior_reach(authored, interiors.atten_scale);
-            if !fixture_eligible(d, p.distance(cam), r, ents.distance.0) {
-                return None;
-            }
+            // 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.to_linear();
             // 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.red + 0.7152 * c.green + 0.0722 * c.blue).max(0.0) * base.max(0.0);
-            let score = candidate_score(lum, d, r, light_lane, has_rooms, synthetic, fire_gain.0);
-            (score > 0.0).then_some((e, p, score))
+            // 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));
+            }
+            // 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))
         })
         .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)) => {
+        match cands.iter().find(|(e, ..)| *e == slot.fixture) {
+            Some((_, p, sc, _, r)) => {
                 slot.pos = *p;
                 slot.score = *sc;
+                slot.reach = *r;
             }
             None => {
                 slot.score = 0.0;
@@ -482,9 +769,9 @@ fn update_torch_shadows(
     // 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)) = cands
+        let Some(&(e, p, sc, exterior, reach)) = cands
             .iter()
-            .find(|(e, _, _)| !lane.slots.iter().any(|s| s.fixture == *e))
+            .find(|(e, ..)| !lane.slots.iter().any(|s| s.fixture == *e))
         else {
             break;
         };
@@ -499,6 +786,9 @@ fn update_torch_shadows(
             fixture: e,
             pos: p,
             score: sc,
+            reach,
+            checked: None,
+            exterior,
             w: 0.0,
             evicting: false,
         });
@@ -518,8 +808,8 @@ fn update_torch_shadows(
             .map(|(i, s)| (i, s.score));
         let challenger = cands
             .iter()
-            .find(|(e, _, _)| !lane.slots.iter().any(|s| s.fixture == *e))
-            .map(|(_, _, sc)| *sc);
+            .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;
@@ -530,25 +820,36 @@ fn update_torch_shadows(
 
     // The published set, in slot order: fixture, position, score (trace only) and fade weight,
     // capped at the table's allocation.
-    let promoted: Vec<(usize, Entity, Vec3, f32, f32)> = lane
+    // 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))
+        .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();
+    let fixture_positions: Vec<_> = promoted.iter().map(|(i, _, p, ..)| (*i, *p)).collect();
     let dynamic = dynamic_set(&fixture_positions, anchor, video.interior_shadow_dynamic as usize);
     let mut 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,
         dynamic_mask: dynamic,
+        // 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
@@ -558,16 +859,51 @@ fn update_torch_shadows(
     // 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();
-    let start = lane.rebuild_cursor;
+    // 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);
     for offset in 0..scan {
         let index = (start + offset) % slot_count;
         let slot = &mut lane.slots[index];
         let i = slot.cache_slot;
+        // 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);
-        gx.as_ref().map(|gx| gx.torch_geometry_key(slot.pos, TORCH_RANGE)).hash(&mut hash);
+        // MONKEY (outdoor torch shadows): the exclusion radius is part of the ADMISSION, so it
+        // must be part of the FINGERPRINT — a key computed over a different source set than the
+        // mesh would certify the wrong geometry as current.
+        let self_exclude = if slot.exterior { TORCH_EXT_SELF_EXCLUDE } else { 0.0 };
+        gx.as_ref()
+            .map(|gx| gx.torch_geometry_key(slot.pos, TORCH_RANGE, self_exclude))
+            .hash(&mut hash);
         let mut entity_key = 0u64;
         for (entity, pick, part, global, rig, occluder, _) in &ents.parts {
             if !static_part(part, rig.is_some()) || !occluder.0 { continue; }
@@ -583,18 +919,24 @@ fn update_torch_shadows(
         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));
+        }
         if dirty && rebuilt < 2 {
             let mut positions = Vec::new();
             let mut indices = Vec::new();
             if let Some(gx) = &gx {
-                gx.append_torch_triangles(slot.pos, TORCH_RANGE, &mut positions, &mut indices);
+                gx.append_torch_triangles(
+                    slot.pos, TORCH_RANGE, self_exclude, &mut positions, &mut indices);
             }
-            collect_torch_entities(&ents, true, &[(i, slot.pos)], &mut positions, &mut indices);
+            collect_torch_entities(
+                &ents, true, &[(i, slot.pos, TORCH_RANGE)], &mut positions, &mut indices);
             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));
             rebuilt += 1;
             static_rebuilt |= 1 << i;
         }
@@ -636,18 +978,51 @@ fn update_torch_shadows(
     }
     // 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.
-    let dynamic_positions: Vec<_> = fixture_positions.iter().copied()
-        .filter(|(i, _)| dynamic & (1 << i) != 0).collect();
-    let mut ent_admitted = 0;
+    //
+    // 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<(usize, Vec3, f32)> = 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)))
+        .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 {
-        if lane.entity_mesh.is_none() { lane.entity_mesh = Some(meshes.add(empty_shadow_mesh())); }
-        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);
-            ent_admitted = collect_torch_entities(&ents, false, &dynamic_positions, &mut positions, &mut indices);
-            restore_mesh_buffers(mesh, positions, indices);
+        let fresh = lane.entity_mesh.is_none();
+        if fresh { lane.entity_mesh = Some(meshes.add(empty_shadow_mesh())); }
+        let due = fresh
+            || 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
@@ -655,28 +1030,54 @@ fn update_torch_shadows(
     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 {} ({} candidates, caster {}, {} entity casters)",
+                "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"
                 },
-                ent_admitted,
+                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) in &promoted {
+            for (i, e, p, sc, w, ext) in &promoted {
                 info!(
-                    "  slot {i}: {e} at [{:.1},{:.1},{:.1}] d(player) {:.1} score {:.4e} w {:.2} (camera <= shadowDistance AND player <= 4R+3) static {} dynamic {}",
+                    "  slot {i}: lane {} {e} at [{:.1},{:.1},{:.1}] d(player) {:.1} score {:.4e} w {:.2} (camera <= shadowDistance AND player <= 4R+3) static {} dynamic {} requested_live_rank {:?}",
+                    if *ext { "EXT" } else { "INT" },
                     p.x,
                     p.y,
                     p.z,
@@ -685,6 +1086,7 @@ fn update_torch_shadows(
                     w,
                     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)),
                 );
             }
         }
@@ -697,8 +1099,12 @@ 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)` — each fixture carries the
+/// radius it admits casters inside, instead of the whole gather sharing [`TORCH_RANGE`]. The static
+/// (cached) caller passes `TORCH_RANGE` and is therefore byte-for-byte the gather it always was;
+/// only the per-frame MOVING gather narrows, to `entity_gather_radius(reach)`.
 fn collect_torch_entities(
-    ents: &EntityCasters, want_static: bool, fixtures: &[(usize, Vec3)],
+    ents: &EntityCasters, want_static: bool, fixtures: &[(usize, Vec3, f32)],
     positions: &mut Vec<[f32; 3]>, indices: &mut Vec<u32>,
 ) -> u32 {
     let mut admitted = 0;
@@ -711,7 +1117,7 @@ fn collect_torch_entities(
         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 !fixtures.iter().any(|(_, p)| p.distance_squared(origin) <= TORCH_RANGE * TORCH_RANGE) { continue; }
+        if !within_any_reach(fixtures, origin) { 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 };
@@ -746,6 +1152,34 @@ fn collect_torch_entities(
     admitted
 }
 
+/// 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 {
@@ -755,6 +1189,11 @@ fn teardown(lane: &mut TorchLane, meshes: &mut Assets<Mesh>, views: &mut TorchSh
     // 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();
 }
 
@@ -796,14 +1235,17 @@ mod tests {
         assert!(!fixture_eligible(1.0, f32::NAN, 48.0, 80.0));
     }
 
-    // MONKEY (static torch cache): sparse physical slots, tie stability and live shrink/off.
+    // 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), 0);
+        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
@@ -818,6 +1260,138 @@ mod tests {
         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)
+            })
+            .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)];
+        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), (1usize, Vec3::X * 60.0, hearth)];
+        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.
+    #[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;
diff --git a/crates/benilla-app/src/video.rs b/crates/benilla-app/src/video.rs
index ccb1e050..888bf7d6 100644
--- a/crates/benilla-app/src/video.rs
+++ b/crates/benilla-app/src/video.rs
@@ -226,6 +226,46 @@ pub(crate) struct VideoConfig {
     /// 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`
@@ -247,12 +287,34 @@ pub(crate) struct VideoConfig {
     /// 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). A candle cluster casts many hard-edged
     /// overlapping shadows; widening the 4-tap kernel is the cheap softening. Rides the torch
@@ -267,7 +329,7 @@ pub(crate) struct VideoConfig {
     /// 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..3). See
+    /// MONKEY (interior debug): the interior-lane diagnostic overlay (`interiorDebug`, 0..4). See
     /// [`benilla_world::lighting::DynamicInteriors::debug`].
     pub(crate) interior_debug: u32,
     /// MONKEY (fire GO lights): gain on every light SYNTHESISED from a fire prop's flame emitter
@@ -275,6 +337,12 @@ pub(crate) struct VideoConfig {
     /// [`benilla_world::lighting::FireLightGain`] by `dynamic_interior`, and applied at PACK time
     /// so it is live.
     pub(crate) fire_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,
@@ -287,6 +355,12 @@ impl Default for VideoConfig {
             world_shadows: false,
             character_shadows: false,
             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.15,
@@ -295,15 +369,21 @@ impl Default for VideoConfig {
             // 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,
             interior_shadow_soft: 1.0,
             // MONKEY (room gate): on — without it a building's fixtures light through its own
             // floors and walls.
             interior_room_gate: true,
             interior_debug: 0,
             fire_light_gain: 1.0,
+            fire_flicker: 1.0,
             display: if windowed_env() {
                 DisplayMode::Windowed
             } else {
diff --git a/crates/benilla-app/src/world_shadow.rs b/crates/benilla-app/src/world_shadow.rs
index 8d963951..c3bd7662 100644
--- a/crates/benilla-app/src/world_shadow.rs
+++ b/crates/benilla-app/src/world_shadow.rs
@@ -38,8 +38,8 @@ 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, ShadowCaster, ShadowDemand, ShadowFrame,
-    ShadowSet, PLAYER_SHADOW_LAYER, STATIC_REBUILD_STEP,
+    shadow_trace, spawn_solid_caster, take_mesh_buffers, RebuildRate, ShadowCaster, ShadowDemand,
+    ShadowFrame, ShadowSet, PLAYER_SHADOW_LAYER, STATIC_REBUILD_STEP,
 };
 use crate::video::VideoConfig;
 
@@ -117,11 +117,15 @@ struct WorldLane {
     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>,
@@ -169,8 +173,20 @@ fn update_world_shadows(
         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();
     }
-    if let Some(handle) = lane.env_mesh.clone() {
+    // 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(
@@ -323,4 +339,6 @@ fn teardown(
     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/m2.rs b/crates/benilla-assets/src/m2.rs
index 5f05806d..a79fd563 100644
--- a/crates/benilla-assets/src/m2.rs
+++ b/crates/benilla-assets/src/m2.rs
@@ -301,6 +301,18 @@ pub struct ModelLight {
     /// 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,
 }
 
 /// Bevy [`AssetLoader`] decoding `*.m2` → [`M2Model`].
@@ -489,6 +501,7 @@ impl AssetLoader for M2ModelLoader {
                     .map_or([0.0; 3], |b| b.pivot),
                 def,
                 synthetic: false,
+                flame: false,
             })
             .collect();
         // MONKEY (fire GO lights) / MONKEY (lamp lights): a prop that authors NO casting light gets
@@ -508,14 +521,16 @@ impl AssetLoader for M2ModelLoader {
             // 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.
+            // 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`]).
             let synth = 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)
+                (src.position, src.bone, fire.color, fire.intensity, true)
             })
             .or_else(|| {
                 // MONKEY (lamp lights): a lamppost/lantern/chandelier authors NO particle emitter
@@ -530,9 +545,9 @@ impl AssetLoader for M2ModelLoader {
                     .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))
+                    .map(|l| (l.position, l.bone, l.color, l.intensity, false))
             });
-            if let Some((position, src_bone, color, intensity)) = synth {
+            if let Some((position, src_bone, color, intensity, flame)) = 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
@@ -566,6 +581,7 @@ impl AssetLoader for M2ModelLoader {
                         .get(src_bone as usize)
                         .map_or([0.0; 3], |b| b.pivot),
                     synthetic: true,
+                    flame,
                 });
             }
         }
diff --git a/crates/benilla-assets/src/shaders/shadow_hook.wgsl b/crates/benilla-assets/src/shaders/shadow_hook.wgsl
index ac004e86..49a8084a 100644
--- a/crates/benilla-assets/src/shaders/shadow_hook.wgsl
+++ b/crates/benilla-assets/src/shaders/shadow_hook.wgsl
@@ -92,6 +92,20 @@ fn torch_caster_count() -> u32 {
 //                  many overlapping penumbra-less edges, and widening the kernel is the cheapest
 //                  softening available here (a real penumbra would need the blocker distance and a
 //                  variable kernel — not worth a second sampling pass on a 512² face).
+//   - `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 4-tap PCF factor otherwise (0 = shadowed).
 fn torch_map_shadow(
     view_proj: mat4x4<f32>,
@@ -101,6 +115,7 @@ fn torch_map_shadow(
     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) {
@@ -126,8 +141,11 @@ fn torch_map_shadow(
     // 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.
-    let far_fade = smoothstep(0.0, 0.06, ndc.z);
-    return mix(1.0, sum * 0.25, far_fade);
+    // 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, sum * 0.25, select(fade, ndc_fade, fade < 0.0));
 }
 
 // MONKEY (interior debug): the interior lane's diagnostic overlay. `mode` is decoded from the
diff --git a/crates/benilla-assets/src/shaders/wow_model.wgsl b/crates/benilla-assets/src/shaders/wow_model.wgsl
index 5913db49..3f0bb7ab 100644
--- a/crates/benilla-assets/src/shaders/wow_model.wgsl
+++ b/crates/benilla-assets/src/shaders/wow_model.wgsl
@@ -220,6 +220,7 @@ 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>,
@@ -242,6 +243,27 @@ const TORCH_NORMAL_OFFSET: f32 = 0.15;
 fn torch_soft() -> f32 {
     return max(f32(torch_table.count.y) * 0.01, 0.05);
 }
+// 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
@@ -262,7 +284,16 @@ fn torch_face(d: vec3<f32>) -> u32 {
 // 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.
-fn torch_entity_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32 {
+//
+// 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) {
@@ -270,10 +301,22 @@ fn torch_entity_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32
         if (torch_table.positions[i].w <= 0.0) { continue; }
         let fixture = torch_table.positions[i].xyz;
         if (distance(fixture, light_pos) < 1.0) {
-            let layer = i * 6u + torch_face(Ps - fixture);
+            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,
+            );
             let s = shadow_hook::torch_map_shadow(
-                torch_table.view_projs[layer], i32(layer + select(0u, 96u, (torch_table.count.z & (1u << i)) != 0u)), Ps, torch_depth, torch_samp, TORCH_BIAS,
-                torch_soft());
+                torch_table.view_projs[layer], i32(depth_layer), Ps, 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
@@ -284,6 +327,17 @@ fn torch_entity_shadow(light_pos: vec3<f32>, P: vec3<f32>, N: vec3<f32>) -> f32
     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;
@@ -293,10 +347,14 @@ fn torch_entity_debug_factor(P: vec3<f32>, N: vec3<f32>) -> f32 {
     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 layer = i * 6u + torch_face(Ps - torch_table.positions[i].xyz);
+        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);
         let raw = shadow_hook::torch_map_shadow(
-            torch_table.view_projs[layer], i32(layer + select(0u, 96u, (torch_table.count.z & (1u << i)) != 0u)), Ps, torch_depth, torch_samp, TORCH_BIAS,
-            torch_soft());
+            torch_table.view_projs[layer], i32(depth_layer), Ps, 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));
     }
@@ -341,6 +399,12 @@ struct WowVsOut {
 #ifdef WOW_MERGED_SLOT
     @location(10) @interpolate(flat) merged_slot: u32,
 #endif
+    // MONKEY (outdoor torch shadows): WHICH <=3 exterior table entries `point_lit` was summed from,
+    // packed 10 bits each (see `EXT_SEL_NONE`). FLAT, because it is a choice and not a quantity -
+    // interpolating three packed indices would produce a fourth, 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.
+    @location(11) @interpolate(flat) ext_sel: u32,
 }
 
 // The dynamic point-light term at a world-space point (decisions 0016/0273/0278, selection 0285) —
@@ -380,7 +444,17 @@ 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 ≤3-nearest
+// EXTERIOR selection packed into ONE u32, three 10-bit indices (rank 0 in the low bits) with
+// `EXT_SEL_EMPTY` for an unfilled rank. The point table is capped at 256 entries, so 10 bits leaves
+// two bits of headroom. 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.
+const EXT_SEL_EMPTY: u32 = 1023u;
+const EXT_SEL_NONE: u32 = 1073741823u; // three empty ranks: 1023 | 1023<<10 | 1023<<20
+
+// The ranking half of `point_light_sum`, split out verbatim (same tests, same order, same ties).
+fn point_light_pick(anchor: vec3<f32>) -> 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);
@@ -409,21 +483,63 @@ fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
             sd[2] = d2; sel[2] = i;
         }
     }
+    return select(EXT_SEL_EMPTY, sel[0], sd[0] <= 9.9e29)
+        | (select(EXT_SEL_EMPTY, sel[1], sd[1] <= 9.9e29) << 10u)
+        | (select(EXT_SEL_EMPTY, sel[2], sd[2] <= 9.9e29) << 20u);
+}
+
+// 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).
+fn point_light_eval(sel: 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) {
+        let idx = (sel >> (10u * s)) & 1023u;
+        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 three entries, 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. Bounded at three iterations, and reached only under `torch_ext_on()`, so nothing here
+// runs in daylight or with `exteriorShadows 0`.
+fn point_light_eval_shadowed(sel: u32, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+    for (var s = 0u; s < 3u; s = s + 1u) {
+        let idx = (sel >> (10u * s)) & 1023u;
+        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 s = 1.0;
+        if (ext_w > TORCH_SKIP_EPS) {
+            s = torch_entity_exterior_shadow(fixture, P, N);
+        }
+        sum += wow_light.points[2u * idx + 1u].rgb * (ext_w * s);
+    }
+    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), 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
@@ -568,8 +684,17 @@ fn interior_room_light(P: vec3<f32>, N: vec3<f32>, room_inst: u32, room_group: u
         // `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.
-        let s = torch_entity_shadow(pos_range.xyz, P, N);
-        direct += c_norm * (atten * nl * window) * s;
+        // 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
@@ -609,7 +734,9 @@ fn mcnk_cell_anchor(P: vec3<f32>) -> vec3<f32> {
 // 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;
-fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+// 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>) -> u32 {
     let anchor = mcnk_cell_anchor(P);
     let count = u32(wow_light.point_count.x);
     var sel = array<u32, 3>(0u, 0u, 0u);
@@ -638,18 +765,12 @@ fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
             sd[2] = d2; sel[2] = i;
         }
     }
-    var sum = vec3<f32>(0.0);
-    for (var s = 0u; s < 3u; s = s + 1u) {
-        if (sd[s] > 9.9e29) {
-            break;
-        }
-        let to_light = wow_light.points[2u * sel[s]].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);
-    }
-    return sum;
+    return select(EXT_SEL_EMPTY, sel[0], sd[0] <= 9.9e29)
+        | (select(EXT_SEL_EMPTY, sel[1], sd[1] <= 9.9e29) << 10u)
+        | (select(EXT_SEL_EMPTY, sel[2], sd[2] <= 9.9e29) << 20u);
+}
+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
@@ -922,15 +1043,23 @@ fn vertex(vertex: WowVertex) -> WowVsOut {
         // 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.
-        out.point_lit = wmo_exterior_point_sum(out.world_position.xyz, out.world_normal);
+        // MONKEY (outdoor torch shadows): the pick is PUBLISHED so the fragment stage can shadow
+        // these same three entries 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;
         if (m.clutter_fade.w > 0.5) {
             anchor = mcnk_cell_anchor(out.world_position.xyz);
         }
-        out.point_lit = point_light_sum(out.world_position.xyz, out.world_normal, anchor);
+        let sel = point_light_pick(anchor);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, out.world_position.xyz, out.world_normal);
     }
     return out;
 }
@@ -1399,7 +1528,30 @@ fn fragment(in: WowVsOut, @builtin(front_facing) is_front: bool) -> WowFragOut {
     // 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 three 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
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 6f5fd156..e17b81d2 100644
--- a/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs
+++ b/crates/benilla-formats/src/bin/benilla-extract/scan/lighting.rs
@@ -565,6 +565,39 @@ impl RootRooms {
     }
 }
 
+/// 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()
+}
+
 fn root_rooms(
     chain: &mut Chain,
     root: &benilla_formats::WmoRoot,
@@ -675,13 +708,23 @@ pub fn wmolights(chain: &mut Chain, raw_path: &str) -> Result<()> {
     // (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.
-    println!("=== groups (class, MOGP flags, MOGI box, portals, MOLR fixtures) ===");
+    // 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} {}  flags {:#010x}  box ({:>8.2},{:>8.2},{:>7.2})..({:>8.2},{:>8.2},{:>7.2})  portals {pc:<3} molr {:?}",
-            if g.interior { "INT" } else { "ext" },
+            "  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],
@@ -689,6 +732,30 @@ pub fn wmolights(chain: &mut Chain, raw_path: &str) -> Result<()> {
         );
     }
     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();
+        println!(
+            "  p{pi:<3} area {area:>7.2} yd^2  |n.z| {:.2}  joins {joins:?}{}",
+            plane[2].abs(),
+            if area >= benilla_formats::room_claim::SPLIT_PORTAL_MIN_AREA { "   SPLIT" } else { "" },
+        );
+    }
+    println!();
     for (i, l) in lights.iter().enumerate() {
         let prod = [
             l.color[0] * l.intensity,
diff --git a/crates/benilla-formats/src/room_claim.rs b/crates/benilla-formats/src/room_claim.rs
index 31c78b2e..89bb3c9d 100644
--- a/crates/benilla-formats/src/room_claim.rs
+++ b/crates/benilla-formats/src/room_claim.rs
@@ -14,6 +14,10 @@
 //! 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
@@ -65,6 +69,11 @@ pub enum ClaimHow {
     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 {
@@ -73,6 +82,7 @@ impl ClaimHow {
             ClaimHow::Contains => "in",
             ClaimHow::Molr => "molr",
             ClaimHow::Portal => "portal",
+            ClaimHow::Split => "split",
         }
     }
 }
@@ -188,6 +198,29 @@ fn portal_box(portals: &PortalGraph, portal: u16) -> Option<([f32; 3], [f32; 3])
     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
@@ -242,6 +275,34 @@ pub const CLAIM_FADE_MIN_YD: f32 = 2.0;
 /// 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.)
@@ -271,11 +332,23 @@ 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`]).
-fn claimable_by_box(g: &WmoGroupInfo) -> bool {
+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)
+}
+
 /// `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])
@@ -351,6 +424,68 @@ pub fn room_claims(
     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.
     //
@@ -611,6 +746,64 @@ mod tests {
         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.
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 f93a6c40..3ad68e1c 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;
@@ -538,6 +540,26 @@ impl Default for ShadowDistance {
     }
 }
 
+/// 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)
+    }
+}
+
 /// Main-world resource holding the packed light for this frame; extracted into the render world where
 /// [`upload_light`] writes it. Rebuilt every frame by [`build_light_data`] (cheap — one std430 pack).
 #[derive(Resource, Clone, Copy, ExtractResource)]
@@ -568,6 +590,10 @@ pub(super) fn register(app: &mut App) {
         .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>()
@@ -683,9 +709,24 @@ pub struct DynamicInteriors {
     /// 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+). Packed with the on/off
-    /// flag into `wmo_fog_params.w` as `1 + debug` (so `>0.5` still means "on").
+    /// 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,
 }
 
 impl Default for DynamicInteriors {
@@ -701,6 +742,8 @@ impl Default for DynamicInteriors {
             // its own floors and walls.
             room_gate: true,
             debug: 0,
+            // MONKEY (flame flicker): on at the authored amplitudes.
+            flicker: 1.0,
         }
     }
 }
@@ -880,6 +923,10 @@ fn build_light_data(
             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>,
         ),
         Without<ShadowProxyLight>,
     >,
@@ -965,6 +1012,10 @@ 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);
+    // 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
@@ -978,7 +1029,7 @@ fn build_light_data(
     // 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(|(_, gt, 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
@@ -996,7 +1047,7 @@ fn build_light_data(
                 && gt.translation().distance_squared(cam_pos)
                     < INTERIOR_NEAR_ADMIT * INTERIOR_NEAR_ADMIT)
         })
-        .filter_map(|(pl, gt, rooms, synthetic, reach, lane_of, lit_rooms)| {
+        .filter_map(|(pl, gt, rooms, synthetic, reach, lane_of, lit_rooms, flicker)| {
             let p = gt.translation();
             let d2 = p.distance_squared(cam_pos);
             (d2 < POINT_PACK_RADIUS * POINT_PACK_RADIUS).then(|| {
@@ -1008,7 +1059,20 @@ fn build_light_data(
                 // 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.
                 let s = base * if synthetic { fire_gain.0.max(0.0) } else { 1.0 };
-                let rgb = commit_raw([c.red * s, c.green * s, c.blue * s]);
+                // 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.red * s, c.green * s, c.blue * 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
@@ -1103,16 +1167,29 @@ fn build_light_data(
             // 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 ({interior} INT / {} EXT, {synth} synthetic, gain {:.2}, atten x{:.2}), cam {cam_pos:.1?} — this chunk's candidates: {boxed} (was {sphere} at the 48 yd sphere), 3 slots",
+                "[points] {} packed ({interior} INT / {} EXT, {synth} synthetic, {flames} flickering, gain {:.2}, atten x{:.2}, flicker 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,
             );
             for (d2, p, _, rgb, synthetic, lane, claim, lit_n) in pts.iter().take(8) {
                 eprintln!(
@@ -1685,6 +1762,68 @@ mod tests {
         assert!((data.points[1][0] - 2.0).abs() < 1e-4, "authored unaffected");
     }
 
+    /// 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.
     ///
diff --git a/crates/benilla-world/src/lighting/mod.rs b/crates/benilla-world/src/lighting/mod.rs
index 41b81344..4ccf4b85 100644
--- a/crates/benilla-world/src/lighting/mod.rs
+++ b/crates/benilla-world/src/lighting/mod.rs
@@ -12,16 +12,21 @@ use benilla_formats::{LightCatalog, LiquidKind};
 
 mod blob; // the off-world light-blob builder (booth studio, body pane, glue scene)
 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;
+// 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, ShadowProxyLight, SyntheticFireLight, WorldShadowActive,
+    ShadowDistance, ShadowFilterGaussian, ShadowProxyLight, SyntheticFireLight,
+    WorldShadowActive,
 };
 pub use global_light::{
     room_claim_bytes, CLAIM_EXT_OK, LIT_ROOM_EXT_DENY, ROOM_CLAIM_MAX, ROOM_CLAIM_STRIDE,
diff --git a/crates/benilla-world/src/shaders/static_gx.wgsl b/crates/benilla-world/src/shaders/static_gx.wgsl
index 9fb81ed8..7c454f8f 100644
--- a/crates/benilla-world/src/shaders/static_gx.wgsl
+++ b/crates/benilla-world/src/shaders/static_gx.wgsl
@@ -138,6 +138,12 @@ const WORD_MATTE: u32 = 268435456u;    // 1 << 28 — exterior MODD prop: intens
 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
+
 // Vanilla cutout ref (224/255) — wow_model.wgsl's VANILLA_ALPHA_KEY.
 const VANILLA_ALPHA_KEY: f32 = 0.8784314;
 
@@ -149,6 +155,7 @@ 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>,
@@ -170,6 +177,38 @@ fn torch_soft() -> f32 {
 }
 #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
@@ -185,21 +224,47 @@ fn torch_face(d: vec3<f32>) -> u32 {
     return select(5u, 4u, d.z > 0.0);
 }
 
-// This interior fixture's OWN cast shadow: correlate the `wow_light` fixture at `light_pos` to a
+// 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).
-fn torch_surface_shadow(light_pos: vec3<f32>, P: vec3<f32>) -> f32 {
+//
+// 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).
+fn torch_map_at(light_pos: vec3<f32>, P: 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 layer = i * 6u + torch_face(P - fixture);
+            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(layer + select(0u, 96u, (torch_table.count.z & (1u << i)) != 0u)), P, torch_depth, torch_samp, TORCH_BIAS,
-                torch_soft());
+                torch_table.view_projs[layer], i32(depth_layer), P, 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
@@ -212,6 +277,17 @@ fn torch_surface_shadow(light_pos: vec3<f32>, P: vec3<f32>) -> f32 {
     return 1.0;
 }
 
+// The INTERIOR lane's call — unchanged behaviour (`fade_radius 0` ⇒ the reverse-Z `ndc.z` fade).
+fn torch_surface_shadow(light_pos: vec3<f32>, P: vec3<f32>) -> f32 {
+    return torch_map_at(light_pos, P, 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.
+fn torch_exterior_shadow(light_pos: vec3<f32>, P: vec3<f32>) -> f32 {
+    return torch_map_at(light_pos, P, 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;
@@ -221,10 +297,14 @@ fn torch_debug_factor(P: vec3<f32>) -> f32 {
     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 layer = i * 6u + torch_face(P - torch_table.positions[i].xyz);
+        let face = torch_face(P - 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);
         let raw = shadow_hook::torch_map_shadow(
-            torch_table.view_projs[layer], i32(layer + select(0u, 96u, (torch_table.count.z & (1u << i)) != 0u)), P, torch_depth, torch_samp, TORCH_BIAS,
-            torch_soft());
+            torch_table.view_projs[layer], i32(depth_layer), P, 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.
@@ -243,7 +323,24 @@ 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 ≤3-nearest EXTERIOR selection, packed into ONE u32 as three
+// 10-bit indices (rank 0 in the low bits), `EXT_SEL_EMPTY` for an unfilled rank. The packed light
+// table is capped at 256 entries, so 10 bits carries two bits of headroom.
+//
+// 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 three 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).
+const EXT_SEL_EMPTY: u32 = 1023u;
+const EXT_SEL_NONE: u32 = 1073741823u; // three empty ranks: 1023 | 1023<<10 | 1023<<20
+
+// The ranking half of the old `point_light_sum` — the EXTERIOR doodad/MODD-prop family, anchored at
+// the receiving unit's own origin. Split out verbatim (same tests, same order, same tie handling)
+// so the sum can be re-evaluated later against the identical choice.
+fn point_light_pick(anchor: vec3<f32>) -> 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);
@@ -273,21 +370,67 @@ fn point_light_sum(P: vec3<f32>, N: vec3<f32>, anchor: vec3<f32>) -> vec3<f32> {
             sd[2] = d2; sel[2] = i;
         }
     }
+    return select(EXT_SEL_EMPTY, sel[0], sd[0] <= 9.9e29)
+        | (select(EXT_SEL_EMPTY, sel[1], sd[1] <= 9.9e29) << 10u)
+        | (select(EXT_SEL_EMPTY, sel[2], sd[2] <= 9.9e29) << 20u);
+}
+
+// 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).
+fn point_light_eval(sel: 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) {
+        let idx = (sel >> (10u * s)) & 1023u;
+        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 three entries, 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).
+//
+// Bounded at three iterations by construction, and reached only under `torch_ext_on()`, so nothing
+// here executes in daylight or with `exteriorShadows 0`.
+fn point_light_eval_shadowed(sel: u32, P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+    var sum = vec3<f32>(0.0);
+    for (var s = 0u; s < 3u; s = s + 1u) {
+        let idx = (sel >> (10u * s)) & 1023u;
+        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 s = 1.0;
+        if (ext_w > TORCH_SKIP_EPS) {
+            s = torch_exterior_shadow(fixture, P);
+        }
+        sum += wow_light.points[2u * idx + 1u].rgb * (ext_w * s);
+    }
+    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), 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
@@ -325,7 +468,9 @@ fn mcnk_cell_anchor(P: vec3<f32>) -> vec3<f32> {
     let iz = floor((half + P.z) / cell);
     return vec3<f32>((ix + 0.5) * cell - half, P.y, (iz + 0.5) * cell - half);
 }
-fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
+// 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>) -> u32 {
     let anchor = mcnk_cell_anchor(P);
     let count = u32(wow_light.point_count.x);
     var sel = array<u32, 3>(0u, 0u, 0u);
@@ -354,18 +499,12 @@ fn wmo_exterior_point_sum(P: vec3<f32>, N: vec3<f32>) -> vec3<f32> {
             sd[2] = d2; sel[2] = i;
         }
     }
-    var sum = vec3<f32>(0.0);
-    for (var s = 0u; s < 3u; s = s + 1u) {
-        if (sd[s] > 9.9e29) {
-            break;
-        }
-        let to_light = wow_light.points[2u * sel[s]].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);
-    }
-    return sum;
+    return select(EXT_SEL_EMPTY, sel[0], sd[0] <= 9.9e29)
+        | (select(EXT_SEL_EMPTY, sel[1], sd[1] <= 9.9e29) << 10u)
+        | (select(EXT_SEL_EMPTY, sel[2], sd[2] <= 9.9e29) << 20u);
+}
+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
@@ -635,8 +774,20 @@ fn interior_room_light(
         // 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.)
-        let s = torch_surface_shadow(pos_range.xyz, P);
-        direct += c_norm * (atten * nl * window) * s * w;
+        // 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);
+        }
+        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
@@ -674,6 +825,12 @@ struct GxVsOut {
     @location(3) @interpolate(flat) word: u32,
     @location(4) point_lit: vec3<f32>,
     @location(5) color: vec4<f32>,
+    // MONKEY (outdoor torch shadows): WHICH ≤3 exterior table entries `point_lit` was summed from,
+    // packed 10 bits each (see `EXT_SEL_NONE`). FLAT, because it is a choice, not a quantity —
+    // interpolating three packed indices would produce a fourth, 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.
+    @location(6) @interpolate(flat) ext_sel: u32,
 }
 
 @vertex
@@ -691,6 +848,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
@@ -725,6 +883,7 @@ fn vertex(v: GxVertex) -> GxVsOut {
         // 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
@@ -732,9 +891,16 @@ fn vertex(v: GxVertex) -> GxVsOut {
         // 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.
-        out.point_lit = wmo_exterior_point_sum(world, v.normal);
+        // MONKEY (outdoor torch shadows): the pick is published so the fragment stage can shadow
+        // these same three entries 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);
+        let sel = point_light_pick(v.anchor);
+        out.ext_sel = sel;
+        out.point_lit = point_light_eval(sel, world, v.normal);
     }
     return out;
 }
@@ -794,6 +960,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 three 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(
@@ -905,6 +1095,40 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
             }
         }
         let sidn_e = sidn_rgb * (wow_light.grade.x * sidn_w);
+        // 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.
+        // `ext_night` itself is kept for the `interiorDebug 4` overlay only.
+        let night_w = 0.0;
         // 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
@@ -938,7 +1162,7 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // the whole skyline.
         var ext_room = vec3<f32>(0.0);
         let ext_room_d = distance(in.world_position.xyz, view.world_position.xyz);
-        if (!interior && wow_light.wmo_fog_params.w > 0.5 && ext_room_d < EXT_ROOM_FADE_END) {
+        if (!interior && interiors_on && ext_room_d < EXT_ROOM_FADE_END) {
             let lit = interior_room_light(
                 in.world_position.xyz,
                 n_lit,
@@ -947,7 +1171,16 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
                 true, // fail CLOSED: an unclaimed exterior surface renders exactly as before
             );
             let far = 1.0 - smoothstep(EXT_ROOM_FADE_START, EXT_ROOM_FADE_END, ext_room_d);
-            ext_room = max(lit - vec3<f32>(wow_light.point_count.y), vec3<f32>(0.0)) * far;
+            // MONKEY (ext-class night law): the ambient floor is subtracted by `1 − night_w`, not
+            // flat. The floor is removed here because an exterior surface has the SKY for its
+            // floor — but that premise is exactly what `night_w` retires, so the two must move
+            // together or the dusk cross-fade dips (the sky half already faded out, the interior
+            // half's floor still subtracted away). At `night_w = 1` this term is weighted to zero
+            // by the blend below anyway; the scaling is what keeps the ramp between monotone.
+            ext_room = max(
+                lit - vec3<f32>(wow_light.point_count.y * (1.0 - night_w)),
+                vec3<f32>(0.0),
+            ) * far;
         }
         // 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
@@ -955,7 +1188,7 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // 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 + ext_room) + sidn_e,
+            vc.rgb * (lit_wmo + point_lit + ext_room) + sidn_e,
             vec3<f32>(0.0),
             vec3<f32>(1.0),
         );
@@ -964,7 +1197,14 @@ 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 && wow_light.wmo_fog_params.w > 0.5) {
+        // MONKEY (ext-class night law): `night_w > 0` is a HARD gate, not a redundant one. With the
+        // sun up the blend below would be `mix(interior_result, rgb, 1.0)` = `a + (b − a)`, which
+        // in floats does not always round back to `b` — the ±1/255 film this renderer has chased
+        // before, and it would land on every sunlit street, wall and courtyard in the world, which
+        // is most of a city's screen. Skipping the branch outright makes DAYLIGHT bit-identical to
+        // the reference path, and costs nothing but the per-fragment point walk we also do not want
+        // to pay in daylight. Interior groups are unaffected: they enter on `interior` as before.
+        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
@@ -990,7 +1230,14 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
                 n_lit,
                 gx_room_inst(),
                 gx_room_group(in.word),
-                false, // the interior lane's gate fails OPEN (see `interior_room_admits`)
+                // 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) {
@@ -998,7 +1245,32 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
             } else if (!class_int) {
                 day_w = 1.0;
             }
-            let illum = vec3<f32>(1.0) - exp(-(room + sidn_e) * wow_light.point_count.w);
+            // 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.
+            let illum = vec3<f32>(1.0)
+                - exp(-(room + 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
@@ -1013,6 +1285,41 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
                 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
         // interior-prop branch verbatim: the folded per-instance SH probe (MODD ambient +
@@ -1039,7 +1346,7 @@ 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
@@ -1116,7 +1423,7 @@ fn fragment(in: GxVsOut) -> @location(0) vec4<f32> {
         // 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/static_gx/bake.rs b/crates/benilla-world/src/static_gx/bake.rs
index 61b057f5..5ca99b13 100644
--- a/crates/benilla-world/src/static_gx/bake.rs
+++ b/crates/benilla-world/src/static_gx/bake.rs
@@ -296,6 +296,7 @@ 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),
         });
     }
     // Recentre for clip-space precision (0974): the shader reconstructs world = v + origin.
@@ -534,6 +535,7 @@ mod tests {
             sidn: Some([10, 20, 30]),
             window: true,
             batch_order: group + 1,
+            ext_night: 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 4fc5b7dc..e7fc17f4 100644
--- a/crates/benilla-world/src/static_gx/mod.rs
+++ b/crates/benilla-world/src/static_gx/mod.rs
@@ -401,6 +401,10 @@ 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,
     /// 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,
@@ -540,7 +544,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
@@ -561,6 +571,11 @@ 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,
     /// The MOBA batch class (INT/TRANS/EXT) — the lighting-lane selector on interior groups.
     pub class: Option<WmoBatchClass>,
     /// The MOMT SIDN night-glow colour.
@@ -683,6 +698,7 @@ impl StaticGx {
         let wmo = b.wmo.map(|w| GxItemWmo {
             group: w.group,
             interior: w.interior,
+            ext_night: w.ext_night,
             class_lane: match (w.interior, w.class) {
                 (true, Some(WmoBatchClass::Int)) => 1,
                 (true, Some(WmoBatchClass::Trans)) => 2,
diff --git a/crates/benilla-world/src/static_gx/render.rs b/crates/benilla-world/src/static_gx/render.rs
index 30eae3cb..e6cfdcc0 100644
--- a/crates/benilla-world/src/static_gx/render.rs
+++ b/crates/benilla-world/src/static_gx/render.rs
@@ -71,6 +71,10 @@ 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,
 }
 
 /// One baked cell (or WMO region), published by the main-world flush.
@@ -177,6 +181,13 @@ const RECORD_FOG_BIT: u32 = 1 << 14;
 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;
+
 /// 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.
@@ -256,7 +267,12 @@ struct GxPipelines {
     /// 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(
@@ -439,7 +455,12 @@ fn prepare_static_gx(
     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 {
@@ -450,7 +471,7 @@ 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))
@@ -462,10 +483,16 @@ fn prepare_static_gx(
         for cutout in [false, true] {
             for two_sided in [false, true] {
                 let mut defs = vec![];
-                // The world camera uses Bevy's default Gaussian shadow filtering. The retained
-                // pipeline is custom, so it must opt into the same shader branch explicitly;
+                // 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.
-                defs.push(ShaderDefVal::from("SHADOW_FILTER_METHOD_GAUSSIAN"));
+                // 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"));
@@ -726,7 +753,13 @@ fn assemble_region(
                     | (u32::from(item.sidn[2]) << 16),
                 kill_bit(&draw.killed, i)
                     | (u32::from(item.slot) << 1)
-                    | if gated { room_key(item, &draw.sets) } else { 0 },
+                    | 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 },
             ]
         })
         .collect();
@@ -860,11 +893,32 @@ 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(
@@ -898,8 +952,18 @@ fn prepare_view_bind(
 /// 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(BindGroup);
+struct GxTorchBind {
+    group: BindGroup,
+    table: super::torch_depth::TorchTableUniform,
+    texture: TextureId,
+}
 
 fn prepare_torch_bind(
     mut commands: Commands,
@@ -910,6 +974,7 @@ fn prepare_torch_bind(
     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.
@@ -920,25 +985,62 @@ fn prepare_torch_bind(
         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),
+        contents: bytemuck::bytes_of(table),
         usage: BufferUsages::UNIFORM,
     });
     let layout = pipeline_cache.get_bind_group_layout(&pipes.torch_layout);
-    commands.insert_resource(GxTorchBind(render_device.create_bind_group(
+    render_device.create_bind_group(
         "static_gx_torch",
         &layout,
         &BindGroupEntries::sequential((
-            // The image's default view: D2Array over all 192 layers — the 96 STATIC faces the
-            // table's matrices address plus the 96 LIVE copies (MONKEY, static torch cache); the
-            // shader picks the bank per slot from `count.z`. (wgpu's default view for a
+            // 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,
-            targets.sampler(),
+            sampler,
             buffer.as_entire_binding(),
         )),
-    )));
+    )
 }
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
@@ -1095,7 +1197,7 @@ 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.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),
@@ -1177,6 +1279,7 @@ mod tests {
             order: 0,
             sidn: [0; 3],
             slot: 0,
+            ext_night: false,
         }
     }
 
diff --git a/crates/benilla-world/src/static_gx/torch_depth.rs b/crates/benilla-world/src/static_gx/torch_depth.rs
index 7d69f14d..9ec02afe 100644
--- a/crates/benilla-world/src/static_gx/torch_depth.rs
+++ b/crates/benilla-world/src/static_gx/torch_depth.rs
@@ -52,20 +52,23 @@ use bytemuck::Zeroable;
 use super::render::StaticGxView;
 use benilla_assets::materials::TorchBinds;
 
-/// MONKEY (static torch cache): each 512-square Depth32 face is 1 MiB. Two banks support
-/// sixteen resident static cubes and up to sixteen live entity overlays: 192 MiB total. Keep
-/// the edge here so a memory-constrained port can choose 384 (108 MiB, 25% less linear detail).
+/// 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;
 pub(crate) const CUBE_FACES: usize = 6;
-/// MONKEY (static torch cache): matrices address the 96 STATIC faces. Physical texture layers
-/// 0..96 hold those faces permanently; 96..192 are live copies used only by dynamic-mask bits.
+/// 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 * 2;
+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;
 
 /// **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.
@@ -81,6 +84,13 @@ pub struct TorchShadowViews {
     /// 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 (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
@@ -98,6 +108,18 @@ pub struct TorchShadowViews {
     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 (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.)
@@ -108,6 +130,7 @@ impl Default for TorchShadowViews {
             dynamic_mask: 0,
             ready_mask: 0,
             soft: 1.0,
+            exterior: false,
             positions: [Vec4::ZERO; MAX_TORCH_MAPS],
             view_projs: [Mat4::ZERO; MAX_TORCH_LAYERS],
             caster_meshes: [None; MAX_TORCH_MAPS],
@@ -117,9 +140,9 @@ impl Default for TorchShadowViews {
 }
 
 /// MONKEY (torch shadows Phase 3A): the ONE shared torch depth array — a `Depth32Float`
-/// MONKEY (static torch cache): 512×512×192-layer `Image` asset (render, sample, copy-src/dst),
+/// 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 192 layers
+/// 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
@@ -212,7 +235,7 @@ pub fn new_torch_shared(
 }
 
 /// MONKEY (static torch cache): byte-identical std140/std430 table in BOTH receiver shaders.
-/// count@0: live high-water mark, soft*100, dynamic mask, reserved (16 bytes).
+/// count@0: live high-water mark, soft*100, dynamic mask, lane flags (16 bytes).
 /// 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.
@@ -225,7 +248,11 @@ pub(crate) struct TorchTableUniform {
     /// alternative was a whole new 16-byte row for one dial.
     soft_x100: u32,
     dynamic_mask: u32,
-    _pad: 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],
 }
@@ -247,6 +274,9 @@ impl TorchTableUniform {
         // 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 };
         table.soft_x100 = (soft * 100.0).round().max(1.0) as u32;
+        // 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; }
@@ -270,12 +300,60 @@ 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());
-    queue.write_buffer(&buffer.0, 0, bytemuck::bytes_of(&table));
+    // 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
@@ -302,7 +380,7 @@ impl TorchDepthTargets {
 #[derive(Resource, Default)]
 struct TorchLayerViews {
     texture: Option<TextureId>,
-    /// `views[i]` = the depth attachment for array layer `i` (fixture `i / 6`, face `i % 6`).
+    /// MONKEY (live bank rank): static slot `i / 6`; live rank `(i - 96) / 6`; face `i % 6`.
     views: Vec<TextureView>,
 }
 
@@ -457,9 +535,10 @@ fn prepare_torch_depth(
         return;
     }
     let cached = cache.0.lock().unwrap();
-    let (ready_mask, rebuild_mask) = torch_cache_plan(&*cached, &views.caster_meshes[..count],
+    let (ready_mask, rebuild_mask, dynamic_mask) = torch_cache_plan(&*cached, &views.caster_meshes[..count], views.dynamic_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;
@@ -556,6 +635,7 @@ impl ViewNode for TorchDepthNode {
             let rebuild = draw.rebuild_mask & (1 << slot) != 0
                 && 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 {
@@ -576,8 +656,10 @@ impl ViewNode for TorchDepthNode {
                     pass.set_bind_group(0, &draw.bind_groups[layer], &[]);
                     draw_torch_mesh(&mut pass, views.caster_meshes[slot], meshes, allocator);
                 }
-                if dynamic {
-                    let live = layer + MAX_TORCH_LAYERS;
+                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,
@@ -609,9 +691,10 @@ impl ViewNode for TorchDepthNode {
             }
             if rebuild { cached[slot] = views.caster_meshes[slot]; }
             if trace_on && (trace_due || rebuild) {
-                info!("torch-cache: slot {slot} static {} dynamic {}",
+                info!("torch-cache: slot {slot} static {} dynamic {} live_rank {:?} live_base {:?}",
                     if rebuild { "rebuilt" } else { "cached" },
-                    if dynamic { "yes" } else { "no" });
+                    if dynamic { "yes" } else { "no" }, live_rank,
+                    live_rank.map(|rank| MAX_TORCH_LAYERS + rank * CUBE_FACES));
             }
         }
         Ok(())
@@ -670,8 +753,8 @@ pub(super) fn build(app: &mut App) {
 
 // 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.
-fn torch_cache_plan<T: Copy + Eq>(cached: &[Option<T>], requested: &[Option<T>],
-    mut mesh_ready: impl FnMut(T) -> bool) -> (u32, u32) {
+fn torch_cache_plan<T: Copy + Eq>(cached: &[Option<T>], requested: &[Option<T>], dynamic_mask: u32,
+    mut mesh_ready: impl FnMut(T) -> bool) -> (u32, u32, u32) {
     let (mut ready, mut rebuild) = (0u32, 0u32);
     for (i, requested) in requested.iter().take(MAX_TORCH_MAPS).enumerate() {
         let Some(id) = *requested else { continue };
@@ -682,7 +765,15 @@ fn torch_cache_plan<T: Copy + Eq>(cached: &[Option<T>], requested: &[Option<T>],
             ready |= 1 << i;
         }
     }
-    (ready, rebuild)
+    // 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
@@ -714,11 +805,12 @@ 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.
-    pub fn append_torch_triangles(&self, center: Vec3, reach: f32,
+    pub fn append_torch_triangles(&self, center: Vec3, reach: f32, self_exclude: f32,
         positions: &mut Vec<[f32; 3]>, indices: &mut Vec<u32>) {
         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, self_exclude) { 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()));
@@ -730,15 +822,41 @@ impl super::StaticGx {
         }
     }
 
+    /// 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) -> u64 {
+    pub fn torch_geometry_key(&self, center: Vec3, reach: f32, self_exclude: f32) -> 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, self_exclude) { 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.
@@ -752,6 +870,40 @@ impl super::StaticGx {
     }
 }
 
+/// MONKEY (outdoor torch shadows): EMITTER-OWNER EXCLUSION — is this item the fixture's own body?
+///
+/// A campfire's light sits AT the flame, inside the campfire prop's own opaque logs, and nothing in
+/// this lane knows the two belong together (the light is an ECS entity, the logs are a retained
+/// `GxItem`; the placement that spawned both is not carried on either side). Left in, the logs are
+/// the nearest occluder in every one of the six cube faces and the fire blacks out its OWN pool —
+/// which indoors never mattered, because an authored MOLT fixture stands clear of its bracket,
+/// and outdoors is the whole effect.
+///
+/// So identity is approximated by CONTAINMENT: an item whose entire bounding sphere lies inside
+/// `radius` of the fixture is the fixture's own body (or is so close to it that it can cast
+/// nothing but self-shadow). Containment, not centre distance, is what keeps a wall or a fence
+/// that merely PASSES near the fire — a large sphere with a near centre — casting normally.
+/// `radius <= 0` (the interior lane, and any caller that wants the old set) excludes nothing, so
+/// the interior gather is byte-for-byte the set it always was. An item with no bounds is never
+/// excluded: the failure direction of this test must be "keeps a caster", not "loses a wall".
+fn torch_item_is_emitter(item: &super::GxItem, center: Vec3, radius: f32) -> bool {
+    item.local_aabb.is_some_and(|aabb| torch_bound_contained(
+        &item.transform, aabb.center.into(), aabb.half_extents.into(), center, radius))
+}
+
+/// The containment 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`
+/// (the interior lane) 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 {
@@ -775,12 +927,39 @@ mod tests {
     #[test]
     fn cache_plan_reuses_and_limits_rebuilds() {
         let cached = [Some(10), Some(11), None, Some(13)];
-        assert_eq!(torch_cache_plan(&cached, &cached, |_| false), (0b1011, 0));
+        assert_eq!(torch_cache_plan(&cached, &cached, 0xf, |_| false), (0b1011, 0, 0b1011));
         let requested = [Some(20), Some(11), Some(12), Some(23)];
-        assert_eq!(torch_cache_plan(&cached, &requested, |_| true), (0b0111, 0b0101));
-        assert_eq!(torch_cache_plan(&cached, &requested, |id| id == 23), (0b1010, 0b1000));
-        assert_eq!(torch_cache_plan(&cached, &[None, Some(11)], |_| true), (0b10, 0));
-        assert_eq!(torch_cache_plan(&[None; 4], &requested, |_| true), (0b11, 0b11));
+        assert_eq!(torch_cache_plan(&cached, &requested, 0xf, |_| true), (0b0111, 0b0101, 0b0111));
+        assert_eq!(torch_cache_plan(&cached, &requested, 0xf, |id| id == 23), (0b1010, 0b1000, 0b1010));
+        assert_eq!(torch_cache_plan(&cached, &[None, Some(11)], 0xf, |_| true), (0b10, 0, 0b10));
+        assert_eq!(torch_cache_plan(&[None; 4], &requested, 0, |_| true), (0b11, 0b11, 0));
+    }
+
+    #[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, |_| false);
+        assert_eq!(capped, 0xff);
+        let mut requested = cached;
+        requested[0] = None;
+        let (ready, _, dynamic) = torch_cache_plan(&cached, &requested, 0x8001, |_| 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]
@@ -808,6 +987,37 @@ mod tests {
         assert_eq!(table.positions[0][3], 0.0);
         assert_eq!(table.positions[15][3], 1.0);
         assert_eq!(MAX_TORCH_LAYERS, 96);
-        assert_eq!(TORCH_TEXTURE_LAYERS, 192);
+        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));
     }
 }
diff --git a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
index 28f5e5d4..a456b356 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/assemble.rs
@@ -428,8 +428,11 @@ pub fn spawn_model_entities(
                         // entity path).
                         (class.never_fade || fade.is_some()).then_some((*owner, None, None, fade))
                     }
-                    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| {
                             (
@@ -438,6 +441,13 @@ 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),
                                     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 7d31df62..e19387e6 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/fx.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/fx.rs
@@ -67,6 +67,12 @@ fn spawn_point_light(
     // `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
@@ -94,6 +100,12 @@ fn spawn_point_light(
     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));
     }
@@ -166,6 +178,14 @@ pub(super) fn spawn_lights_for(
             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`,
@@ -490,6 +510,11 @@ pub(super) fn spawn_wmo_lights_for(
                     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
diff --git a/crates/benilla-world/src/terrain_stream/spawn/mod.rs b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
index a8e5ec40..5c8fcb70 100644
--- a/crates/benilla-world/src/terrain_stream/spawn/mod.rs
+++ b/crates/benilla-world/src/terrain_stream/spawn/mod.rs
@@ -456,6 +456,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,
                                     },
                                 )
                             })