diff --git a/Cargo.lock b/Cargo.lock
index d7ec227..c3e81d9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4317,9 +4317,6 @@ dependencies = [
 [[package]]
 name = "master_protocol"
 version = "0.1.0"
-dependencies = [
- "quinn-proto",
-]
 
 [[package]]
 name = "matchers"
@@ -5679,6 +5676,7 @@ dependencies = [
  "hud_iw4",
  "lighting_iw4",
  "marks_iw4",
+ "master_protocol",
  "math_iw4",
  "naga",
  "net",
@@ -5747,6 +5745,7 @@ dependencies = [
  "render_backend",
  "render_frame",
  "render_material",
+ "render_scene",
 ]
 
 [[package]]
diff --git a/crates/asset_game/src/fpv_assembly.rs b/crates/asset_game/src/fpv_assembly.rs
index 6d920b8..0ca55fc 100644
--- a/crates/asset_game/src/fpv_assembly.rs
+++ b/crates/asset_game/src/fpv_assembly.rs
@@ -123,6 +123,7 @@ pub struct FpvAssemblyKey {
 
 #[derive(Clone, Debug)]
 pub struct FpvSideAssemblies {
+    pub ammunition: asset_model::AmmunitionVisualMode,
     pub bare: Arc<FpvAssembly>,
     pub rocket: Option<Arc<FpvAssembly>>,
     pub melee: Option<Arc<FpvAssembly>>,
diff --git a/crates/asset_game/src/impact_fx_catalog.rs b/crates/asset_game/src/impact_fx_catalog.rs
index 3338503..d5a25d6 100644
--- a/crates/asset_game/src/impact_fx_catalog.rs
+++ b/crates/asset_game/src/impact_fx_catalog.rs
@@ -10,9 +10,9 @@ pub struct OwnedFxImpactEntry {
     pub flesh: [String; FX_IMPACT_FLESH_COUNT],
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct OwnedFxImpactTable {
-    pub t5: bool,
+    pub namespace: crate::AssetNamespace,
     pub name: String,
     pub entries: Vec<OwnedFxImpactEntry>,
     pub capture_gaps: usize,
@@ -28,11 +28,7 @@ impl OwnedFxImpactTable {
     }
 
     pub fn namespace(&self) -> crate::AssetNamespace {
-        if self.t5 {
-            crate::AssetNamespace::T5
-        } else {
-            crate::AssetNamespace::Iw4
-        }
+        self.namespace
     }
 
     pub fn effect_name(
@@ -105,7 +101,7 @@ impl ImpactFxCatalog {
         }
         self.capture_gaps += gaps;
         self.table = Some(OwnedFxImpactTable {
-            t5: false,
+            namespace: crate::AssetNamespace::Iw4,
             name,
             entries,
             capture_gaps: gaps,
@@ -164,7 +160,7 @@ impl ImpactFxCatalog {
         }
         self.capture_gaps += gaps;
         self.table = Some(OwnedFxImpactTable {
-            t5: true,
+            namespace: crate::AssetNamespace::T5,
             name: s.cstr(name)?.to_owned(),
             entries: rows,
             capture_gaps: gaps,
@@ -175,7 +171,7 @@ impl ImpactFxCatalog {
 
 impl OwnedFxImpactTable {
     pub fn impact_row(&self, impact_type: i32, exit: bool) -> Option<usize> {
-        if !self.t5 {
+        if self.namespace == crate::AssetNamespace::Iw4 {
             return fx_iw4::impact_table_row(impact_type, exit);
         }
         let exit = usize::from(exit);
diff --git a/crates/asset_game/src/menu_catalog.rs b/crates/asset_game/src/menu_catalog.rs
index 52e28b4..988c322 100644
--- a/crates/asset_game/src/menu_catalog.rs
+++ b/crates/asset_game/src/menu_catalog.rs
@@ -60,6 +60,12 @@ pub enum MenuEvent {
     },
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize)]
+pub struct ExpressionId {
+    pub source: u64,
+    pub statement: (u8, u32),
+}
+
 #[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct MenuHandlers {
@@ -113,6 +119,7 @@ pub struct MenuSlider {
 #[derive(Clone, Debug, Default, serde::Deserialize, serde::Serialize)]
 #[serde(default, deny_unknown_fields)]
 pub struct MenuItem {
+    pub authored_id: String,
     pub name: String,
     pub handlers: ItemHandlers,
 
@@ -149,6 +156,8 @@ pub struct MenuItem {
     pub vis_ptr: u8,
     pub mat_ptr: u8,
     pub vis_exp: String,
+    pub visibility_expression: Option<ExpressionId>,
+    pub expression_ids: std::collections::BTreeMap<String, ExpressionId>,
     pub text_exp: String,
     pub material_exp: String,
     pub disabled_exp: String,
@@ -197,17 +206,6 @@ pub struct MenuDef {
 }
 
 impl MenuDef {
-    pub fn inherit_shared_vis(&mut self) {
-        let mut prev = String::new();
-        for item in &mut self.items {
-            if item.vis_exp.is_empty() && item.vis_ptr != 0 && !prev.is_empty() {
-                item.vis_exp = prev.clone();
-            } else if !item.vis_exp.is_empty() {
-                prev = item.vis_exp.clone();
-            }
-        }
-    }
-
     pub fn static_dvar_name(&self, index: i32) -> Option<&str> {
         self.expr_dvar_rows
             .get_or_init(|| expr_dvar_rows(&self.expr_dvars))
@@ -345,8 +343,12 @@ impl CapturedStringTable {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ImageProductRevision(pub u64);
+
 #[derive(Clone, Debug, Default, Resource)]
 pub struct MenuCatalog {
+    image_revision: std::sync::OnceLock<ImageProductRevision>,
     pub menus: BTreeMap<String, MenuDef>,
     pub fonts: BTreeMap<String, FontDef>,
 
@@ -354,14 +356,14 @@ pub struct MenuCatalog {
 
     pub rawfiles: BTreeMap<String, String>,
 
-    pub zone_images: BTreeMap<String, ZoneUiImage>,
+    pub(crate) zone_images: BTreeMap<String, ZoneUiImage>,
 
-    pub material_state_bits: BTreeMap<String, asset_iw4::ColorPassAgreement<[u32; 2]>>,
+    pub(crate) material_state_bits: BTreeMap<String, asset_iw4::ColorPassAgreement<[u32; 2]>>,
 
-    pub material_2d_plans: BTreeMap<String, HudMaterialPlan>,
+    pub(crate) material_2d_plans: BTreeMap<String, HudMaterialPlan>,
 
-    pub material_images: BTreeMap<String, String>,
-    pub material_srgb_reads: BTreeMap<String, bool>,
+    pub(crate) material_images: BTreeMap<String, String>,
+    pub(crate) material_srgb_reads: BTreeMap<String, bool>,
     pub lists: Vec<(String, i32)>,
     pub walked: usize,
 
@@ -390,16 +392,64 @@ pub struct HudMaterialTextureBinding {
 }
 
 impl MenuCatalog {
-    /// Runs after every variant is resolved: a variant that overrides an item's
-    /// visibility must still pass it on to the items that share it.
-    pub fn inherit_shared_vis(&mut self) {
-        for def in self.menus.values_mut() {
-            def.inherit_shared_vis();
-        }
-    }
-
     pub fn load_definitions(&mut self, source: &str) -> Result<(), String> {
-        let definitions = crate::menu_source::load(source, self)?;
+        let mut definitions = crate::menu_source::load(source, self)?;
+        use std::hash::{Hash, Hasher};
+        let mut hash = std::collections::hash_map::DefaultHasher::new();
+        source.hash(&mut hash);
+        let source = hash.finish();
+        let mut next = 0_u32;
+        for definition in &mut definitions {
+            let mut ids = std::collections::BTreeSet::new();
+            for item in &definition.items {
+                if !item.authored_id.is_empty()
+                    && !ids.insert(item.authored_id.to_ascii_lowercase())
+                {
+                    return Err(format!(
+                        "Duplicate authored item identity in {}",
+                        definition.name
+                    ));
+                }
+            }
+            for item in &mut definition.items {
+                item.expression_ids.clear();
+                for (field, dump) in [
+                    ("Visible", &item.vis_exp),
+                    ("Disabled", &item.disabled_exp),
+                    ("Text", &item.text_exp),
+                    ("Material", &item.material_exp),
+                ] {
+                    if !dump.is_empty() {
+                        item.expression_ids.insert(
+                            field.to_owned(),
+                            ExpressionId {
+                                source,
+                                statement: (u8::MAX, next),
+                            },
+                        );
+                        next = next
+                            .checked_add(1)
+                            .ok_or("authored expression identity exhausted")?;
+                    }
+                }
+                for (key, dump) in &item.float_exp {
+                    if !dump.is_empty() {
+                        item.expression_ids.insert(
+                            format!("Float({key})"),
+                            ExpressionId {
+                                source,
+                                statement: (u8::MAX, next),
+                            },
+                        );
+                        next = next
+                            .checked_add(1)
+                            .ok_or("authored expression identity exhausted")?;
+                    }
+                }
+                item.visibility_expression = item.expression_ids.get("Visible").copied();
+            }
+        }
+
         self.menus
             .extend(definitions.into_iter().map(|def| (def.name.clone(), def)));
         Ok(())
@@ -475,6 +525,34 @@ impl MenuCatalog {
             .get(&AssetRef::bare_name(name).to_ascii_lowercase())
     }
 
+    pub fn image_revision(&self) -> Option<ImageProductRevision> {
+        self.image_revision.get().copied()
+    }
+
+    pub fn publish_image_products(&self) -> ImageProductRevision {
+        *self
+            .image_revision
+            .get_or_init(|| ImageProductRevision(self.image_identity()))
+    }
+
+    pub fn zone_images(&self) -> &BTreeMap<String, ZoneUiImage> {
+        &self.zone_images
+    }
+    pub fn material_images(&self) -> &BTreeMap<String, String> {
+        &self.material_images
+    }
+    pub fn material_srgb_reads(&self) -> &BTreeMap<String, bool> {
+        &self.material_srgb_reads
+    }
+    pub fn material_2d_plans(&self) -> &BTreeMap<String, HudMaterialPlan> {
+        &self.material_2d_plans
+    }
+    pub fn material_state_bits(
+        &self,
+    ) -> &BTreeMap<String, asset_iw4::ColorPassAgreement<[u32; 2]>> {
+        &self.material_state_bits
+    }
+
     pub fn image_identity(&self) -> u64 {
         use std::hash::{Hash, Hasher};
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
@@ -483,7 +561,7 @@ impl MenuCatalog {
             image.material.hash(&mut hasher);
             image.image.hash(&mut hasher);
             (image.width, image.height).hash(&mut hasher);
-            Arc::as_ptr(&image.rgba).hash(&mut hasher);
+            image.rgba.as_slice().hash(&mut hasher);
         }
         self.material_images.hash(&mut hasher);
         self.material_srgb_reads.hash(&mut hasher);
@@ -529,6 +607,14 @@ impl MenuCatalog {
     }
 
     pub fn absorb(&mut self, other: MenuCatalog) {
+        let images_changed = !other.zone_images.is_empty()
+            || !other.material_images.is_empty()
+            || !other.material_srgb_reads.is_empty()
+            || !other.material_2d_plans.is_empty()
+            || !other.material_state_bits.is_empty();
+        if images_changed {
+            self.image_revision = std::sync::OnceLock::new();
+        }
         self.walked += other.walked;
         self.font_headers += other.font_headers;
         self.lists.extend(other.lists);
@@ -553,6 +639,9 @@ impl MenuCatalog {
         for (name, image) in other.zone_images {
             self.zone_images.insert(name, image);
         }
+        if images_changed {
+            self.publish_image_products();
+        }
     }
 }
 
@@ -660,7 +749,11 @@ fn load_menu_catalog_with_iwd(path: &Path, games: Option<&Path>) -> Result<MenuC
     let header = image.header().map_err(|e| e.to_string())?;
     let mut memory = ZoneMemory::for_header(&header);
     let mut stream = memory.stream(&image.bytes).map_err(|e| e.to_string())?;
+    use std::hash::{Hash, Hasher};
+    let mut source_hash = std::collections::hash_map::DefaultHasher::new();
+    image.bytes.hash(&mut source_hash);
     let mut sink = MenuSink {
+        expression_source: source_hash.finish(),
         catalog: MenuCatalog::default(),
         russian_fonts: path
             .parent()
@@ -680,7 +773,9 @@ fn load_menu_catalog_with_iwd(path: &Path, games: Option<&Path>) -> Result<MenuC
         Some((index, ty, slot)) => format!("asset #{index} {} at {slot:?}: {error:?}", ty.name()),
         None => format!("asset table: {error:?}"),
     })?;
-    Ok(sink.finish_and_take(games))
+    let catalog = sink.finish_and_take(games);
+    catalog.publish_image_products();
+    Ok(catalog)
 }
 
 #[derive(Clone, Copy)]
@@ -713,6 +808,7 @@ enum RecordedEvent {
 }
 
 struct MenuSink {
+    expression_source: u64,
     russian_fonts: bool,
     catalog: MenuCatalog,
     names: HashMap<(u8, u32), String>,
@@ -1377,6 +1473,52 @@ impl AssetLinkSink for MenuSink {
         Ok(())
     }
 
+    fn capture_item_expression_reference(
+        &mut self,
+        menu: &str,
+        _item: &str,
+        field: fastfile_iw4::ItemExpressionField,
+        source: Ptr,
+    ) -> fastfile_iw4::Result<()> {
+        if let Some(item) = self
+            .catalog
+            .menus
+            .get_mut(menu)
+            .and_then(|menu| menu.items.last_mut())
+        {
+            item.expression_ids.insert(
+                format!("{field:?}"),
+                ExpressionId {
+                    source: self.expression_source,
+                    statement: ptr_key(source),
+                },
+            );
+        }
+        Ok(())
+    }
+
+    fn capture_item_visible_reference(
+        &mut self,
+        menu: &str,
+        item: &str,
+        source: Ptr,
+        dump: &str,
+    ) -> fastfile_iw4::Result<()> {
+        self.capture_item_visible_exp(menu, item, dump)?;
+        if let Some(item) = self
+            .catalog
+            .menus
+            .get_mut(menu)
+            .and_then(|menu| menu.items.last_mut())
+        {
+            item.visibility_expression = Some(ExpressionId {
+                source: self.expression_source,
+                statement: ptr_key(source),
+            });
+        }
+        Ok(())
+    }
+
     fn capture_item_visible_exp(
         &mut self,
         menu: &str,
diff --git a/crates/asset_game/src/weapon_catalog.rs b/crates/asset_game/src/weapon_catalog.rs
index e35c38e..d3f0485 100644
--- a/crates/asset_game/src/weapon_catalog.rs
+++ b/crates/asset_game/src/weapon_catalog.rs
@@ -31,7 +31,9 @@ mod capture_t6;
 pub use capture_t5::t5_inline_note_alias;
 use capture_t6::*;
 mod capture_t5;
+mod flame_stream;
 use capture_t5::*;
+pub use flame_stream::{FlameStreamView, FlameTube, WeaponFlameStream};
 mod capture_iw5;
 use capture_iw5::*;
 mod binding;
@@ -326,6 +328,7 @@ pub(crate) struct WeaponBodyFacts {
     pub min_player_damage: i32,
     pub max_damage_range: f32,
     pub min_damage_range: f32,
+    pub flame_damage_interval_ms: i32,
 
     pub kick: WeaponKickFacts,
 
@@ -625,6 +628,8 @@ struct CatalogWeapon {
 
     pub combat_fx: WeaponCombatFx,
 
+    pub flame: Option<Box<WeaponFlameStream>>,
+
     pub(crate) combat_slots: CombatFxSlots,
     pub facts: WeaponBodyFacts,
 }
@@ -836,6 +841,9 @@ pub struct WeaponSoundAliases {
 
     pub fire_player_akimbo: Option<String>,
 
+    pub fire_start: Option<String>,
+    pub fire_start_player: Option<String>,
+
     pub fire_loop: Option<String>,
     pub fire_loop_player: Option<String>,
 
@@ -923,6 +931,12 @@ weapon_sound_slots! {
     ProjIgnition => proj_ignition_sound,
     FireLast => fire_last,
     FireLastPlayer => fire_last_player,
+    FireStart => fire_start,
+    FireStartPlayer => fire_start_player,
+    FireLoop => fire_loop,
+    FireLoopPlayer => fire_loop_player,
+    FireStop => fire_stop,
+    FireStopPlayer => fire_stop_player,
 }
 
 impl WeaponSoundAliases {
@@ -967,6 +981,8 @@ impl WeaponSoundAliases {
             self.projectile.as_deref(),
             self.proj_ignition_sound.as_deref(),
             self.fire_player_akimbo.as_deref(),
+            self.fire_start.as_deref(),
+            self.fire_start_player.as_deref(),
             self.fire_loop.as_deref(),
             self.fire_loop_player.as_deref(),
             self.fire_stop.as_deref(),
@@ -1428,6 +1444,8 @@ struct WeaponRow {
 
     combat_fx: WeaponCombatFx,
 
+    flame: Option<Box<WeaponFlameStream>>,
+
     reticle: WeaponReticleAssets,
 
     hud_material_edges: WeaponHudMaterialEdges,
@@ -1533,6 +1551,7 @@ impl Default for WeaponRow {
             iw5_notetrack_overrides: Vec::new(),
             sounds: WeaponSoundAliases::default(),
             combat_fx: WeaponCombatFx::empty(crate::AssetNamespace::Iw4),
+            flame: None,
             reticle: WeaponReticleAssets::default(),
             hud_material_edges: WeaponHudMaterialEdges::default(),
             overlay_material: None,
diff --git a/crates/asset_game/src/weapon_catalog/capture_iw4.rs b/crates/asset_game/src/weapon_catalog/capture_iw4.rs
index cf51c38..3f3b7ac 100644
--- a/crates/asset_game/src/weapon_catalog/capture_iw4.rs
+++ b/crates/asset_game/src/weapon_catalog/capture_iw4.rs
@@ -279,6 +279,8 @@ impl WeaponCatalog {
                     geometry.notetrack_rumble_values,
                 ),
                 fire_player_akimbo: None,
+                fire_start: None,
+                fire_start_player: None,
                 fire_loop: None,
                 fire_loop_player: None,
                 fire_stop: None,
@@ -304,6 +306,7 @@ impl WeaponCatalog {
                 explosion: geometry.explosion_slot,
                 tracer: geometry.tracer_slot,
             },
+            flame: None,
             combat_fx: WeaponCombatFx {
                 last_shot_eject_pair_authored: geometry.view_last_shot_eject_slot.is_some()
                     && geometry.world_last_shot_eject_slot.is_some(),
@@ -464,6 +467,7 @@ impl WeaponCatalog {
                 min_player_damage: geometry.min_player_damage,
                 max_damage_range: geometry.max_damage_range,
                 min_damage_range: geometry.min_damage_range,
+                flame_damage_interval_ms: 0,
                 kick: WeaponKickFacts::from_capture(geometry.kick),
                 sway: WeaponSwayFacts::from_capture(geometry.sway),
                 dual_wield_view_model_offset: geometry.dual_wield_view_model_offset,
diff --git a/crates/asset_game/src/weapon_catalog/capture_iw5.rs b/crates/asset_game/src/weapon_catalog/capture_iw5.rs
index cdfb239..5257c82 100644
--- a/crates/asset_game/src/weapon_catalog/capture_iw5.rs
+++ b/crates/asset_game/src/weapon_catalog/capture_iw5.rs
@@ -269,6 +269,7 @@ impl WeaponCatalog {
             sz_xanims_left: [const { None }; WEAPON_ANIM_SLOTS],
             hide_tags: read_hide_tags_iw5(stream, strings, geometry.hide_tags),
             sounds: leftover_iw5_sounds(stream, strings, &geometry),
+            flame: None,
             combat_fx: read_iw5_combat_fx(stream, &geometry, fx_name_at_slot),
             combat_slots: CombatFxSlots::default(),
             facts: capture_iw5_body_facts(stream, &geometry),
@@ -839,6 +840,8 @@ pub(super) fn leftover_iw5_sounds(
     };
     let mut sounds = WeaponSoundAliases {
         notetrack_convention: NotetrackConvention::SoundMap,
+        fire_start: None,
+        fire_start_player: None,
         pickup: leftover_iw5_snd_alias(stream, body, sz::WEAPON_DEF_SND_PICKUP_OFF, 128),
         pickup_player: leftover_iw5_snd_alias(
             stream,
diff --git a/crates/asset_game/src/weapon_catalog/capture_merge.rs b/crates/asset_game/src/weapon_catalog/capture_merge.rs
index 9576d60..dd76bed 100644
--- a/crates/asset_game/src/weapon_catalog/capture_merge.rs
+++ b/crates/asset_game/src/weapon_catalog/capture_merge.rs
@@ -207,6 +207,8 @@ pub(super) fn merge_sound_aliases(dst: &mut WeaponSoundAliases, src: &WeaponSoun
         (&mut dst.projectile, &src.projectile),
         (&mut dst.proj_ignition_sound, &src.proj_ignition_sound),
         (&mut dst.fire_player_akimbo, &src.fire_player_akimbo),
+        (&mut dst.fire_start, &src.fire_start),
+        (&mut dst.fire_start_player, &src.fire_start_player),
         (&mut dst.fire_loop, &src.fire_loop),
         (&mut dst.fire_loop_player, &src.fire_loop_player),
         (&mut dst.fire_stop, &src.fire_stop),
@@ -680,6 +682,9 @@ pub(super) fn merge_body_facts(dst: &mut WeaponBodyFacts, src: WeaponBodyFacts)
     if dst.min_damage_range == 0.0 {
         dst.min_damage_range = src.min_damage_range;
     }
+    if dst.flame_damage_interval_ms == 0 {
+        dst.flame_damage_interval_ms = src.flame_damage_interval_ms;
+    }
     if !dst.inherits_perks && src.inherits_perks {
         dst.inherits_perks = true;
     }
diff --git a/crates/asset_game/src/weapon_catalog/capture_t5.rs b/crates/asset_game/src/weapon_catalog/capture_t5.rs
index 5633f36..da0e561 100644
--- a/crates/asset_game/src/weapon_catalog/capture_t5.rs
+++ b/crates/asset_game/src/weapon_catalog/capture_t5.rs
@@ -185,6 +185,7 @@ impl WeaponCatalog {
             hide_tags: read_hide_tags_t5(stream, strings, geometry.hide_tags),
             sounds: leftover_t5_sounds(stream, strings, &geometry),
             combat_fx: WeaponCombatFx::empty(crate::AssetNamespace::T5),
+            flame: flame_stream::capture_t5_flame_stream(stream, &geometry),
             combat_slots: CombatFxSlots::default(),
             facts: capture_t5_body_facts(stream, &geometry),
         });
@@ -385,6 +386,46 @@ pub(super) fn leftover_t5_cstr(
         .map(str::to_owned)
 }
 
+fn leftover_t5_flame_table(
+    stream: &fastfile_t5::ZoneStream<'_>,
+    body: fastfile_t5::Ptr,
+    off: usize,
+) -> Option<fastfile_t5::Ptr> {
+    match stream.ptr_at(body, off).ok()? {
+        fastfile_t5::ZonePtr::Offset(q) => Some(stream.resolve_alias(q)),
+        _ => None,
+    }
+}
+
+fn apply_t5_flame(
+    stream: &fastfile_t5::ZoneStream<'_>,
+    body: fastfile_t5::Ptr,
+    facts: &mut WeaponBodyFacts,
+) {
+    use fastfile_t5::size as sz;
+    let fuel_tank = u8_at_t5(stream, body, sz::WEAPON_DEF_FUEL_TANK_WEAPON_OFF) != 0;
+    let tank_life_ms = i32_at_t5(stream, body, sz::WEAPON_DEF_TANK_LIFE_TIME_OFF);
+    if fuel_tank && tank_life_ms > 0 && facts.fire_time_ms > 0 {
+        let ticks = (tank_life_ms / facts.fire_time_ms).max(1);
+        facts.clip_size = facts.clip_size.saturating_mul(ticks);
+        if !facts.ammo_count_clip_relative {
+            facts.start_ammo = facts.start_ammo.saturating_mul(ticks);
+            facts.max_ammo = facts.max_ammo.saturating_mul(ticks);
+        }
+    }
+    facts.flame_damage_interval_ms =
+        f32_at_t5(stream, body, sz::WEAPON_DEF_DAMAGE_INTERVAL_OFF) as i32;
+    let reach = leftover_t5_flame_table(stream, body, sz::WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF)
+        .map(|table| {
+            f32_at_t5(stream, table, sz::FLAME_TABLE_STREAM_FUEL_LENGTH_OFF)
+                + f32_at_t5(stream, table, sz::FLAME_TABLE_STREAM_FLAME_LENGTH_OFF)
+        })
+        .unwrap_or(0.0);
+    facts.min_damage = facts.damage;
+    facts.max_damage_range = reach;
+    facts.min_damage_range = reach;
+}
+
 pub(super) fn leftover_t5_asset_slot(
     stream: &fastfile_t5::ZoneStream<'_>,
     body: Option<fastfile_t5::Ptr>,
@@ -595,11 +636,40 @@ pub(super) fn leftover_t5_sounds(
     let Some(body) = geometry.weap_def else {
         return WeaponSoundAliases::default();
     };
+    let gas = geometry.weap_type == weapon_iw4::WEAPTYPE_GAS;
+    let flame_sound = |table_off, sound_off| {
+        let table = gas.then(|| leftover_t5_flame_table(stream, body, table_off))??;
+        leftover_t5_cstr(stream, table, sound_off)
+    };
     WeaponSoundAliases {
         projectile: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_PROJECTILE_SOUND_OFF),
         proj_explosion: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_PROJ_EXPLOSION_SOUND_OFF),
         proj_ignition_sound: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_PROJ_IGNITION_SOUND_OFF),
         notetrack_convention: NotetrackConvention::InlinePrefix,
+        fire_start: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_THIRD_PERSON_OFF,
+            sz::FLAME_TABLE_IGNITE_SOUND_OFF,
+        ),
+        fire_start_player: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF,
+            sz::FLAME_TABLE_IGNITE_SOUND_OFF,
+        ),
+        fire_loop: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_THIRD_PERSON_OFF,
+            sz::FLAME_TABLE_ON_LOOP_SOUND_OFF,
+        ),
+        fire_loop_player: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF,
+            sz::FLAME_TABLE_ON_LOOP_SOUND_OFF,
+        ),
+        fire_stop: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_THIRD_PERSON_OFF,
+            sz::FLAME_TABLE_COOLDOWN_SOUND_OFF,
+        ),
+        fire_stop_player: flame_sound(
+            sz::WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF,
+            sz::FLAME_TABLE_COOLDOWN_SOUND_OFF,
+        ),
         fire: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_FIRE_OFF),
         fire_player: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_FIRE_PLAYER_OFF),
         empty_fire: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_EMPTY_FIRE_OFF),
@@ -622,6 +692,8 @@ pub(super) fn leftover_t5_sounds(
         ),
         reload_end: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_RELOAD_END_OFF),
         reload_end_player: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_RELOAD_END_PLAYER_OFF),
+        alt_switch: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_ALT_SWITCH_OFF),
+        alt_switch_player: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_ALT_SWITCH_PLAYER_OFF),
         raise_player: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_RAISE_PLAYER_OFF),
         putaway_player: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_PUTAWAY_PLAYER_OFF),
         melee_swipe: leftover_t5_cstr(stream, body, sz::WEAPON_DEF_SND_MELEE_SWIPE_OFF),
@@ -853,6 +925,9 @@ pub(super) fn capture_t5_body_facts(
     };
     facts.inherits_perks = leftover_t5_inherits_host_perks();
     facts.kick = leftover_t5_kick(stream, geometry);
+    if facts.weap_type == weapon_iw4::WEAPTYPE_GAS {
+        apply_t5_flame(stream, body, &mut facts);
+    }
     facts
 }
 
diff --git a/crates/asset_game/src/weapon_catalog/capture_t6.rs b/crates/asset_game/src/weapon_catalog/capture_t6.rs
index c9d6d96..233ad83 100644
--- a/crates/asset_game/src/weapon_catalog/capture_t6.rs
+++ b/crates/asset_game/src/weapon_catalog/capture_t6.rs
@@ -117,7 +117,14 @@ impl WeaponCatalog {
             sz_xanims_left: t6_sz_xanims_left(weapon),
             hide_tags: Vec::new(),
             sounds: capture_t6_sounds(weapon),
+            flame: None,
             combat_fx: WeaponCombatFx {
+                view_flash_hint: weapon
+                    .def_asset_name(fastfile_t6::weapon::def::VIEW_FLASH_EFFECT)
+                    .map(str::to_owned),
+                world_flash_hint: weapon
+                    .def_asset_name(fastfile_t6::weapon::def::WORLD_FLASH_EFFECT)
+                    .map(str::to_owned),
                 explosion_hint: weapon
                     .def_asset_name(fastfile_t6::weapon::def::PROJ_EXPLOSION_EFFECT)
                     .map(str::to_owned),
@@ -424,6 +431,8 @@ pub(super) fn capture_t6_sounds(w: fastfile_t6::weapon::WeaponView<'_>) -> Weapo
         melee_miss: name(d::MELEE_MISS_SOUND),
         pullback: name(d::PULLBACK_SOUND),
         pullback_player: name(d::PULLBACK_SOUND_PLAYER),
+        alt_switch: name(d::ALT_SWITCH_SOUND),
+        alt_switch_player: name(d::ALT_SWITCH_SOUND_PLAYER),
         raise: name(d::RAISE_SOUND),
         raise_player: name(d::RAISE_SOUND_PLAYER),
         first_raise: name(d::FIRST_RAISE_SOUND),
diff --git a/crates/asset_game/src/weapon_catalog/combat.rs b/crates/asset_game/src/weapon_catalog/combat.rs
index 8b7c8ef..4d5c371 100644
--- a/crates/asset_game/src/weapon_catalog/combat.rs
+++ b/crates/asset_game/src/weapon_catalog/combat.rs
@@ -79,6 +79,7 @@ fn captured_input(f: WeaponBodyFacts, melee_charge_anim: bool) -> CapturedCombat
         stunned_start_time_ms: f.stunned_start_time_ms,
         stunned_end_time_ms: f.stunned_end_time_ms,
         damage: f.damage,
+        flame_damage_interval_ms: f.flame_damage_interval_ms,
         min_damage: f.min_damage,
         max_damage_range: f.max_damage_range,
         min_damage_range: f.min_damage_range,
diff --git a/crates/asset_game/src/weapon_catalog/flame_stream.rs b/crates/asset_game/src/weapon_catalog/flame_stream.rs
new file mode 100644
index 0000000..a3459c5
--- /dev/null
+++ b/crates/asset_game/src/weapon_catalog/flame_stream.rs
@@ -0,0 +1,122 @@
+use super::capture_t5::f32_at_t5;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct FlameTube {
+    pub size: [f32; 2],
+    pub length: f32,
+    pub segments: f32,
+    pub anim_loop_s: f32,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FlameStreamView {
+    pub chunk_gravity: [f32; 2],
+    pub chunk_max_size: f32,
+    pub chunk_size: [f32; 2],
+    pub chunk_size_rand: [f32; 2],
+    pub chunk_dist_scalar: f32,
+    pub chunk_speed: f32,
+    pub chunk_decel: f32,
+    pub chunk_life_s: f32,
+    pub chunk_rot_rand: f32,
+    pub fire_interval_s: [f32; 2],
+    pub fire_first_life_frac: f32,
+    pub fire_min_life_frac: f32,
+    pub fire_min_life_age_s: [f32; 2],
+    pub fuel: FlameTube,
+    pub flame: FlameTube,
+    pub fire_life_s: f32,
+    pub fire_life_rand_s: f32,
+    pub fire_speed_scale: f32,
+    pub fire_speed_scale_rand: f32,
+    pub fire_vel_add_z: f32,
+    pub fire_vel_add_z_rand: f32,
+    pub fire_vel_add_sideways: f32,
+    pub fire_gravity: [f32; 2],
+    pub fire_max_rot_vel: f32,
+    pub fire_friction: f32,
+    pub fire_end_size_add: f32,
+    pub fire_start_size_scale: f32,
+    pub fire_end_size_scale: f32,
+    /// `FlameTable` material order: fire, smoke, heat, drips, fuel, fuel2,
+    /// flame, flame2.
+    pub materials: [Option<String>; fastfile_t5::FLAME_TABLE_MATERIAL_COUNT],
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct WeaponFlameStream {
+    pub views: [FlameStreamView; 2],
+}
+
+impl WeaponFlameStream {
+    pub fn view(&self, player_view: bool) -> &FlameStreamView {
+        &self.views[usize::from(!player_view)]
+    }
+}
+
+pub(super) fn capture_t5_flame_stream(
+    stream: &fastfile_t5::ZoneStream<'_>,
+    geometry: &fastfile_t5::WeaponGeometry,
+) -> Option<Box<WeaponFlameStream>> {
+    use fastfile_t5::size as sz;
+    let body = geometry.weap_def?;
+    let mut views: [FlameStreamView; 2] = Default::default();
+    for (view, (off, names)) in views.iter_mut().zip(
+        [
+            sz::WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF,
+            sz::WEAPON_DEF_FLAME_TABLE_THIRD_PERSON_OFF,
+        ]
+        .into_iter()
+        .zip(&geometry.flame_material_names),
+    ) {
+        let table = match stream.ptr_at(body, off).ok()? {
+            fastfile_t5::ZonePtr::Offset(q) => stream.resolve_alias(q),
+            _ => return None,
+        };
+        let f = |i: usize| f32_at_t5(stream, table, i * 4);
+        let tube = |i: usize| FlameTube {
+            size: [f(i), f(i + 1)],
+            length: f(i + 2),
+            segments: f(i + 3),
+            anim_loop_s: f(i + 4),
+        };
+        let name = |slot: usize| {
+            names[slot]
+                .and_then(|ptr| stream.cstr(ptr).ok())
+                .filter(|name| !name.is_empty())
+                .map(str::to_owned)
+        };
+        *view = FlameStreamView {
+            chunk_gravity: [f(0), f(1)],
+            chunk_max_size: f(2),
+            chunk_size: [f(3), f(4)],
+            chunk_size_rand: [f(5), f(6)],
+            chunk_dist_scalar: f(7),
+            chunk_speed: f(10),
+            chunk_decel: f(11),
+            chunk_life_s: f(13),
+            chunk_rot_rand: f(28),
+            fire_interval_s: [f(18), f(19)],
+            fire_first_life_frac: f(20),
+            fire_min_life_frac: f(22),
+            fire_min_life_age_s: [f(23), f(24)],
+            fuel: tube(40),
+            flame: tube(45),
+            fire_life_s: f(58),
+            fire_life_rand_s: f(59),
+            fire_speed_scale: f(60),
+            fire_speed_scale_rand: f(61),
+            fire_vel_add_z: f(62),
+            fire_vel_add_z_rand: f(63),
+            fire_vel_add_sideways: f(64),
+            fire_gravity: [f(65), f(66)],
+            fire_max_rot_vel: f(67),
+            fire_friction: f(68),
+            fire_end_size_add: f(69),
+            fire_start_size_scale: f(70),
+            fire_end_size_scale: f(71),
+            materials: std::array::from_fn(name),
+        };
+    }
+    Some(Box::new(WeaponFlameStream { views }))
+}
diff --git a/crates/asset_game/src/weapon_catalog/model_linking.rs b/crates/asset_game/src/weapon_catalog/model_linking.rs
index c2aaefd..60fa656 100644
--- a/crates/asset_game/src/weapon_catalog/model_linking.rs
+++ b/crates/asset_game/src/weapon_catalog/model_linking.rs
@@ -188,7 +188,7 @@ impl WeaponBuild {
             if parent == 0 {
                 row.fpv_assemblies = [None, None];
             }
-            let Some(Ok(mounts)) = &row.fpv_mount_plan else {
+            let Some(Ok(mounts)) = &mut row.fpv_mount_plan else {
                 continue;
             };
             let clips: std::collections::BTreeSet<usize> = row
@@ -199,11 +199,19 @@ impl WeaponBuild {
                 .filter_map(|edge| edge.bound_index())
                 .collect();
             let hide_mode = row.preparation.hide_mode();
-            let embedded_ammo = mounts.rocket.is_none()
+            let declares_embedded = row.rocket_model.is_none()
                 && row.projectile_model.is_some()
                 && hide_tags
                     .iter()
                     .any(|tag| tag.eq_ignore_ascii_case("tag_clip"));
+            if declares_embedded && let Err(error) = mounts.prepare_embedded_ammunition(fpv) {
+                row.fpv_assemblies = std::array::from_fn(|_| Some(Err(error.to_string())));
+                continue;
+            }
+            let embedded_ammo = matches!(
+                mounts.ammunition,
+                asset_model::AmmunitionVisualMode::Embedded { .. }
+            );
             let knife_model = row.knife_xmodel.as_deref().map(|name| {
                 row.preparation
                     .bind_fpv(WeaponComponent::ViewModel, Some(name), fpv)
@@ -320,6 +328,7 @@ impl WeaponBuild {
                         .any(|(jammed, bare)| jammed.hide != bare.hide)
                         .then_some(jammed);
                     Some(Ok(crate::FpvSideAssemblies {
+                        ammunition: mounts.ammunition,
                         bare,
                         rocket,
                         melee,
diff --git a/crates/asset_game/src/weapon_catalog/publication.rs b/crates/asset_game/src/weapon_catalog/publication.rs
index ee7ebb6..3e1b0f9 100644
--- a/crates/asset_game/src/weapon_catalog/publication.rs
+++ b/crates/asset_game/src/weapon_catalog/publication.rs
@@ -328,6 +328,9 @@ impl WeaponBuild {
                             entry.sounds.leftover_sound_overrides.clone();
                     }
                     merge_combat_fx(&mut existing.combat_fx, &entry.combat_fx);
+                    if existing.flame.is_none() {
+                        existing.flame = entry.flame;
+                    }
                     merge_combat_slots(&mut existing.combat_slots, &entry.combat_slots);
                     merge_body_facts(&mut existing.facts, entry.facts);
                 }
@@ -430,6 +433,7 @@ impl WeaponBuild {
                 iw5_notetrack_overrides: entry.iw5_notetrack_overrides,
                 sounds: entry.sounds,
                 combat_fx: entry.combat_fx,
+                flame: entry.flame,
                 reticle: entry.reticle,
                 hud_material_edges: entry.hud_material_edges,
                 overlay_material_from_slot: entry.overlay_material_slot.is_some(),
diff --git a/crates/asset_game/src/weapon_catalog/registry.rs b/crates/asset_game/src/weapon_catalog/registry.rs
index 5d67798..348a251 100644
--- a/crates/asset_game/src/weapon_catalog/registry.rs
+++ b/crates/asset_game/src/weapon_catalog/registry.rs
@@ -1106,6 +1106,10 @@ impl WeaponRegistry {
         self.rows.get(index as usize).map(|row| &row.combat_fx)
     }
 
+    pub fn flame_stream_of(&self, index: u32) -> Option<&WeaponFlameStream> {
+        self.rows.get(index as usize)?.flame.as_deref()
+    }
+
     pub fn tracer_type_census(&self) -> AssetEdgeCensus {
         let mut census = AssetEdgeCensus::default();
         for row in self.rows.iter().skip(1) {
diff --git a/crates/asset_material/src/material_catalog.rs b/crates/asset_material/src/material_catalog.rs
index 1eee3bd..1a97233 100644
--- a/crates/asset_material/src/material_catalog.rs
+++ b/crates/asset_material/src/material_catalog.rs
@@ -2044,7 +2044,7 @@ impl MaterialCatalog {
                 sort_key: geometry.sort_key,
 
                 info_game_flags: geometry.info_game_flags,
-                texture_atlas: None,
+                texture_atlas: Some(geometry.texture_atlas),
                 surface_type_bits: Some(geometry.surface_type_bits),
                 t5_layered_surface_types: Some(geometry.layered_surface_types),
                 state_flags: geometry.state_flags,
diff --git a/crates/asset_material/src/material_compile/mod.rs b/crates/asset_material/src/material_compile/mod.rs
index 0f373de..5eec8e1 100644
--- a/crates/asset_material/src/material_compile/mod.rs
+++ b/crates/asset_material/src/material_compile/mod.rs
@@ -137,6 +137,7 @@ pub fn compile_material_catalog(source: &crate::MaterialDefinitions) -> RuntimeM
                     .draw_rules(material, source.is_unlit(material).unwrap_or(false)),
                 sort_key: material.sort_key,
                 info_game_flags: material.info_game_flags,
+                texture_atlas: material.texture_atlas.unwrap_or([1, 1]),
                 state_flags: material.state_flags,
                 surface_type_bits: material.surface_type_bits,
                 unlit: source.is_unlit(material).unwrap_or(false),
diff --git a/crates/asset_model/src/body_catalog.rs b/crates/asset_model/src/body_catalog.rs
index 4b2c8da..eb17a5a 100644
--- a/crates/asset_model/src/body_catalog.rs
+++ b/crates/asset_model/src/body_catalog.rs
@@ -80,6 +80,7 @@ impl BodyMeshEntry {
 
 #[derive(Clone, Debug, Default)]
 pub struct BodyMeshCatalog {
+    identity: u64,
     entries: HashMap<String, BodyMeshEntry>,
     kits_cache: std::sync::OnceLock<SoldierKits>,
 }
@@ -99,7 +100,15 @@ impl std::ops::Deref for BodyMeshBuild {
 }
 
 impl BodyMeshBuild {
-    pub fn publish(self) -> BodyMeshCatalog {
+    pub fn publish(mut self) -> BodyMeshCatalog {
+        static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+        self.catalog.identity = NEXT
+            .fetch_update(
+                std::sync::atomic::Ordering::Relaxed,
+                std::sync::atomic::Ordering::Relaxed,
+                |next| next.checked_add(1),
+            )
+            .expect("body product revision exhausted");
         self.catalog
     }
 
@@ -193,6 +202,10 @@ impl BodyMeshBuild {
 }
 
 impl BodyMeshCatalog {
+    pub fn identity(&self) -> u64 {
+        self.identity
+    }
+
     pub fn len(&self) -> usize {
         self.entries.len()
     }
diff --git a/crates/asset_model/src/fpv_catalog.rs b/crates/asset_model/src/fpv_catalog.rs
index cbb8e32..862a274 100644
--- a/crates/asset_model/src/fpv_catalog.rs
+++ b/crates/asset_model/src/fpv_catalog.rs
@@ -561,16 +561,104 @@ pub struct FpvMount {
     pub tag: String,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum AmmunitionVisualMode {
+    Absent,
+    Embedded { bone: u16 },
+    Mounted,
+}
+
 #[derive(Clone, Debug)]
 pub struct FpvMountPlan {
     pub gun: FpvMeshIndex,
     pub secondary_gun: Option<FpvMeshIndex>,
     pub attachments: Vec<FpvMount>,
     pub rocket: Option<FpvMount>,
+    pub ammunition: AmmunitionVisualMode,
     pub ads_swaps: Vec<(usize, FpvMeshIndex)>,
 }
 
 impl FpvMountPlan {
+    pub fn prepare_embedded_ammunition(
+        &mut self,
+        catalog: &FpvMeshCatalog,
+    ) -> Result<(), FpvMountError> {
+        let entry = catalog
+            .get_at(self.gun.order())
+            .ok_or_else(|| FpvMountError {
+                model: format!("#{}", self.gun.order()),
+                detail: "gun missing from FPV catalog",
+            })?;
+        let valid = entry.skel.pose.as_ref().is_some_and(|pose| {
+            let count = entry.skel.bone_names.len();
+            pose.num_bones == count
+                && entry.skel.bones.len() == count
+                && pose.num_root_bones > 0
+                && pose.num_root_bones <= count
+                && pose.parent_list.len() == count - pose.num_root_bones
+                && (pose.num_root_bones..count).all(|bone| entry.skel.parent_of(bone).is_some())
+                && entry.skel.vert_skin.iter().all(|skin| {
+                    (0..4)
+                        .filter(|index| {
+                            if *index == 0 {
+                                !skin.primary_is_zero()
+                            } else {
+                                skin.has_extra_weight(*index)
+                            }
+                        })
+                        .all(|index| usize::from(skin.bones[index]) < count)
+                })
+        });
+        if !valid {
+            return Err(FpvMountError {
+                model: entry.skel.name.clone(),
+                detail: "invalid embedded ammunition hierarchy or binding",
+            });
+        }
+        let bone = entry
+            .skel
+            .bone_names
+            .iter()
+            .position(|name| name.eq_ignore_ascii_case("tag_clip"))
+            .filter(|bone| *bone <= u8::MAX as usize)
+            .filter(|bone| {
+                entry.skel.vert_skin.iter().any(|skin| {
+                    skin.bones
+                        .iter()
+                        .enumerate()
+                        .filter(|(index, _)| {
+                            if *index == 0 {
+                                !skin.primary_is_zero()
+                            } else {
+                                skin.has_extra_weight(*index)
+                            }
+                        })
+                        .any(|(_, bound)| {
+                            let mut current = Some(usize::from(*bound));
+                            while let Some(index) = current {
+                                if index == *bone {
+                                    return true;
+                                }
+                                current = entry.skel.parent_of(index);
+                            }
+                            false
+                        })
+                })
+            })
+            .ok_or_else(|| FpvMountError {
+                model: entry.skel.name.clone(),
+                detail: "embedded ammunition has no bound geometry",
+            })?;
+        if entry.skel.pose.is_none() || self.rocket.is_some() {
+            return Err(FpvMountError {
+                model: entry.skel.name.clone(),
+                detail: "invalid embedded ammunition structure",
+            });
+        }
+        self.ammunition = AmmunitionVisualMode::Embedded { bone: bone as u16 };
+        Ok(())
+    }
+
     pub fn attachment_models(&self, ads: bool) -> impl Iterator<Item = FpvMeshIndex> + '_ {
         self.attachments.iter().enumerate().map(move |(at, mount)| {
             ads.then(|| self.ads_swaps.iter().find(|(swap, _)| *swap == at))
@@ -728,6 +816,11 @@ pub fn plan_fpv_mounts(
         gun,
         secondary_gun: None,
         attachments: selected,
+        ammunition: if rocket.is_some() {
+            AmmunitionVisualMode::Mounted
+        } else {
+            AmmunitionVisualMode::Absent
+        },
         rocket,
         ads_swaps: Vec::new(),
     })
diff --git a/crates/asset_model/src/world_weapon_catalog.rs b/crates/asset_model/src/world_weapon_catalog.rs
index 622b4d5..b1ce23b 100644
--- a/crates/asset_model/src/world_weapon_catalog.rs
+++ b/crates/asset_model/src/world_weapon_catalog.rs
@@ -109,12 +109,19 @@ impl WorldWeaponBuild {
     pub fn seal_identity(&mut self) -> u64 {
         static NEXT_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
         if self.catalog.identity == 0 {
-            self.catalog.identity = NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+            self.catalog.identity = NEXT_ID
+                .fetch_update(
+                    std::sync::atomic::Ordering::Relaxed,
+                    std::sync::atomic::Ordering::Relaxed,
+                    |next| next.checked_add(1),
+                )
+                .expect("world weapon product revision exhausted");
         }
         self.catalog.identity
     }
 
-    pub fn publish(self) -> WorldWeaponCatalog {
+    pub fn publish(mut self) -> WorldWeaponCatalog {
+        self.seal_identity();
         self.catalog
     }
 
@@ -227,6 +234,7 @@ impl WorldWeaponBuild {
     }
 
     fn retain(&mut self, key: WorldWeaponKey, entry: WorldWeaponEntry) {
+        self.catalog.identity = 0;
         if let Some(&pos) = self.catalog.indices.get(&key) {
             self.catalog.zones[pos] = self.capture_zone;
             self.catalog.entries[pos] = entry;
diff --git a/crates/asset_world/src/clip_collision.rs b/crates/asset_world/src/clip_collision.rs
index f111677..28ba080 100644
--- a/crates/asset_world/src/clip_collision.rs
+++ b/crates/asset_world/src/clip_collision.rs
@@ -28,12 +28,25 @@ pub struct ClipCmodel {
 #[derive(Clone, Debug, Default)]
 pub struct ClipMapMaterial {
     pub name: String,
+    pub source_surface_flags: u32,
     pub surface_flags: u32,
     pub content_flags: u32,
 }
 
+pub const COLLISION_ADAPTER_VERSION: u32 = 1;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum CollisionCoverage {
+    #[default]
+    Unvalidated,
+    Complete,
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct ClipCollision {
+    pub adapter_version: u32,
+    pub source_family: Option<asset_core::AssetNamespace>,
+    pub coverage: CollisionCoverage,
     pub brushes: Vec<ClipBrush>,
 
     pub nodes: Vec<ClipBspNode>,
@@ -178,6 +191,244 @@ impl clipmap_iw4::BrushView for ClipBrush {
 }
 
 impl ClipCollision {
+    pub fn validate(
+        &mut self,
+        family: asset_core::AssetNamespace,
+    ) -> Result<(), ClipCollisionError> {
+        self.coverage = CollisionCoverage::Unvalidated;
+        let invalid = || ClipCollisionError::InvalidSemantics("BSP node graph");
+        let finite = |v: &[f32]| v.iter().all(|n| n.is_finite());
+        let mut node_indegree = vec![0_usize; self.nodes.len()];
+        for node in &self.nodes {
+            if !finite(&node.plane) || node.plane[..3].iter().map(|n| n * n).sum::<f32>() < 0.5 {
+                return Err(invalid());
+            }
+            for child in node.children {
+                if child >= 0 {
+                    let slot = node_indegree.get_mut(child as usize).ok_or_else(invalid)?;
+                    *slot += 1;
+                } else if (-1_i64 - i64::from(child)) as usize >= self.leaves.len() {
+                    return Err(invalid());
+                }
+            }
+        }
+        let mut roots: std::collections::VecDeque<_> = node_indegree
+            .iter()
+            .enumerate()
+            .filter_map(|(index, n)| (*n == 0).then_some(index))
+            .collect();
+        let mut visited = 0;
+        while let Some(index) = roots.pop_front() {
+            visited += 1;
+            for child in self.nodes[index]
+                .children
+                .into_iter()
+                .filter(|child| *child >= 0)
+            {
+                node_indegree[child as usize] -= 1;
+                if node_indegree[child as usize] == 0 {
+                    roots.push_back(child as usize);
+                }
+            }
+        }
+        if visited != self.nodes.len() {
+            return Err(invalid());
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("brush hull");
+        for brush in &self.brushes {
+            if brush.planes.len() < 4
+                || brush.planes.len() != brush.plane_surface_flags.len()
+                || brush.planes.iter().any(|plane| {
+                    !finite(plane) || plane[..3].iter().map(|n| n * n).sum::<f32>() < 0.5
+                })
+            {
+                return Err(invalid());
+            }
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("leaf brush references");
+        if self
+            .leafbrushes
+            .iter()
+            .any(|index| *index as usize >= self.brushes.len())
+        {
+            return Err(invalid());
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("leaf brush span");
+        for leaf in &self.leaves {
+            if (leaf.first_brush as usize)
+                .checked_add(leaf.num_brushes as usize)
+                .is_none_or(|end| end > self.leafbrushes.len())
+            {
+                return Err(invalid());
+            }
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("collision model span or bounds");
+        for model in &self.cmodels {
+            if !finite(&model.mins)
+                || !finite(&model.maxs)
+                || !model.radius.is_finite()
+                || model.radius < 0.0
+                || (0..3).any(|axis| model.mins[axis] > model.maxs[axis])
+                || (model.first_brush as usize)
+                    .checked_add(model.num_brushes as usize)
+                    .is_none_or(|end| end > self.leafbrushes.len())
+            {
+                return Err(invalid());
+            }
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("mesh arrays");
+        let mesh = &self.mesh;
+        let triangles = mesh.tri_count();
+        if mesh.tri_indices.len() % 3 != 0 {
+            return Err(ClipCollisionError::InvalidSemantics("triangle triplets"));
+        }
+        if mesh.verts.iter().any(|vertex| !finite(vertex)) {
+            return Err(ClipCollisionError::InvalidSemantics("finite mesh vertices"));
+        }
+        if triangles != 0 && mesh.partitions.is_empty() {
+            return Err(ClipCollisionError::InvalidSemantics(
+                "mesh partitions absent",
+            ));
+        }
+        if triangles != 0 && mesh.tri_surface_flags.len() != triangles {
+            return Err(ClipCollisionError::InvalidSemantics(
+                "triangle surface flags",
+            ));
+        }
+        if triangles != 0 && mesh.tri_content_flags.len() != triangles {
+            return Err(ClipCollisionError::InvalidSemantics("triangle contents"));
+        }
+        if !self.tri_material_index.is_empty()
+            && (self.tri_material_index.len() != triangles
+                || self
+                    .tri_material_index
+                    .iter()
+                    .enumerate()
+                    .any(|(tri, index)| {
+                        *index as usize >= self.materials.len()
+                            && mesh
+                                .tri_content_flags
+                                .get(tri)
+                                .is_some_and(|flags| *flags != 0)
+                    }))
+        {
+            return Err(invalid());
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("partition range");
+        let mut covered = vec![false; triangles];
+        for partition in &mesh.partitions {
+            let first = usize::try_from(partition.first_tri).map_err(|_| invalid())?;
+            let end = first
+                .checked_add(partition.tri_count as usize)
+                .filter(|end| *end <= triangles)
+                .ok_or_else(invalid)?;
+            if (partition.first_border as usize)
+                .checked_add(partition.border_count as usize)
+                .is_none_or(|end| end > mesh.borders.len())
+            {
+                return Err(invalid());
+            }
+            covered[first..end].fill(true);
+            let base = partition.first_vert_segment as usize * clipmap_iw4::VERTS_PER_SEGMENT;
+            if mesh.tri_indices[first * 3..end * 3]
+                .iter()
+                .any(|index| base + *index as usize >= mesh.verts.len())
+            {
+                return Err(invalid());
+            }
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("triangle coverage");
+        if covered
+            .iter()
+            .enumerate()
+            .any(|(tri, covered)| !covered && mesh.tri_content_flags[tri] != 0)
+        {
+            return Err(invalid());
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("mesh border");
+        for border in &mesh.borders {
+            if !finite(&border.dist_eq)
+                || !finite(&[border.z_base, border.z_slope, border.start, border.length])
+                || border.length < 0.0
+            {
+                return Err(invalid());
+            }
+        }
+        for leaf in &self.leaves {
+            if (leaf.first_coll_aabb_index as usize)
+                .checked_add(leaf.coll_aabb_count as usize)
+                .is_none_or(|end| end > mesh.aabb_trees.len())
+            {
+                return Err(invalid());
+            }
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("AABB roots");
+        if mesh
+            .aabb_roots
+            .iter()
+            .any(|index| *index as usize >= mesh.aabb_trees.len())
+        {
+            return Err(invalid());
+        }
+        let invalid = || ClipCollisionError::InvalidSemantics("AABB child or partition reference");
+        for node in &mesh.aabb_trees {
+            if !finite(&node.origin)
+                || !finite(&node.half_size)
+                || node.half_size.iter().any(|n| *n < 0.0)
+                || (node.child_count != 0
+                    && usize::try_from(node.u)
+                        .ok()
+                        .and_then(|first| first.checked_add(node.child_count as usize))
+                        .is_none_or(|end| end > mesh.aabb_trees.len()))
+                || (node.child_count == 0
+                    && usize::try_from(node.u)
+                        .ok()
+                        .is_none_or(|index| index >= mesh.partitions.len()))
+            {
+                return Err(invalid());
+            }
+        }
+        let mut indegree = vec![0_usize; mesh.aabb_trees.len()];
+        for node in &mesh.aabb_trees {
+            if node.child_count == 0 {
+                if !self.materials.is_empty()
+                    && node.material_index as usize >= self.materials.len()
+                {
+                    return Err(invalid());
+                }
+            } else {
+                for child in node.u as usize..node.u as usize + node.child_count as usize {
+                    indegree[child] += 1;
+                }
+            }
+        }
+        let mut roots: std::collections::VecDeque<_> = indegree
+            .iter()
+            .enumerate()
+            .filter_map(|(index, n)| (*n == 0).then_some(index))
+            .collect();
+        let mut visited = 0;
+        while let Some(index) = roots.pop_front() {
+            visited += 1;
+            let node = &mesh.aabb_trees[index];
+            if node.child_count != 0 {
+                for child in node.u as usize..node.u as usize + node.child_count as usize {
+                    indegree[child] -= 1;
+                    if indegree[child] == 0 {
+                        roots.push_back(child);
+                    }
+                }
+            }
+        }
+        if visited != mesh.aabb_trees.len() {
+            return Err(ClipCollisionError::InvalidSemantics("AABB cycle"));
+        }
+        self.adapter_version = COLLISION_ADAPTER_VERSION;
+        self.source_family = Some(family);
+        self.coverage = CollisionCoverage::Complete;
+        Ok(())
+    }
+
     fn map_ref(&self) -> clipmap_iw4::ClipMapRef<'_, ClipBrush> {
         clipmap_iw4::ClipMapRef {
             nodes: &self.nodes,
@@ -208,6 +459,7 @@ impl ClipCollision {
         let mesh = self.mesh.as_ref().as_ref();
         let trace = clipmap_iw4::trace_brush_and_mesh(&map, &mesh, &ext, &|_piece| true);
         ClipSweepHit {
+            coverage: self.coverage,
             fraction: trace.fraction,
             normal: trace.normal,
             endpos: trace.endpos,
@@ -220,6 +472,7 @@ impl ClipCollision {
 
 #[derive(Clone, Copy, Debug)]
 pub struct ClipSweepHit {
+    pub coverage: CollisionCoverage,
     pub fraction: f32,
     pub normal: [f32; 3],
     pub endpos: [f32; 3],
@@ -235,11 +488,15 @@ pub enum ClipCollisionError {
     Truncated,
 
     LeafbrushIndexOverflow,
+    InvalidSemantics(&'static str),
 }
 
 impl core::fmt::Display for ClipCollisionError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
+            Self::InvalidSemantics(reason) => {
+                write!(f, "collision semantics or references are invalid: {reason}")
+            }
             Self::MissingTables => write!(f, "clipmap brush tables were not retained"),
             Self::Truncated => write!(f, "clipmap brush bytes truncated in arena"),
             Self::LeafbrushIndexOverflow => {
@@ -362,6 +619,7 @@ pub fn build_clip_collision(
     extract_cmodels(s, g, &mut out)?;
     gate_leafbrush_index_fits(out.leafbrushes.len())?;
 
+    out.validate(asset_core::AssetNamespace::Iw4)?;
     Ok(out)
 }
 
@@ -372,6 +630,9 @@ pub fn attach_static_models(
     out: &mut ClipCollision,
 ) {
     extract_static_models(s, g, catalog, out);
+    if out.static_models.len() != g.static_model_count {
+        out.coverage = CollisionCoverage::Unvalidated;
+    }
 }
 
 pub fn attach_iw5_static_models(
@@ -381,6 +642,9 @@ pub fn attach_iw5_static_models(
     out: &mut ClipCollision,
 ) {
     extract_iw5_static_models(s, g, catalog, out);
+    if out.static_models.len() != g.static_model_count {
+        out.coverage = CollisionCoverage::Unvalidated;
+    }
 }
 
 fn extract_mesh_tables(
@@ -389,6 +653,12 @@ fn extract_mesh_tables(
     out: &mut ClipCollision,
 ) -> Result<(), ClipCollisionError> {
     let mesh = std::sync::Arc::make_mut(&mut out.mesh);
+    if (g.vert_count != 0 && g.verts.is_none())
+        || (g.tri_count != 0 && g.tri_indices.is_none())
+        || (g.material_count != 0 && g.materials.is_none())
+    {
+        return Err(ClipCollisionError::MissingTables);
+    }
     let Some(verts_ptr) = g.verts else {
         return Ok(());
     };
@@ -548,7 +818,9 @@ fn extract_clip_materials_iw4(
 ) -> Result<Vec<ClipMapMaterial>, ClipCollisionError> {
     let mut out = Vec::with_capacity(g.material_count);
     let Some(mats) = g.materials else {
-        out.resize(g.material_count, ClipMapMaterial::default());
+        if g.material_count != 0 {
+            return Err(ClipCollisionError::MissingTables);
+        }
         return Ok(out);
     };
     for i in 0..g.material_count {
@@ -568,6 +840,7 @@ fn extract_clip_materials_iw4(
             .map_err(|_| ClipCollisionError::Truncated)?;
         out.push(ClipMapMaterial {
             name,
+            source_surface_flags: surface_flags,
             surface_flags,
             content_flags,
         });
@@ -1160,6 +1433,7 @@ pub fn build_iw5_clip_collision(
     extract_iw5_cmodels(s, g, &mut out)?;
     gate_leafbrush_index_fits(out.leafbrushes.len())?;
 
+    out.validate(asset_core::AssetNamespace::Iw5)?;
     Ok(out)
 }
 
@@ -1307,6 +1581,12 @@ fn extract_iw5_mesh_tables(
     out: &mut ClipCollision,
 ) -> Result<(), ClipCollisionError> {
     let mesh = std::sync::Arc::make_mut(&mut out.mesh);
+    if (g.vert_count != 0 && g.verts.is_none())
+        || (g.tri_count != 0 && g.tri_indices.is_none())
+        || (g.material_count != 0 && g.materials.is_none())
+    {
+        return Err(ClipCollisionError::MissingTables);
+    }
     let Some(verts_ptr) = g.verts else {
         return Ok(());
     };
@@ -1461,12 +1741,15 @@ fn extract_iw5_mesh_materials(
                     .map_err(|_| ClipCollisionError::Truncated)?;
                 mats.push(ClipMapMaterial {
                     name,
+                    source_surface_flags: surface_flags,
                     surface_flags,
                     content_flags,
                 });
             }
         } else {
-            mats.resize(g.material_count, ClipMapMaterial::default());
+            if g.material_count != 0 {
+                return Err(ClipCollisionError::MissingTables);
+            }
         }
         mats
     };
@@ -1814,6 +2097,7 @@ pub fn build_t5_clip_collision(
     extract_t5_mesh_tables(s, g, &mut out)?;
     extract_t5_bsp_tables(s, g, &mut out)?;
 
+    out.validate(asset_core::AssetNamespace::T5)?;
     Ok(out)
 }
 
@@ -1834,6 +2118,12 @@ fn extract_t5_mesh_tables(
     out: &mut ClipCollision,
 ) -> Result<(), ClipCollisionError> {
     let mesh = std::sync::Arc::make_mut(&mut out.mesh);
+    if (g.vert_count != 0 && g.verts.is_none())
+        || (g.tri_count != 0 && g.tri_indices.is_none())
+        || (g.material_count != 0 && g.materials.is_none())
+    {
+        return Err(ClipCollisionError::MissingTables);
+    }
     let Some(verts_ptr) = g.verts else {
         return Ok(());
     };
@@ -1876,6 +2166,7 @@ fn extract_t5_mesh_tables(
             let end = bytes.iter().position(|&b| b == 0).unwrap_or(bytes.len());
             out.materials.push(ClipMapMaterial {
                 name: String::from_utf8_lossy(&bytes[..end]).into_owned(),
+                source_surface_flags: s.u32_at(p, 64).map_err(|_| ClipCollisionError::Truncated)?,
                 surface_flags: treyarch_surface_flags(
                     s.u32_at(p, 64).map_err(|_| ClipCollisionError::Truncated)?,
                 ),
diff --git a/crates/asset_world/src/world_t6.rs b/crates/asset_world/src/world_t6.rs
index d0df91f..aaca5e0 100644
--- a/crates/asset_world/src/world_t6.rs
+++ b/crates/asset_world/src/world_t6.rs
@@ -493,6 +493,7 @@ pub fn build_clip_collision(load: &ZoneLoad) -> Result<crate::ClipCollision, Str
             let b = r.bytes(p, 12)?;
             out.materials.push(ClipMapMaterial {
                 name: r.text(Reader::ptr(b, 0)?)?.to_owned(),
+                source_surface_flags: Reader::word(b, 4)?,
                 surface_flags: crate::clip_collision::treyarch_surface_flags(Reader::word(b, 4)?),
                 content_flags: Reader::word(b, 8)?,
             });
@@ -553,7 +554,7 @@ pub fn build_clip_collision(load: &ZoneLoad) -> Result<crate::ClipCollision, Str
         for index in 0..static_count {
             let row = table.at(index * 84);
             let Some(model_asset) = load.asset_in(asset, row.at(4)) else {
-                continue;
+                return Err(format!("T6 collision static model {index} is unresolved"));
             };
             let key = std::ptr::from_ref(model_asset);
             if !models.contains_key(&key) {
@@ -802,6 +803,8 @@ pub fn build_clip_collision(load: &ZoneLoad) -> Result<crate::ClipCollision, Str
         }
     }
     out.mesh = std::sync::Arc::new(mesh);
+    out.validate(asset_core::AssetNamespace::T6)
+        .map_err(|error| error.to_string())?;
     Ok(out)
 }
 
diff --git a/crates/assets/src/lane/iw4.rs b/crates/assets/src/lane/iw4.rs
index 6939e18..c9f7e0a 100644
--- a/crates/assets/src/lane/iw4.rs
+++ b/crates/assets/src/lane/iw4.rs
@@ -660,6 +660,7 @@ impl ZoneLane for Iw4Lane {
                         fx_glass,
                         map_content,
                         impact_fx,
+                        family_impact_fx: Vec::new(),
                         reflection_probe_images,
                         intermission_view,
                         exp_fog,
diff --git a/crates/assets/src/lane/mod.rs b/crates/assets/src/lane/mod.rs
index 3d0d015..0b8a24e 100644
--- a/crates/assets/src/lane/mod.rs
+++ b/crates/assets/src/lane/mod.rs
@@ -158,6 +158,7 @@ pub(crate) enum CommonDependencyRefusal {
 
 pub(crate) struct CommonPreparationResult {
     pub products: CommonPreparationProducts,
+    pub impact_fx: Option<asset_game::OwnedFxImpactTable>,
     pub refusals: Vec<CommonDependencyRefusal>,
 }
 
diff --git a/crates/assets/src/lane/t5.rs b/crates/assets/src/lane/t5.rs
index 06a9049..b5350c1 100644
--- a/crates/assets/src/lane/t5.rs
+++ b/crates/assets/src/lane/t5.rs
@@ -454,6 +454,7 @@ impl ZoneLane for T5Lane {
                         fx_glass: None,
                         map_content: Default::default(),
                         impact_fx: sink.impact_fx.take_table(),
+                        family_impact_fx: Vec::new(),
                         reflection_probe_images,
                         intermission_view,
                         exp_fog,
diff --git a/crates/assets/src/lane/t6.rs b/crates/assets/src/lane/t6.rs
index 9571bf0..1f7decf 100644
--- a/crates/assets/src/lane/t6.rs
+++ b/crates/assets/src/lane/t6.rs
@@ -48,6 +48,7 @@ struct T6Content {
     pub fx: Vec<asset_game::T6FxCapture>,
     pub fx_materials: BTreeMap<String, T6MaterialCapture>,
     pub camouflages: BTreeMap<String, Vec<asset_game::WeaponCamouflage>>,
+    pub impact_fx: Option<asset_game::OwnedFxImpactTable>,
     pub report: Vec<String>,
 }
 
@@ -1351,10 +1352,52 @@ fn capture_content(
         content.materials.len(),
         ipaks.len()
     ));
+    content.impact_fx = capture_impact_table(&zones);
     capture_effects(&zones, ipaks, &mut content);
     content
 }
 
+const FX_IMPACT_ROWS: u32 = 21;
+const FX_IMPACT_ENTRY: u32 = 144;
+const FX_IMPACT_NONFLESH: u32 = 32;
+const FX_IMPACT_FIRST_EXPLOSION_ROW: usize = 11;
+
+fn capture_impact_table(
+    zones: &[&fastfile_t6::ZoneLoad],
+) -> Option<asset_game::OwnedFxImpactTable> {
+    zones.iter().find_map(|&load| {
+        let asset = load
+            .assets
+            .iter()
+            .find(|asset| asset.ty == fastfile_t6::AssetType::ImpactFx)?;
+        let table = decode_ptr(header_u32(&asset.header, 4)?)?;
+        let name_at = |cell: u32| {
+            load.asset_at(table.at(cell * 4))
+                .and_then(|fx| header_str(load, &fx.header, 0))
+                .unwrap_or_default()
+                .to_owned()
+        };
+        let entries = (0..FX_IMPACT_ROWS)
+            .map(|row| {
+                let first = row * FX_IMPACT_ENTRY / 4;
+                // The 32nd nonflesh surface (riotshield) has no IW4-shaped column.
+                asset_game::OwnedFxImpactEntry {
+                    nonflesh: std::array::from_fn(|surf| name_at(first + surf as u32)),
+                    flesh: std::array::from_fn(|slot| {
+                        name_at(first + FX_IMPACT_NONFLESH + slot as u32)
+                    }),
+                }
+            })
+            .collect();
+        Some(asset_game::OwnedFxImpactTable {
+            namespace: asset_core::AssetNamespace::T6,
+            name: header_str(load, &asset.header, 0)?.to_owned(),
+            entries,
+            capture_gaps: 0,
+        })
+    })
+}
+
 const FX_ELEM_DEF: u32 = 292;
 const FX_ELEM_TYPE: usize = 184;
 const FX_ELEM_VEL_SAMPLES: usize = 188;
@@ -1381,6 +1424,34 @@ fn capture_effects(
         .map(|&name| name.to_owned())
         .collect();
     wanted.insert("maps/mp_maps/fx_mp_exp_bomb".to_owned());
+    if let Some(table) = &content.impact_fx {
+        wanted.extend(
+            table.entries[FX_IMPACT_FIRST_EXPLOSION_ROW..]
+                .iter()
+                .flat_map(|entry| entry.nonflesh.iter().chain(&entry.flesh))
+                .filter(|name| !name.is_empty())
+                .cloned(),
+        );
+    }
+    for &load in zones {
+        for asset in load
+            .assets
+            .iter()
+            .filter(|asset| asset.ty == fastfile_t6::AssetType::Weapon)
+        {
+            let Some(weapon) = fastfile_t6::weapon::WeaponView::new(load, asset) else {
+                continue;
+            };
+            use fastfile_t6::weapon::def;
+            wanted.extend(
+                [def::VIEW_FLASH_EFFECT, def::WORLD_FLASH_EFFECT]
+                    .into_iter()
+                    .filter_map(|off| weapon.def_asset_name(off))
+                    .filter(|name| !name.is_empty())
+                    .map(str::to_owned),
+            );
+        }
+    }
     for load in zones {
         match destructible::effect_names(load) {
             Ok(names) => wanted.extend(names),
@@ -2524,6 +2595,7 @@ impl ZoneLane for T6Lane {
                 path: path.to_owned(),
                 ..Default::default()
             };
+            effect_content.impact_fx = capture_impact_table(&image_loads);
             capture_effects(&image_loads, &ipaks, &mut effect_content);
             let mut fx = asset_game::FxCatalog::default();
             let mut effect_refusals = Vec::new();
diff --git a/crates/assets/src/lane/t6/common_compile.rs b/crates/assets/src/lane/t6/common_compile.rs
index 130e08f..74001cc 100644
--- a/crates/assets/src/lane/t6/common_compile.rs
+++ b/crates/assets/src/lane/t6/common_compile.rs
@@ -27,6 +27,7 @@ impl CommonFamilyCompiler for T6CommonCompiler {
         } = products;
         let t6_captured = self.captured_weapons;
         let mut content = self.content;
+        let impact_fx = content.impact_fx.take();
         let t6_hands = content.hands.clone();
         let (added, kept) = xanims.absorb_vacant(std::mem::take(&mut content.xanims));
         report.push(format!(
@@ -92,6 +93,7 @@ impl CommonFamilyCompiler for T6CommonCompiler {
                 fx: common_fx,
                 report,
             },
+            impact_fx,
             refusals,
         }
     }
diff --git a/crates/assets/src/lib.rs b/crates/assets/src/lib.rs
index 9cf23d1..9956aa1 100644
--- a/crates/assets/src/lib.rs
+++ b/crates/assets/src/lib.rs
@@ -32,8 +32,8 @@ pub use lighting_iw4::MODEL_LIGHTING_TILE_BYTES;
 pub use loading_screen::{LoadingPreviewSource, LoadingScreen};
 pub use map_load_process::MapLoadProcess;
 pub use match_load::{
-    MapLoadApproval, MatchLoadAbort, MatchLoadAccepted, MatchLoadBusy, MatchLoadDispatch,
-    MatchLoadRequest, PreparedMatchReady, PreparedMatchSound,
+    CurrentMatchLoad, MapLoadApproval, MatchLoadAbort, MatchLoadAccepted, MatchLoadBusy,
+    MatchLoadDispatch, MatchLoadRequest, PreparedMatchReady, PreparedMatchSound,
 };
 pub use plugin::AssetPlugin;
 pub use prepared::{
diff --git a/crates/assets/src/match_load.rs b/crates/assets/src/match_load.rs
index e1e1397..5eb196b 100644
--- a/crates/assets/src/match_load.rs
+++ b/crates/assets/src/match_load.rs
@@ -20,6 +20,16 @@ pub struct MatchLoadBusy(pub bool);
 #[derive(Resource, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct MatchLoadAbort(pub u64);
 
+#[derive(Resource, Default)]
+pub struct CurrentMatchLoad(pub Option<frame::LocalLoadKey>);
+
+fn current_load(world: &World, key: frame::LocalLoadKey) -> bool {
+    world.resource::<CurrentMatchLoad>().0 == Some(key)
+        && world
+            .get_resource::<MatchLoadAbort>()
+            .is_none_or(|abort| abort.0 != key.local_load_request_id)
+}
+
 #[derive(Resource)]
 pub struct MatchLoadRequest {
     pub request_id: u64,
@@ -87,7 +97,15 @@ fn start_match_load(
         .is_some_and(|abort| abort.0 == request.request_id)
     {
         *waiting_for_retirement = None;
-        commands.remove_resource::<MatchLoadRequest>();
+        let load_key = request.load_key;
+        commands.queue(move |world: &mut World| {
+            if world
+                .get_resource::<MatchLoadRequest>()
+                .is_some_and(|request| request.load_key == load_key)
+            {
+                world.remove_resource::<MatchLoadRequest>();
+            }
+        });
         if busy.is_none() {
             inflight.0 = false;
         }
@@ -132,7 +150,15 @@ fn start_match_load(
             zone: request.zone.clone(),
             error: error.clone(),
         });
-        commands.remove_resource::<MatchLoadRequest>();
+        let load_key = request.load_key;
+        commands.queue(move |world: &mut World| {
+            if world
+                .get_resource::<MatchLoadRequest>()
+                .is_some_and(|request| request.load_key == load_key)
+            {
+                world.remove_resource::<MatchLoadRequest>();
+            }
+        });
         inflight.0 = false;
         return;
     }
@@ -148,12 +174,12 @@ fn start_match_load(
     // The process outlives the overlay and every task this spawns: it is what
     // the table reads, what admission finishes, and what the bench still has
     // once the screen is gone.
-    commands.insert_resource(MapLoadProcess::new(
-        request_id,
-        load_key,
-        zone.clone(),
-        cancel_handle.clone(),
-    ));
+    let process = MapLoadProcess::new(request_id, load_key, zone.clone(), cancel_handle.clone());
+    commands.queue(move |world: &mut World| {
+        if current_load(world, load_key) {
+            world.insert_resource(process);
+        }
+    });
 
     let families = request.families;
     let games = identity.map(|identity| asset_transport::GamesRoot(identity.games_root.clone()));
@@ -210,6 +236,9 @@ fn start_match_load(
     });
     inflight.0 = true;
     commands.queue(move |world: &mut World| {
+        if !current_load(world, load_key) {
+            return;
+        }
         frame::scope::insert(
             world,
             MatchLoadAccepted {
@@ -222,6 +251,10 @@ fn start_match_load(
         );
     });
     commands.queue(move |world: &mut World| {
+        if !current_load(world, load_key) {
+            cancel_handle.cancel();
+            return;
+        }
         frame::scope::insert(
             world,
             MatchLoadTask {
@@ -234,7 +267,14 @@ fn start_match_load(
             frame::MatchScope::Loading,
         );
     });
-    commands.remove_resource::<MatchLoadRequest>();
+    commands.queue(move |world: &mut World| {
+        if world
+            .get_resource::<MatchLoadRequest>()
+            .is_some_and(|request| request.load_key == load_key)
+        {
+            world.remove_resource::<MatchLoadRequest>();
+        }
+    });
 }
 
 fn approve_map_load(
@@ -246,8 +286,10 @@ fn approve_map_load(
     dvars: Res<frame::UiMenuDvars>,
     server_families: Option<Res<frame::AssetFamilies>>,
     abort: Option<Res<MatchLoadAbort>>,
+    mut current: ResMut<CurrentMatchLoad>,
 ) {
     for request in approved.read() {
+        current.0 = Some(request.load_key);
         if abort
             .as_ref()
             .is_some_and(|abort| abort.0 == request.request_id)
@@ -319,7 +361,7 @@ fn approve_map_load(
         // Its own state, never the live map's: tasks from the request before
         // this one still hold handles, and they must not land in these rows.
         let progress = LoadProgress::new(request.request_id);
-        commands.insert_resource(MatchLoadRequest {
+        let candidate = MatchLoadRequest {
             request_id: request.request_id,
             load_key: request.load_key,
             zone,
@@ -327,6 +369,11 @@ fn approve_map_load(
             common_mp,
             progress,
             families,
+        };
+        commands.queue(move |world: &mut World| {
+            if current_load(world, candidate.load_key) {
+                world.insert_resource(candidate);
+            }
         });
     }
 }
@@ -337,14 +384,16 @@ fn poll_match_load(
     mut inflight: ResMut<MatchLoadBusy>,
     abort: Option<Res<MatchLoadAbort>>,
     mut failed: MessageWriter<MapLoadFailed>,
+    current: Res<CurrentMatchLoad>,
 ) {
     let Some(task) = task.as_deref_mut() else {
         return;
     };
 
-    if abort
-        .as_ref()
-        .is_some_and(|abort| abort.0 == task.request_id)
+    if (current.0 != Some(task.load_key)
+        || abort
+            .as_ref()
+            .is_some_and(|abort| abort.0 == task.request_id))
         && !task.progress.is_canceled()
     {
         task.progress.cancel();
@@ -363,9 +412,25 @@ fn poll_match_load(
         Err(panic) => Err(walk_panic_failure(task, panic.as_ref())),
     };
     let request_id = task.request_id;
+    let load_key = task.load_key;
     inflight.0 = false;
-    commands.remove_resource::<MatchLoadTask>();
-    commands.remove_resource::<MatchLoadAccepted>();
+    commands.queue(move |world: &mut World| {
+        if world
+            .get_resource::<MatchLoadTask>()
+            .is_some_and(|task| task.load_key == load_key)
+        {
+            world.remove_resource::<MatchLoadTask>();
+        }
+        if world
+            .get_resource::<MatchLoadAccepted>()
+            .is_some_and(|accepted| accepted.load_key == load_key)
+        {
+            world.remove_resource::<MatchLoadAccepted>();
+        }
+    });
+    if current.0 != Some(load_key) {
+        return;
+    }
     let outcome = match outcome {
         Ok(ready) => ready,
         Err(error) => {
@@ -414,9 +479,10 @@ fn poll_match_load(
             .unwrap_or_else(|| Err("the map zone never opened".to_owned())),
     };
     commands.queue(move |world: &mut World| {
+        if !current_load(world, ready.load_key) {
+            return;
+        }
         frame::scope::insert(world, map_sound, frame::MatchScope::Loading);
-    });
-    commands.queue(move |world: &mut World| {
         frame::scope::insert(world, ready, frame::MatchScope::Loading);
     });
 }
@@ -454,7 +520,18 @@ fn expire_match_load_abort(
     if task.is_some() || request.is_some() || ready.is_some() {
         return;
     }
-    commands.remove_resource::<MatchLoadAbort>();
+    let request_id = abort.expect("checked abort").0;
+    commands.queue(move |world: &mut World| {
+        if world
+            .get_resource::<MatchLoadAbort>()
+            .is_some_and(|abort| abort.0 == request_id)
+            && !world.contains_resource::<MatchLoadTask>()
+            && !world.contains_resource::<MatchLoadRequest>()
+            && !world.contains_resource::<PreparedMatchReady>()
+        {
+            world.remove_resource::<MatchLoadAbort>();
+        }
+    });
 }
 
 pub fn register_match_load_systems(app: &mut App) {
@@ -465,21 +542,23 @@ pub fn register_match_load_systems(app: &mut App) {
         OnExit(frame::MatchScope::Loading),
         cancel_loading.in_set(frame::ScopeSet::Release),
     );
-    app.init_resource::<MatchLoadBusy>().add_systems(
-        Update,
-        (
-            approve_map_load.in_set(MapLoadApproval),
+    app.init_resource::<CurrentMatchLoad>()
+        .init_resource::<MatchLoadBusy>()
+        .add_systems(
+            Update,
             (
-                start_match_load.run_if(in_state(frame::MatchScope::Loading)),
-                poll_match_load.after(start_match_load),
-                expire_match_load_abort.after(poll_match_load),
+                approve_map_load.in_set(MapLoadApproval),
+                (
+                    start_match_load.run_if(in_state(frame::MatchScope::Loading)),
+                    poll_match_load.after(start_match_load),
+                    expire_match_load_abort.after(poll_match_load),
+                )
+                    .in_set(MatchLoadDispatch)
+                    .after(MapLoadApproval),
             )
-                .in_set(MatchLoadDispatch)
-                .after(MapLoadApproval),
-        )
-            .after(frame::SessionSwapApplied)
-            .in_set(ClientSet::Load),
-    );
+                .after(frame::SessionSwapApplied)
+                .in_set(ClientSet::Load),
+        );
 }
 
 fn cancel_loading(task: Option<Res<MatchLoadTask>>, mut busy: ResMut<MatchLoadBusy>) {
diff --git a/crates/assets/src/prepared.rs b/crates/assets/src/prepared.rs
index 47e265c..03b9fe6 100644
--- a/crates/assets/src/prepared.rs
+++ b/crates/assets/src/prepared.rs
@@ -195,3 +195,133 @@ pub struct SessionCompass {
 
 #[derive(Clone, Copy, Debug, Default, Resource, PartialEq, Eq)]
 pub struct PreparedBodyClips(pub bool);
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DependencyRole {
+    Authority,
+    Presentation,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DependencyImportance {
+    Required,
+    Optional,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PreparedDependency {
+    pub key: String,
+    pub source: String,
+    pub role: DependencyRole,
+    pub importance: DependencyImportance,
+    pub available: bool,
+}
+
+#[derive(Clone, Debug, Resource)]
+pub struct PreparedCapabilities {
+    pub version: u32,
+    pub products: frame::WorldProducts,
+    pub dependencies: Vec<PreparedDependency>,
+    pub script_fx: std::collections::BTreeSet<String>,
+}
+
+impl PreparedCapabilities {
+    pub fn prepare(prepared: &crate::PreparedMatch) -> Self {
+        let mut script_fx = std::collections::BTreeSet::new();
+        let mut dependencies = Vec::new();
+        for namespace in [
+            asset_core::AssetNamespace::Iw4,
+            asset_core::AssetNamespace::Iw5,
+            asset_core::AssetNamespace::T5,
+            asset_core::AssetNamespace::T6,
+        ] {
+            for name in prepared.fx.names() {
+                if prepared.fx.get_in(namespace, name).is_none() {
+                    continue;
+                }
+                let key = format!("{}:{name}", namespace.as_str()).to_ascii_lowercase();
+                script_fx.insert(key.clone());
+                script_fx.insert(name.to_ascii_lowercase());
+                dependencies.push(PreparedDependency {
+                    key,
+                    source: format!("{} effect corpus", namespace.as_str()),
+                    role: DependencyRole::Presentation,
+                    importance: DependencyImportance::Optional,
+                    available: true,
+                });
+            }
+        }
+        for (key, source) in prepared.scripts.fx_references() {
+            let available = script_fx.contains(&key);
+            script_fx.insert(key.clone());
+            dependencies.push(PreparedDependency {
+                key,
+                source,
+                role: DependencyRole::Presentation,
+                importance: DependencyImportance::Optional,
+                available,
+            });
+        }
+        let has_crossbow = (1..=prepared.weapons.len() as u32)
+            .filter_map(|id| prepared.weapons.key_of(id))
+            .any(|key| {
+                key.namespace == asset_core::AssetNamespace::T6 && key.name.contains("crossbow")
+            });
+        if has_crossbow {
+            let effect = "weapon/crossbow/fx_trail_crossbow_blink_grn_os";
+            for (key, available) in [
+                (
+                    format!("t5:{effect}"),
+                    prepared
+                        .fx
+                        .get_in(asset_core::AssetNamespace::T5, effect)
+                        .is_some(),
+                ),
+                (
+                    "t5:wpn_crossbow_alert".into(),
+                    prepared
+                        .script_sound_aliases
+                        .as_ref()
+                        .is_some_and(|aliases| {
+                            aliases
+                                .get("t5:wpn_crossbow_alert")
+                                .is_some_and(|facts| facts.is_some())
+                        }),
+                ),
+            ] {
+                dependencies.push(PreparedDependency {
+                    key,
+                    source: "t6 crossbow warning".into(),
+                    role: DependencyRole::Presentation,
+                    importance: DependencyImportance::Required,
+                    available,
+                });
+            }
+        }
+        Self {
+            version: 1,
+            products: frame::WorldProducts::from_walk(prepared.materials.products_id),
+            dependencies,
+            script_fx,
+        }
+    }
+
+    pub fn validate(&self, role: frame::RuntimeRole) -> Result<(), String> {
+        for dependency in &self.dependencies {
+            let required_role = match dependency.role {
+                DependencyRole::Authority => role.runs_authority(),
+                DependencyRole::Presentation => role.runs_client(),
+            };
+            if required_role
+                && dependency.importance == DependencyImportance::Required
+                && !dependency.available
+            {
+                return Err(format!(
+                    "Required capability {} missing ({})",
+                    dependency.key, dependency.source
+                ));
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/assets/src/script_sources.rs b/crates/assets/src/script_sources.rs
index 0a6afc6..a42fbcb 100644
--- a/crates/assets/src/script_sources.rs
+++ b/crates/assets/src/script_sources.rs
@@ -65,6 +65,70 @@ impl ScriptSources {
         names
     }
 
+    pub(crate) fn fx_references(&self) -> BTreeMap<String, String> {
+        let mut references = BTreeMap::new();
+        for (module, source) in &self.sources {
+            let Ok(bytes) = &source.bytes else {
+                continue;
+            };
+            let mut at = 0;
+            while at < bytes.len() {
+                if bytes[at..].starts_with(b"//") {
+                    while at < bytes.len() && bytes[at] != b'\n' {
+                        at += 1;
+                    }
+                } else if bytes[at..].starts_with(b"/*") {
+                    at += 2;
+                    while at + 1 < bytes.len() && &bytes[at..at + 2] != b"*/" {
+                        at += 1;
+                    }
+                    at = (at + 2).min(bytes.len());
+                } else if bytes[at] == b'"' {
+                    at += 1;
+                    while at < bytes.len() && bytes[at] != b'"' {
+                        at += if bytes[at] == b'\\' { 2 } else { 1 };
+                    }
+                    at = (at + 1).min(bytes.len());
+                } else if bytes[at].is_ascii_alphabetic() || bytes[at] == b'_' {
+                    let start = at;
+                    while at < bytes.len()
+                        && (bytes[at].is_ascii_alphanumeric() || bytes[at] == b'_')
+                    {
+                        at += 1;
+                    }
+                    if !bytes[start..at].eq_ignore_ascii_case(b"loadfx") {
+                        continue;
+                    }
+                    let mut value = at;
+                    while bytes.get(value).is_some_and(u8::is_ascii_whitespace) {
+                        value += 1;
+                    }
+                    if bytes.get(value) != Some(&b'(') {
+                        continue;
+                    }
+                    value += 1;
+                    while bytes.get(value).is_some_and(u8::is_ascii_whitespace) {
+                        value += 1;
+                    }
+                    if bytes.get(value) != Some(&b'"') {
+                        continue;
+                    }
+                    value += 1;
+                    let start = value;
+                    while value < bytes.len() && bytes[value] != b'"' {
+                        value += 1;
+                    }
+                    if let Ok(name) = std::str::from_utf8(&bytes[start..value]) {
+                        references.insert(normalize(name), module.clone());
+                    }
+                } else {
+                    at += 1;
+                }
+            }
+        }
+        references
+    }
+
     pub fn schemas(&self) -> &BTreeMap<String, std::sync::Arc<structured_data_iw4::DefinitionSet>> {
         &self.schemas
     }
diff --git a/crates/assets/src/session_load/common_cache.rs b/crates/assets/src/session_load/common_cache.rs
index 69bff0d..7a66eae 100644
--- a/crates/assets/src/session_load/common_cache.rs
+++ b/crates/assets/src/session_load/common_cache.rs
@@ -7,6 +7,7 @@ pub struct CommonKey {
     pub(super) runtime: Option<PathBuf>,
     pub(super) foreign: Option<PathBuf>,
     source_revision: u64,
+    collision_adapter_version: u32,
     families: frame::AssetFamilies,
 }
 
@@ -20,6 +21,7 @@ impl CommonKey {
         let source_revision = games_root_from_env()
             .map_or(0, |games| asset_transport::installation_revision(&games.0));
         Self {
+            collision_adapter_version: asset_world::COLLISION_ADAPTER_VERSION,
             source_revision,
             runtime: runtime.map(Path::to_path_buf),
             foreign: families
@@ -39,6 +41,7 @@ impl CommonKey {
             }
         };
         Self {
+            collision_adapter_version: asset_world::COLLISION_ADAPTER_VERSION,
             source_revision: asset_transport::installation_revision(&games.0),
             runtime,
             foreign: None,
@@ -107,6 +110,7 @@ pub(super) struct CommonProducts {
     pub(super) t6_player_anim_sources: asset_anim::PlayerAnimSources,
     pub(super) t5_fx: FxCatalog,
     pub(super) t5_impact_fx: Option<asset_game::OwnedFxImpactTable>,
+    pub(super) t6_impact_fx: Option<asset_game::OwnedFxImpactTable>,
     pub(super) iw5_materials: MaterialCatalog,
     pub(super) iw5_scene_models: asset_world::MapXModelSceneCatalog,
     pub(super) iw5_shared_surfaces: asset_model::SharedXModelSurfaces,
@@ -730,6 +734,7 @@ async fn prepare_common(key: CommonKey) -> Arc<CommonSet> {
         t6_weapon_walk.await;
     common_report.extend(t6_report);
     weapons.absorb(t6_weapons);
+    let mut t6_impact_fx = None;
     if let Some(compiler) = preparation {
         let prepared = compiler.compile(crate::lane::CommonPreparationProducts {
             weapons,
@@ -747,6 +752,7 @@ async fn prepare_common(key: CommonKey) -> Arc<CommonSet> {
                 .iter()
                 .map(|cause| format!("common family preparation refused: {cause:?}")),
         );
+        t6_impact_fx = prepared.impact_fx;
         let products = prepared.products;
         common_report.extend(products.report);
         (
@@ -943,6 +949,7 @@ async fn prepare_common(key: CommonKey) -> Arc<CommonSet> {
             t6_player_anim_sources,
             t5_fx,
             t5_impact_fx,
+            t6_impact_fx,
             iw5_materials,
             iw5_scene_models,
             iw5_shared_surfaces,
diff --git a/crates/assets/src/session_load/match_walk.rs b/crates/assets/src/session_load/match_walk.rs
index 58633c3..50b499a 100644
--- a/crates/assets/src/session_load/match_walk.rs
+++ b/crates/assets/src/session_load/match_walk.rs
@@ -98,6 +98,7 @@ pub(super) async fn walk_prepared_match(
         t6_player_anim_sources,
         t5_fx,
         t5_impact_fx,
+        t6_impact_fx,
         iw5_materials,
         mut iw5_scene_models,
         iw5_shared_surfaces,
@@ -720,12 +721,14 @@ pub(super) async fn walk_prepared_match(
             .into(),
     );
     decode_fx_colour_maps(&world.fx, &mut global, &image_trees, &progress, &mut report);
+    world.family_impact_fx = [t5_impact_fx, t6_impact_fx].into_iter().flatten().collect();
     if world.impact_fx.is_none() {
-        world.impact_fx = if map_namespace == Some(asset_core::AssetNamespace::T5) {
-            t5_impact_fx.or(common_impact)
-        } else {
-            common_impact
-        };
+        world.impact_fx = world
+            .family_impact_fx
+            .iter()
+            .find(|table| Some(table.namespace) == map_namespace)
+            .cloned()
+            .or(common_impact);
     } else if let Some(common_table) = common_impact {
         report.push(format!(
             "impactfx: map table kept; common_mp table `{}` discarded",
@@ -743,6 +746,14 @@ pub(super) async fn walk_prepared_match(
     } else {
         report.push("impactfx handoff: missing — combat play_oriented will miss cells".into());
     }
+    for table in &world.family_impact_fx {
+        report.push(format!(
+            "impactfx family table: {:?}:`{}` rows={}",
+            table.namespace,
+            table.name,
+            table.row_count()
+        ));
+    }
     report.push(format!(
         "tracer catalog handoff: {} named ({} bound, {} unresolved)",
         common_tracers.len(),
diff --git a/crates/assets/src/session_load/mod.rs b/crates/assets/src/session_load/mod.rs
index c06c023..39fe412 100644
--- a/crates/assets/src/session_load/mod.rs
+++ b/crates/assets/src/session_load/mod.rs
@@ -129,6 +129,7 @@ pub struct PreparedWorld {
     pub map_content: Arc<asset_core::MapContentDefinition>,
 
     pub impact_fx: Option<asset_game::OwnedFxImpactTable>,
+    pub family_impact_fx: Vec<asset_game::OwnedFxImpactTable>,
     pub reflection_probe_images: Vec<Option<bevy::prelude::Image>>,
     pub intermission_view: Option<IntermissionView>,
 
@@ -215,6 +216,7 @@ impl PreparedWorld {
             fx_glass: Default::default(),
             map_content: Default::default(),
             impact_fx: Default::default(),
+            family_impact_fx: Default::default(),
             reflection_probe_images: Default::default(),
             intermission_view: Default::default(),
             exp_fog: Default::default(),
diff --git a/crates/assets/src/session_load/resident_map.rs b/crates/assets/src/session_load/resident_map.rs
index 4b209e7..2aa20f7 100644
--- a/crates/assets/src/session_load/resident_map.rs
+++ b/crates/assets/src/session_load/resident_map.rs
@@ -76,18 +76,6 @@ pub async fn load_prepared_match(
             return MatchLoadOutcome::Ready(prepared);
         }
     }
-    let dropped = RESIDENT_MAP
-        .lock()
-        .unwrap_or_else(|poison| poison.into_inner())
-        .take();
-    if let Some(dropped) = dropped {
-        diag::info!(
-            World,
-            "resident map: `{}` walk #{} dropped before the next walk",
-            dropped.zone.path.display(),
-            dropped.prepared.materials.products_id
-        );
-    }
     let (outcome, common) =
         walk_prepared_match(zone_ff, common_mp, progress.clone(), families).await;
     let MatchLoadOutcome::Ready(mut prepared) = outcome else {
diff --git a/crates/audio/src/ambient.rs b/crates/audio/src/ambient.rs
index 8fd3947..f7578ab 100644
--- a/crates/audio/src/ambient.rs
+++ b/crates/audio/src/ambient.rs
@@ -12,7 +12,6 @@ use bevy::{
 use crate::backend::AudioScope;
 use crate::playback::SoundBank;
 use crate::sources::{DesiredSource, SourceCueRequest, SourceKey, SourceRenderGroup};
-use frame::{MatchScope, ScopeEpoch};
 
 pub(crate) const MAP_BED_SLOT: u32 = 2;
 const MAP_EMITTER_SLOT: u32 = 3;
@@ -29,7 +28,10 @@ pub struct SoundIwd(pub Arc<NamespaceSoundIwd>);
 pub struct MapAmbientBooted(pub bool);
 
 #[derive(Resource, Default)]
-pub(crate) struct SoundBankLoadAttempted(pub bool);
+pub struct LoadingAudioOwner(pub Option<frame::LocalLoadKey>);
+
+#[derive(Resource, Default)]
+pub(crate) struct SoundBankLoadAttempted(pub Option<frame::LocalLoadKey>);
 
 const SOUND_BANK_COMPOSE_STALL: std::time::Duration = std::time::Duration::from_secs(20);
 
@@ -155,25 +157,29 @@ pub(crate) struct SoundBankNamespace {
 pub(crate) fn start_sound_bank_compose(
     mut attempted: ResMut<SoundBankLoadAttempted>,
     mut status: ResMut<LoadingAudioStatus>,
+    mut owner: ResMut<LoadingAudioOwner>,
     accepted: Option<Res<assets::MatchLoadAccepted>>,
+    current: Res<assets::CurrentMatchLoad>,
     abort: Option<Res<assets::MatchLoadAbort>>,
     identity: Option<Res<frame::LaunchIdentity>>,
     silent: Option<Res<crate::AudioSilent>>,
     resident: Res<ResidentSoundBank>,
     mut commands: Commands,
 ) {
-    if attempted.0 {
-        return;
-    }
-    if silent.is_some() {
-        *status = LoadingAudioStatus::Ready;
-        attempted.0 = true;
-        return;
-    }
     let Some(accepted) = accepted else {
         return;
     };
-    if abort.is_some_and(|abort| abort.0 == accepted.request_id) {
+    if current.0 != Some(accepted.load_key)
+        || abort.is_some_and(|abort| abort.0 == accepted.request_id)
+        || attempted.0 == Some(accepted.load_key)
+    {
+        return;
+    }
+    owner.0 = Some(accepted.load_key);
+    *status = LoadingAudioStatus::Pending;
+    if silent.is_some() {
+        *status = LoadingAudioStatus::Ready;
+        attempted.0 = Some(accepted.load_key);
         return;
     }
     let Some(identity) = identity else {
@@ -182,7 +188,7 @@ pub(crate) fn start_sound_bank_compose(
     if accepted.zone.is_empty() || identity.games_root.as_os_str().is_empty() {
         return;
     }
-    attempted.0 = true;
+    attempted.0 = Some(accepted.load_key);
     let games = GamesRoot(identity.games_root.clone());
     let zone = accepted.zone.clone();
     let opened_zone = zone.clone();
@@ -211,6 +217,9 @@ pub(crate) fn start_sound_bank_compose(
     };
     let load_key = accepted.load_key;
     commands.queue(move |world: &mut World| {
+        if world.resource::<assets::CurrentMatchLoad>().0 != Some(load_key) {
+            return;
+        }
         frame::scope::insert(
             world,
             SoundBankCompose {
@@ -234,6 +243,7 @@ pub(crate) fn install_sound_bank(
     mut compose: Option<ResMut<SoundBankCompose>>,
     identity: Option<Res<frame::LaunchIdentity>>,
     accepted: Option<Res<assets::MatchLoadAccepted>>,
+    current: Res<assets::CurrentMatchLoad>,
     abort: Option<Res<assets::MatchLoadAbort>>,
     mut map_sound: Option<ResMut<assets::PreparedMatchSound>>,
     process: Option<Res<assets::MapLoadProcess>>,
@@ -245,16 +255,25 @@ pub(crate) fn install_sound_bank(
         return;
     };
 
-    let superseded = accepted
-        .as_ref()
-        .is_some_and(|accepted| accepted.load_key != compose.load_key);
+    let superseded = current.0 != Some(compose.load_key)
+        || accepted
+            .as_ref()
+            .is_some_and(|accepted| accepted.load_key != compose.load_key);
     if abort.is_some_and(|abort| abort.0 == compose.load_key.local_load_request_id) || superseded {
         diag::info!(
             Audio,
             "audio: sound bank for `{}` dropped — the session moved on",
             compose.zone
         );
-        commands.remove_resource::<SoundBankCompose>();
+        let load_key = compose.load_key;
+        commands.queue(move |world: &mut World| {
+            if world
+                .get_resource::<SoundBankCompose>()
+                .is_some_and(|compose| compose.load_key == load_key)
+            {
+                world.remove_resource::<SoundBankCompose>();
+            }
+        });
         return;
     }
     // Install on the load key, not `identity.zone`: gating on a display spelling
@@ -282,7 +301,15 @@ pub(crate) fn install_sound_bank(
                 compose.common_profile_id = arrived.common_profile_id;
                 let products_id = arrived.products_id;
                 let map = std::mem::replace(&mut arrived.sound, Err(String::new()));
-                commands.remove_resource::<assets::PreparedMatchSound>();
+                let load_key = compose.load_key;
+                commands.queue(move |world: &mut World| {
+                    if world
+                        .get_resource::<assets::PreparedMatchSound>()
+                        .is_some_and(|sound| sound.load_key == load_key)
+                    {
+                        world.remove_resource::<assets::PreparedMatchSound>();
+                    }
+                });
                 let kept = resident
                     .0
                     .as_ref()
@@ -341,7 +368,15 @@ pub(crate) fn install_sound_bank(
         }
         return;
     };
-    commands.remove_resource::<SoundBankCompose>();
+    let load_key = compose.load_key;
+    commands.queue(move |world: &mut World| {
+        if world
+            .get_resource::<SoundBankCompose>()
+            .is_some_and(|compose| compose.load_key == load_key)
+        {
+            world.remove_resource::<SoundBankCompose>();
+        }
+    });
     let IwdOpen::Open(iwd) = std::mem::replace(&mut compose.iwd, IwdOpen::Open(Arc::default()))
     else {
         unreachable!("the bank is polled only once the archives are open");
@@ -396,10 +431,19 @@ pub(crate) fn install_sound_bank(
                 zone: compose.zone.clone(),
                 namespace,
             };
+            let load_key = compose.load_key;
             commands.queue(move |world: &mut World| {
+                if world.resource::<assets::CurrentMatchLoad>().0 != Some(load_key)
+                    || world
+                        .get_resource::<assets::MatchLoadAbort>()
+                        .is_some_and(|abort| abort.0 == load_key.local_load_request_id)
+                {
+                    return;
+                }
                 frame::scope::insert(
                     world,
                     PreparedMatchAudio {
+                        load_key,
                         iwd: sound_iwd,
                         clips: new_clips,
                         bank: SoundBank(bank),
@@ -428,7 +472,7 @@ pub(crate) fn boot_map_ambient_once(
     identity: Option<Res<frame::LaunchIdentity>>,
     script_sound: Option<Res<asset_audio::SessionMapScriptSound>>,
     namespace: Option<Res<SoundBankNamespace>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     ready: Res<crate::AudioReady>,
     generation: Res<frame::WorldGeneration>,
     runtime: Res<crate::AudioRuntime>,
@@ -495,7 +539,7 @@ pub(crate) fn boot_map_ambient_once(
             alias,
             emitter: None,
             scope: AudioScope::Match,
-            epoch: epoch.0,
+            epoch: crate::backend::presentation_epoch(epoch.as_deref()),
             group,
         }) else {
             continue;
@@ -503,7 +547,7 @@ pub(crate) fn boot_map_ambient_once(
         sources.desired.push(DesiredSource {
             key: SourceKey {
                 scope: AudioScope::Match,
-                epoch: epoch.0,
+                epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                 object,
                 slot,
             },
@@ -538,13 +582,20 @@ pub enum LoadingAudioStatus {
 }
 
 #[derive(Resource)]
-struct PreparedMatchAudio {
+pub struct PreparedMatchAudio {
+    pub load_key: frame::LocalLoadKey,
     iwd: SoundIwd,
     clips: crate::ClipStore,
     bank: SoundBank,
     namespace: SoundBankNamespace,
 }
 
+pub fn prepared_match_audio_key(world: &World) -> Option<frame::LocalLoadKey> {
+    world
+        .get_resource::<PreparedMatchAudio>()
+        .map(|prepared| prepared.load_key)
+}
+
 pub fn stage_prepared_match_audio(world: &mut World) {
     if let Some(prepared) = world.remove_resource::<PreparedMatchAudio>() {
         frame::scope::stage(world, prepared.iwd);
diff --git a/crates/audio/src/backend.rs b/crates/audio/src/backend.rs
index 66e56bd..9a40660 100644
--- a/crates/audio/src/backend.rs
+++ b/crates/audio/src/backend.rs
@@ -4,12 +4,12 @@ use frame::ClientSet;
 pub(crate) use crate::render_core::AudioScope;
 use crate::runtime::AudioRuntime;
 
-use frame::{MatchScope, ScopeEpoch};
+use frame::MatchScope;
 
 pub(crate) fn register(app: &mut App) {
     app.add_systems(
         StateTransition,
-        sync_scope_epoch
+        sync_presentation_epoch
             .in_set(bevy::state::state::StateTransitionSystems::TransitionSchedules)
             .after(frame::scope::ScopeRetired),
     );
@@ -23,24 +23,23 @@ pub(crate) fn register(app: &mut App) {
     app.world()
         .resource::<AudioRuntime>()
         .set_fire_verdicts(verdicts);
-    app.init_resource::<ScopeEpoch<MatchScope>>()
-        .add_systems(
-            Update,
-            publish_audio_context
-                .in_set(ClientSet::Predict)
-                .after(frame::OwnerEventsPublished),
-        )
-        .add_systems(
-            PostUpdate,
-            (
-                submit_presented_audio,
-                cancel_audio_on_exit.after(submit_presented_audio),
-            ),
-        );
+    app.add_systems(
+        Update,
+        publish_audio_context
+            .in_set(ClientSet::Predict)
+            .after(frame::OwnerEventsPublished),
+    )
+    .add_systems(
+        PostUpdate,
+        (
+            submit_presented_audio,
+            cancel_audio_on_exit.after(submit_presented_audio),
+        ),
+    );
 }
 
 pub(crate) fn publish_audio_context(
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     runtime: Res<AudioRuntime>,
     verdicts: Option<Res<net::FireVerdictState>>,
     clips: Option<Res<crate::ClipStore>>,
@@ -59,7 +58,7 @@ pub(crate) fn publish_audio_context(
     if let Some(verdicts) = verdicts {
         runtime.set_fire_verdicts(verdicts.clone());
     }
-    runtime.set_match_epoch(epoch.0);
+    runtime.set_presentation_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     runtime.set_event_context(
         generation
             .and_then(|generation| generation.0)
@@ -109,15 +108,15 @@ pub(crate) fn publish_audio_context(
             .or_else(|| frontend.as_ref().map(|frontend| frontend.clips.service())),
     );
     if let Some(mix) = mix.as_mut() {
-        mix.reset_epoch(epoch.0);
+        mix.reset_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     }
     if let Some(channels) = channels.as_mut() {
-        channels.reset_epoch(epoch.0);
+        channels.reset_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     }
     runtime.set_cue_mix(
         mix.zip(channels)
             .map(|(mix, channels)| crate::cue_execution::CueMix {
-                epoch: epoch.0,
+                epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                 gain: mix.gain.clone(),
                 channels: channels.bindings(),
             }),
@@ -168,17 +167,18 @@ fn cancel_audio_on_exit(mut exit: MessageReader<AppExit>, runtime: Res<AudioRunt
 
 fn submit_presented_audio(
     mut runtime: ResMut<AudioRuntime>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     settings: Option<Res<frame::GameSettings>>,
     listeners: Query<&Transform, With<crate::AmbientListener>>,
     destructibles: Option<Res<crate::destructible_loops::DestructibleSources>>,
     projectiles: Option<Res<crate::projectile_loops::ProjectileSources>>,
+    flames: Option<Res<crate::flame_loops::FlameSources>>,
     map: Option<Res<crate::ambient::MapSources>>,
     menu: Option<Res<crate::frontend::MenuSources>>,
     shellshock: Option<Res<crate::shellshock::ShellshockSources>>,
     breath: Option<Res<crate::breath::BreathSources>>,
 ) {
-    runtime.set_match_epoch(epoch.0);
+    runtime.set_presentation_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     let mut listener = listeners.iter();
     let pose = listener.next();
     assert!(listener.next().is_none(), "more than one ambient listener");
@@ -196,6 +196,9 @@ fn submit_presented_audio(
     if let Some(projectiles) = projectiles {
         desired.extend(projectiles.desired.iter().cloned());
     }
+    if let Some(flames) = flames {
+        desired.extend(flames.desired.iter().cloned());
+    }
     if let Some(map) = map {
         desired.extend(map.desired.iter().cloned());
     }
@@ -211,8 +214,12 @@ fn submit_presented_audio(
     runtime.set_sources(desired);
 }
 
-fn sync_scope_epoch(epoch: Res<ScopeEpoch<MatchScope>>, runtime: Res<AudioRuntime>) {
-    runtime.set_match_epoch(epoch.0);
+pub(crate) fn presentation_epoch(cursor: Option<&net::EntityEventCursor>) -> u64 {
+    cursor.map_or(0, net::EntityEventCursor::timeline)
+}
+
+fn sync_presentation_epoch(epoch: Option<Res<net::EntityEventCursor>>, runtime: Res<AudioRuntime>) {
+    runtime.set_presentation_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
 }
 
 fn release_audio(mut runtime: ResMut<AudioRuntime>) {
diff --git a/crates/audio/src/breath.rs b/crates/audio/src/breath.rs
index 47e8679..977d338 100644
--- a/crates/audio/src/breath.rs
+++ b/crates/audio/src/breath.rs
@@ -33,7 +33,7 @@ pub(crate) fn update(
     mut state: Local<BreathAudio>,
     mut sources: ResMut<BreathSources>,
     runtime: Res<crate::AudioRuntime>,
-    epoch: Res<frame::ScopeEpoch<frame::MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     mut play: MessageWriter<AliasCommand>,
 ) {
     let client = local.as_ref().map(|local| local.0);
@@ -45,9 +45,13 @@ pub(crate) fn update(
             .for_client(client)
             .map(|meta| meta.life_sequence.0)
     });
-    let context = client
-        .zip(life)
-        .map(|(client, life)| (epoch.0, client.0, life));
+    let context = client.zip(life).map(|(client, life)| {
+        (
+            crate::backend::presentation_epoch(epoch.as_deref()),
+            client.0,
+            life,
+        )
+    });
     if sources.context != context {
         if state.active {
             stop_aliases(
@@ -145,7 +149,7 @@ pub(crate) fn update(
                     alias: cues.heartbeat.into(),
                     emitter: client.map(|client| client.0),
                     scope: crate::backend::AudioScope::Match,
-                    epoch: epoch.0,
+                    epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                     group: None,
                 })
             {
@@ -156,7 +160,7 @@ pub(crate) fn update(
                 sources.source = Some(DesiredSource {
                     key: SourceKey {
                         scope: crate::backend::AudioScope::Match,
-                        epoch: epoch.0,
+                        epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                         object: u64::from(client.expect("alive client").0),
                         slot: 6,
                     },
diff --git a/crates/audio/src/destructible_loops.rs b/crates/audio/src/destructible_loops.rs
index 457c26b..799bfe1 100644
--- a/crates/audio/src/destructible_loops.rs
+++ b/crates/audio/src/destructible_loops.rs
@@ -9,7 +9,6 @@ use crate::backend::AudioScope;
 use crate::playback::SoundBank;
 use crate::runtime::AudioRuntime;
 use crate::sources::{DesiredSource, SourceKey};
-use frame::{MatchScope, ScopeEpoch};
 
 struct PresentedLoop {
     alias: String,
@@ -30,12 +29,12 @@ pub(crate) fn update(
     presented: Res<PresentedSnapshot>,
     bank: Option<Res<SoundBank>>,
     namespace: Option<Res<SoundBankNamespace>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     runtime: Res<AudioRuntime>,
     mut sources: ResMut<DestructibleSources>,
 ) {
-    if sources.epoch != epoch.0 {
-        sources.epoch = epoch.0;
+    if sources.epoch != crate::backend::presentation_epoch(epoch.as_deref()) {
+        sources.epoch = crate::backend::presentation_epoch(epoch.as_deref());
         sources.live.clear();
         sources.desired.clear();
     }
@@ -86,7 +85,7 @@ pub(crate) fn update(
                 alias: alias.into(),
                 emitter: row.snd_ent,
                 scope: AudioScope::Match,
-                epoch: epoch.0,
+                epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                 group: None,
             }) else {
                 continue;
@@ -105,7 +104,7 @@ pub(crate) fn update(
                     source: DesiredSource {
                         key: SourceKey {
                             scope: AudioScope::Match,
-                            epoch: epoch.0,
+                            epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                             object: u64::from(owner),
                             slot: 1,
                         },
diff --git a/crates/audio/src/flame_loops.rs b/crates/audio/src/flame_loops.rs
new file mode 100644
index 0000000..391671d
--- /dev/null
+++ b/crates/audio/src/flame_loops.rs
@@ -0,0 +1,187 @@
+use std::collections::HashMap;
+
+use asset_game::WeaponSoundSlot;
+use bevy::prelude::*;
+
+use crate::backend::AudioScope;
+use crate::sources::{DesiredSource, SourceCueRequest, SourceKey};
+use crate::{AudioRuntime, FlameFire, SoundBank, WeaponSound};
+
+const STREAM_GRACE_SECS: f32 = 0.25;
+
+struct FlameStream {
+    weapon: u32,
+    player_view: bool,
+    origin_inches: [f32; 3],
+    last_fire: f32,
+    source: Option<DesiredSource>,
+}
+
+#[derive(Resource, Default)]
+pub(crate) struct FlameSources {
+    context: Option<frame::PresentationContext>,
+    next_version: u64,
+    live: HashMap<u32, FlameStream>,
+    pub desired: Vec<DesiredSource>,
+}
+
+fn slot_pair(
+    player_view: bool,
+    world: WeaponSoundSlot,
+    player: WeaponSoundSlot,
+) -> [WeaponSoundSlot; 2] {
+    if player_view {
+        [player, world]
+    } else {
+        [world, player]
+    }
+}
+
+pub(crate) fn update(
+    mut fires: MessageReader<FlameFire>,
+    weapons: Option<Res<assets::PreparedWeapons>>,
+    presented: Res<net::PresentedSnapshot>,
+    bank: Option<Res<SoundBank>>,
+    time: Res<Time>,
+    timeline: Res<net::EntityEventCursor>,
+    runtime: Res<AudioRuntime>,
+    mut sounds: MessageWriter<WeaponSound>,
+    mut sources: ResMut<FlameSources>,
+    installed: Res<frame::InstalledMatch>,
+) {
+    let context = Some(frame::PresentationContext::new(
+        installed.load_key,
+        timeline.timeline(),
+    ));
+    if sources.context != context {
+        sources.context = context;
+        sources.live.clear();
+    }
+    sources.desired.clear();
+    let (Some(bank), Some(bound)) = (
+        bank,
+        weapons
+            .as_ref()
+            .and_then(|weapons| weapons.for_snapshot(presented.weapon_epoch()).ok()),
+    ) else {
+        fires.clear();
+        sources.live.clear();
+        return;
+    };
+    let weapons = bound.registry();
+    let key = |weapon: u32, slots: [WeaponSoundSlot; 2]| {
+        slots
+            .into_iter()
+            .find_map(|slot| weapons.weapon_sound_key(weapon, slot, &bank.0))
+    };
+    let mut oneshot = |stream: &FlameStream, number: u32, world, player| {
+        let Some((namespace, alias)) =
+            key(stream.weapon, slot_pair(stream.player_view, world, player))
+        else {
+            return;
+        };
+        sounds.write(WeaponSound {
+            event: None,
+            namespace,
+            alias: alias.to_owned(),
+            origin_inches: (!stream.player_view).then_some(stream.origin_inches),
+            snd_ent: Some(number),
+        });
+    };
+    let now = time.elapsed_secs();
+    for fire in fires.read() {
+        let restarted = sources
+            .live
+            .get(&fire.number)
+            .is_none_or(|stream| stream.weapon != fire.weapon);
+        if restarted {
+            let stream = FlameStream {
+                weapon: fire.weapon,
+                player_view: fire.player_view,
+                origin_inches: fire.origin_inches,
+                last_fire: now,
+                source: None,
+            };
+            oneshot(
+                &stream,
+                fire.number,
+                WeaponSoundSlot::FireStart,
+                WeaponSoundSlot::FireStartPlayer,
+            );
+            sources.live.insert(fire.number, stream);
+        }
+        let stream = sources.live.get_mut(&fire.number).expect("flame stream");
+        stream.player_view = fire.player_view;
+        stream.origin_inches = fire.origin_inches;
+        stream.last_fire = now;
+    }
+    let mut ended = Vec::new();
+    for (&number, stream) in &sources.live {
+        if now - stream.last_fire > STREAM_GRACE_SECS {
+            ended.push(number);
+        }
+    }
+    for number in ended {
+        let stream = sources.live.remove(&number).expect("flame stream");
+        oneshot(
+            &stream,
+            number,
+            WeaponSoundSlot::FireStop,
+            WeaponSoundSlot::FireStopPlayer,
+        );
+    }
+    let FlameSources {
+        next_version,
+        live,
+        desired,
+        ..
+    } = &mut *sources;
+    for (&number, stream) in live.iter_mut() {
+        if stream.source.is_none() {
+            let Some((namespace, alias)) = key(
+                stream.weapon,
+                slot_pair(
+                    stream.player_view,
+                    WeaponSoundSlot::FireLoop,
+                    WeaponSoundSlot::FireLoopPlayer,
+                ),
+            ) else {
+                continue;
+            };
+            let Some(cue) = runtime.source_cue(SourceCueRequest {
+                bank: bank.0.clone(),
+                namespace,
+                alias: alias.into(),
+                emitter: Some(number),
+                scope: AudioScope::Match,
+                epoch: timeline.timeline(),
+                group: None,
+            }) else {
+                continue;
+            };
+            *next_version = next_version
+                .checked_add(1)
+                .expect("source version exhausted");
+            stream.source = Some(DesiredSource {
+                key: SourceKey {
+                    scope: AudioScope::Match,
+                    epoch: timeline.timeline(),
+                    object: u64::from(number),
+                    slot: 8,
+                },
+                version: *next_version,
+                cue,
+                origin_inches: None,
+                start_frame: runtime.audio_frame(),
+                gain: 1.0,
+                rate: 1.0,
+                audible: true,
+            });
+        }
+        let Some(source) = stream.source.as_mut() else {
+            continue;
+        };
+        source.origin_inches = (!stream.player_view).then_some(stream.origin_inches);
+        desired.push(source.clone());
+    }
+}
diff --git a/crates/audio/src/frontend.rs b/crates/audio/src/frontend.rs
index 01f972b..f75bae5 100644
--- a/crates/audio/src/frontend.rs
+++ b/crates/audio/src/frontend.rs
@@ -154,7 +154,7 @@ fn play_ui_sound_messages(
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
     frontend: Option<Res<FrontendAudio>>,
-    epoch: Res<frame::ScopeEpoch<frame::MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     namespace: Option<Res<crate::ambient::SoundBankNamespace>>,
 ) {
     let bank = bank
@@ -191,7 +191,7 @@ fn play_ui_sound_messages(
             &mut decisions,
             Some(crate::SND_ENT_LOCAL),
             SoundClass::Ui,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
         );
         if outcome.allows_binding_fallback() {
             gaps.record(&event.alias);
diff --git a/crates/audio/src/lib.rs b/crates/audio/src/lib.rs
index ebd544f..0d776d2 100644
--- a/crates/audio/src/lib.rs
+++ b/crates/audio/src/lib.rs
@@ -24,13 +24,15 @@ pub use aliases::{
     land_aliases, quiet_surface_alias, select_cg_fire_alias, select_fire_alias, step_prefix,
     surface_alias_candidates, world_surface_alias,
 };
-pub use ambient::{MapAmbientBooted, SoundIwd, stage_prepared_match_audio};
+pub use ambient::{
+    MapAmbientBooted, SoundIwd, prepared_match_audio_key, stage_prepared_match_audio,
+};
 pub use clip_store::{ClipPath, ClipPathCost, ClipPrepCost, ClipStore, clip_prep_cost};
 pub use emit::{BobCycleTracker, emit_footstep_on_bob_wrap, emit_weapon_fire};
 pub use frontend::FrontendAudio;
 pub use match_set::{AudioReady, AudioSilent};
 pub use messages::{
-    AliasCommand, BoundWeaponSound, Footstep, LandSound, PlayAlias, SND_ENT_LOCAL,
+    AliasCommand, BoundWeaponSound, FlameFire, Footstep, LandSound, PlayAlias, SND_ENT_LOCAL,
     ViewmodelNotetrack, ViewmodelNotetracks, WeaponSound, ent_from_number,
 };
 pub use playback::{
@@ -43,6 +45,7 @@ pub use start::{
 };
 
 mod destructible_loops;
+mod flame_loops;
 mod match_set;
 mod match_voices;
 mod projectile_loops;
@@ -83,4 +86,4 @@ mod cue_execution;
 mod event;
 pub use event::{AnimationMarkerId, AudioEvent, AudioEventId, AudioOccurrence};
 
-pub use ambient::LoadingAudioStatus;
+pub use ambient::{LoadingAudioOwner, LoadingAudioStatus, PreparedMatchAudio};
diff --git a/crates/audio/src/messages.rs b/crates/audio/src/messages.rs
index 48e8ce4..9edb810 100644
--- a/crates/audio/src/messages.rs
+++ b/crates/audio/src/messages.rs
@@ -51,6 +51,14 @@ pub struct WeaponSound {
     pub snd_ent: Option<u32>,
 }
 
+#[derive(Message, Clone, Debug)]
+pub struct FlameFire {
+    pub number: u32,
+    pub weapon: u32,
+    pub player_view: bool,
+    pub origin_inches: [f32; 3],
+}
+
 #[derive(Message, Clone, Debug)]
 pub struct BoundWeaponSound {
     pub event: Option<crate::AudioEvent>,
diff --git a/crates/audio/src/playback.rs b/crates/audio/src/playback.rs
index 0ceaa01..1eb6732 100644
--- a/crates/audio/src/playback.rs
+++ b/crates/audio/src/playback.rs
@@ -14,7 +14,6 @@ use crate::messages::{
     ViewmodelNotetracks, WeaponSound,
 };
 use crate::start::{SoundClass, StartDecision, StartDecisions, StartFailure, StartOutcome};
-use frame::{MatchScope, ScopeEpoch};
 
 #[derive(Component, Default)]
 pub struct AmbientListener;
@@ -49,6 +48,7 @@ pub(crate) struct PlayerSoundPlugin;
 impl Plugin for PlayerSoundPlugin {
     fn build(&self, app: &mut App) {
         app.scoped::<crate::LoadingAudioStatus>(frame::MatchScope::Loading)
+            .scoped::<crate::LoadingAudioOwner>(frame::MatchScope::Loading)
             .init_resource::<crate::clip_store::ResidentClipCache>()
             .init_resource::<MissingAliasGaps>()
             .init_resource::<StartDecisions>()
@@ -58,6 +58,8 @@ impl Plugin for PlayerSoundPlugin {
             .scoped::<crate::script_ambient::ScriptAmbientPlayback>(frame::MatchScope::Live)
             .scoped::<crate::destructible_loops::DestructibleSources>(frame::MatchScope::Live)
             .scoped::<crate::projectile_loops::ProjectileSources>(frame::Timeline::Running)
+            .scoped::<crate::flame_loops::FlameSources>(frame::Timeline::Running)
+            .scoped_message::<crate::FlameFire>(frame::Timeline::Running)
             .scoped::<crate::ambient::SoundBankLoadAttempted>(frame::MatchScope::Loading)
             .scoped::<crate::ambient::ResidentSoundBank>(frame::MatchScope::Loading)
             .scoped::<crate::BobCycleTracker>(frame::MatchScope::Live)
@@ -113,6 +115,7 @@ impl Plugin for PlayerSoundPlugin {
                     play_land_sound_messages.in_set(frame::InMatch),
                     crate::destructible_loops::update.in_set(frame::InMatch),
                     crate::projectile_loops::update.in_set(frame::InMatch),
+                    crate::flame_loops::update.in_set(frame::InMatch),
                 )
                     .in_set(ClientSet::Effects),
             )
@@ -195,13 +198,16 @@ fn play_alias_messages(
     mut pending: ResMut<CueFeedback>,
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     local: Res<net::LocalPresentClient>,
 ) {
     for command in events.read() {
         let (event, pitch_scale) = match command {
             AliasCommand::StopEntity { snd_ent } => {
-                runtime.stop_emitter_cues(*snd_ent, epoch.0);
+                runtime.stop_emitter_cues(
+                    *snd_ent,
+                    crate::backend::presentation_epoch(epoch.as_deref()),
+                );
                 continue;
             }
             AliasCommand::Play(event) => (event, 1.0),
@@ -212,7 +218,12 @@ fn play_alias_messages(
                 snd_ent,
             } => {
                 let snd_ent = sound_entity(*snd_ent, local.0);
-                runtime.stop_cue(*namespace, alias, snd_ent, epoch.0);
+                runtime.stop_cue(
+                    *namespace,
+                    alias,
+                    snd_ent,
+                    crate::backend::presentation_epoch(epoch.as_deref()),
+                );
                 continue;
             }
         };
@@ -234,7 +245,7 @@ fn play_alias_messages(
             &mut decisions,
             sound_entity(event.snd_ent, local.0),
             SoundClass::World,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
             pitch_scale,
             1.0,
             event.fallback.iter().cloned().collect(),
@@ -250,7 +261,7 @@ fn play_footstep_messages(
     mut pending: ResMut<CueFeedback>,
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
 ) {
     let Some(bank) = bank else {
         drop_without_bank(events.read().map(|e| (e.alias, e.event)), &mut decisions);
@@ -267,7 +278,7 @@ fn play_footstep_messages(
             &mut decisions,
             event.snd_ent,
             SoundClass::World,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
             event.event,
             event.volume_scale,
         );
@@ -285,7 +296,7 @@ fn play_weapon_sound_messages(
     mut pending: ResMut<CueFeedback>,
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
 ) {
     let Some(bank) = bank else {
         drop_without_bank(
@@ -306,7 +317,7 @@ fn play_weapon_sound_messages(
             &mut decisions,
             event.snd_ent,
             SoundClass::Weapon,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
             1.0,
             1.0,
             Vec::new(),
@@ -325,7 +336,7 @@ fn play_bound_weapon_sounds(
     mut pending: ResMut<CueFeedback>,
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     local: Res<net::LocalPresentClient>,
 ) {
     let Some(bank) = bank else {
@@ -353,7 +364,7 @@ fn play_bound_weapon_sounds(
             &mut decisions,
             sound_entity(event.snd_ent, local.0),
             SoundClass::Weapon,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
             1.0,
             1.0,
             Vec::new(),
@@ -372,7 +383,7 @@ fn play_land_sound_messages(
     mut pending: ResMut<CueFeedback>,
     mut decisions: ResMut<StartDecisions>,
     bank: Option<Res<SoundBank>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
 ) {
     let Some(bank) = bank else {
         drop_without_bank(events.read().map(|e| (e.alias, e.event)), &mut decisions);
@@ -389,7 +400,7 @@ fn play_land_sound_messages(
             &mut decisions,
             event.snd_ent,
             SoundClass::World,
-            epoch.0,
+            crate::backend::presentation_epoch(epoch.as_deref()),
             event.event,
             event.volume_scale,
         );
diff --git a/crates/audio/src/projectile_loops.rs b/crates/audio/src/projectile_loops.rs
index cdfe887..08950e5 100644
--- a/crates/audio/src/projectile_loops.rs
+++ b/crates/audio/src/projectile_loops.rs
@@ -1,7 +1,6 @@
 use std::collections::HashMap;
 
 use bevy::prelude::*;
-use frame::{MatchScope, ScopeEpoch};
 
 use crate::backend::AudioScope;
 use crate::sources::{DesiredSource, SourceCueRequest, SourceKey};
@@ -15,7 +14,7 @@ struct ProjectileLoop {
 
 #[derive(Resource, Default)]
 pub(crate) struct ProjectileSources {
-    context: Option<(u64, u64)>,
+    context: Option<frame::PresentationContext>,
     next_version: u64,
     live: HashMap<u32, ProjectileLoop>,
     pub desired: Vec<DesiredSource>,
@@ -27,11 +26,14 @@ pub(crate) fn update(
     bank: Option<Res<SoundBank>>,
     clock: Option<Res<net::FrameClock>>,
     timeline: Res<net::EntityEventCursor>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
     runtime: Res<AudioRuntime>,
     mut sources: ResMut<ProjectileSources>,
+    installed: Res<frame::InstalledMatch>,
 ) {
-    let context = Some((epoch.0, timeline.timeline()));
+    let context = Some(frame::PresentationContext::new(
+        installed.load_key,
+        timeline.timeline(),
+    ));
     if sources.context != context {
         sources.context = context;
         sources.live.clear();
@@ -81,7 +83,7 @@ pub(crate) fn update(
                 alias: alias.into(),
                 emitter: u32::try_from(projectile.entnum).ok(),
                 scope: AudioScope::Match,
-                epoch: epoch.0,
+                epoch: timeline.timeline(),
                 group: None,
             }) else {
                 continue;
@@ -99,7 +101,7 @@ pub(crate) fn update(
                     source: DesiredSource {
                         key: SourceKey {
                             scope: AudioScope::Match,
-                            epoch: epoch.0,
+                            epoch: timeline.timeline(),
                             object: u64::from(id),
                             slot: 7,
                         },
diff --git a/crates/audio/src/render_core.rs b/crates/audio/src/render_core.rs
index f2bbb0d..b073397 100644
--- a/crates/audio/src/render_core.rs
+++ b/crates/audio/src/render_core.rs
@@ -153,7 +153,7 @@ pub(crate) struct RenderShared {
     rendering: AtomicBool,
     state: UnsafeCell<RenderState>,
     pub frame: AtomicU64,
-    pub match_epoch: AtomicU64,
+    pub presentation_epoch: AtomicU64,
     pub master: AtomicU32,
     pub busy_blocks: AtomicU64,
     pub device_active: AtomicBool,
@@ -193,7 +193,7 @@ impl RenderShared {
                 limiter: Default::default(),
             }),
             frame: AtomicU64::new(0),
-            match_epoch: AtomicU64::new(0),
+            presentation_epoch: AtomicU64::new(0),
             master: AtomicU32::new(1.0f32.to_bits()),
             busy_blocks: AtomicU64::new(0),
             device_active: AtomicBool::new(false),
@@ -228,7 +228,7 @@ impl RenderShared {
         // The lease is held until every reference to this state has expired.
         let state = unsafe { &mut *self.state.get() };
         let frame = self.frame.load(Ordering::Relaxed);
-        let epoch = self.match_epoch.load(Ordering::Acquire);
+        let epoch = self.presentation_epoch.load(Ordering::Acquire);
         let cancelled = self.cancelled.load(Ordering::Acquire);
         let hold_one_shots = device == Some(false) && self.device_required.load(Ordering::Relaxed);
         for (index, slot) in self.slots.iter().enumerate() {
diff --git a/crates/audio/src/rumble.rs b/crates/audio/src/rumble.rs
index 42a75ce..d6210f0 100644
--- a/crates/audio/src/rumble.rs
+++ b/crates/audio/src/rumble.rs
@@ -168,7 +168,7 @@ struct ActiveRumble {
 #[derive(Default)]
 struct RumblePlayback {
     owner: Option<(frame::WorldStamp, sim::ClientId, sim::LifeSequence, u64)>,
-    last_time: i32,
+    timeline: u64,
     active: Vec<ActiveRumble>,
     output: Option<(Entity, GamepadRumbleIntensity)>,
     selected: Option<Entity>,
@@ -308,6 +308,7 @@ fn update(
     local: Res<LocalPresentClient>,
     generation: Res<frame::WorldGeneration>,
     time: Res<Time>,
+    cursor: Option<Res<net::EntityEventCursor>>,
     devices: Res<frame::InputDevices>,
     mut tests: MessageReader<frame::TestControllerRumble>,
     gamepads: Query<Entity, With<Gamepad>>,
@@ -316,6 +317,15 @@ fn update(
     settings: Res<frame::GameSettings>,
     active: Option<Res<frame::ActivePad>>,
 ) {
+    let timeline = crate::backend::presentation_epoch(cursor.as_deref());
+    if state.timeline != timeline {
+        state.active.clear();
+        if let Some((gamepad, _)) = state.output.take() {
+            output.write(GamepadRumbleRequest::Stop { gamepad });
+        }
+        state.timeline = timeline;
+        state.next_refresh_ms = 0;
+    }
     let now = (time.elapsed_secs_f64() * 1000.0) as i32;
     let selected = active
         .and_then(|active| active.0)
@@ -347,14 +357,13 @@ fn update(
             bank.0.revision(),
         ))
     });
-    if owner != state.owner || now < state.last_time {
+    if owner != state.owner {
         state.active.clear();
         if let Some((gamepad, _)) = state.output.take() {
             output.write(GamepadRumbleRequest::Stop { gamepad });
         }
         state.owner = owner;
     }
-    state.last_time = now;
     state
         .active
         .retain(|row| now.saturating_sub(row.start) < row.rumble.duration_ms);
diff --git a/crates/audio/src/runtime.rs b/crates/audio/src/runtime.rs
index d996862..b94d50d 100644
--- a/crates/audio/src/runtime.rs
+++ b/crates/audio/src/runtime.rs
@@ -198,8 +198,10 @@ impl AudioRuntime {
         self.shared.master.store(gain.to_bits(), Ordering::Release);
     }
 
-    pub fn set_match_epoch(&self, epoch: u64) {
-        self.shared.match_epoch.store(epoch, Ordering::Release);
+    pub fn set_presentation_epoch(&self, epoch: u64) {
+        self.shared
+            .presentation_epoch
+            .store(epoch, Ordering::Release);
         self.source_publisher
             .lock()
             .unwrap_or_else(|poison| poison.into_inner())
@@ -224,7 +226,7 @@ impl AudioRuntime {
             .unwrap_or_else(|poison| poison.into_inner())
             .reconcile(
                 sources,
-                self.shared.match_epoch.load(Ordering::Acquire),
+                self.shared.presentation_epoch.load(Ordering::Acquire),
                 self.shared.cancelled.load(Ordering::Acquire),
             );
         self.sources.dropped.fetch_add(rejected, Ordering::Relaxed);
@@ -544,7 +546,7 @@ fn control(
         {
             desired = scene;
         }
-        let epoch = shared.match_epoch.load(Ordering::Acquire);
+        let epoch = shared.presentation_epoch.load(Ordering::Acquire);
         desired.sources.retain(|source| {
             !shared.cancelled.load(Ordering::Acquire)
                 && (source.key.scope != AudioScope::Match || source.key.epoch == epoch)
@@ -670,7 +672,7 @@ fn control(
         });
 
         let diag_stage = crate::diagnostics::slow_stage("null_and_reclaim", diag_stage);
-        resolver.retain_epoch(shared.match_epoch.load(Ordering::Acquire));
+        resolver.retain_epoch(shared.presentation_epoch.load(Ordering::Acquire));
         for _ in 0..CONTROL_BATCH {
             let Ok(request) = cue_rx.try_recv() else {
                 break;
@@ -679,7 +681,7 @@ fn control(
             // Validate a newly received cue against the latest published clocks.
             events.advance(event_context.get());
             if request.scope == AudioScope::Match
-                && request.epoch != shared.match_epoch.load(Ordering::Acquire)
+                && request.epoch != shared.presentation_epoch.load(Ordering::Acquire)
             {
                 request.reject(CueFailure::StaleScope);
             } else if crate::event::EventJournal::fire_refused(
@@ -709,7 +711,7 @@ fn control(
             let mut work = pending_cues.pop_front().expect("pending cue");
             if shared.cancelled.load(Ordering::Acquire)
                 || (work.request.scope == AudioScope::Match
-                    && work.request.epoch != shared.match_epoch.load(Ordering::Acquire))
+                    && work.request.epoch != shared.presentation_epoch.load(Ordering::Acquire))
             {
                 work.complete(crate::StartOutcome::Failed(
                     crate::StartFailure::CueRefused(if shared.cancelled.load(Ordering::Acquire) {
@@ -885,7 +887,7 @@ fn control(
         apply_source_render_budget(&instances);
         instances.sort_by_key(|logical| logical.source.is_some());
         let now = shared.frame.load(Ordering::Acquire);
-        let epoch = shared.match_epoch.load(Ordering::Acquire);
+        let epoch = shared.presentation_epoch.load(Ordering::Acquire);
 
         instances.retain_mut(|logical| {
             let instance = &logical.request.instance;
@@ -1283,7 +1285,7 @@ fn admit(
     {
         Some(AdmissionFailure::Cancelled)
     } else if request.instance.scope == AudioScope::Match
-        && request.instance.epoch != shared.match_epoch.load(Ordering::Acquire)
+        && request.instance.epoch != shared.presentation_epoch.load(Ordering::Acquire)
     {
         Some(AdmissionFailure::StaleScope)
     } else if instances.len() == LOGICAL_INSTANCES {
diff --git a/crates/audio/src/script_ambient.rs b/crates/audio/src/script_ambient.rs
index ee5f71d..dc30cb5 100644
--- a/crates/audio/src/script_ambient.rs
+++ b/crates/audio/src/script_ambient.rs
@@ -14,7 +14,7 @@ pub(crate) struct ScriptAmbientPlayback {
 }
 
 pub(crate) fn update_script_ambient(
-    epoch: Res<frame::ScopeEpoch<frame::MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     ready: Res<crate::AudioReady>,
     generation: Res<frame::WorldGeneration>,
     loading: Option<Res<assets::LoadingScreen>>,
@@ -27,8 +27,8 @@ pub(crate) fn update_script_ambient(
     mut map: Option<ResMut<MapSources>>,
     mut feedback: ResMut<crate::clip_store::CueFeedback>,
 ) {
-    if playback.epoch != epoch.0 {
-        playback.epoch = epoch.0;
+    if playback.epoch != crate::backend::presentation_epoch(epoch.as_deref()) {
+        playback.epoch = crate::backend::presentation_epoch(epoch.as_deref());
         playback.target = None;
         playback.started = false;
         playback.voices.clear();
@@ -109,7 +109,7 @@ pub(crate) fn update_script_ambient(
             origin_inches: None,
             emitter: None,
             class: SoundClass::Ambience,
-            epoch: epoch.0,
+            epoch: crate::backend::presentation_epoch(epoch.as_deref()),
             pitch_scale: 1.0,
             volume_scale: 1.0,
             fallbacks: Vec::new(),
diff --git a/crates/audio/src/script_mix.rs b/crates/audio/src/script_mix.rs
index adb081c..cb0a0ad 100644
--- a/crates/audio/src/script_mix.rs
+++ b/crates/audio/src/script_mix.rs
@@ -3,7 +3,6 @@ use asset_audio::ChannelKey;
 use asset_core::AssetNamespace;
 use bevy::prelude::*;
 use frame::ScopeApp;
-use frame::{MatchScope, ScopeEpoch};
 use std::{collections::HashMap, sync::Arc};
 
 #[derive(Resource, Default)]
@@ -166,11 +165,11 @@ fn update_channel_mix(
     bank: Option<Res<crate::SoundBank>>,
     namespace: Option<Res<crate::ambient::SoundBankNamespace>>,
     local: Option<Res<net::LocalPresentClient>>,
-    epoch: Res<ScopeEpoch<MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     runtime: Res<crate::AudioRuntime>,
 ) {
     let now = runtime.audio_frame();
-    mix.reset_epoch(epoch.0);
+    mix.reset_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     for event in events.read() {
         if event.0.target().is_some() {
             mix.pending.push_back(event.0.clone());
diff --git a/crates/audio/src/script_music.rs b/crates/audio/src/script_music.rs
index aa44fc3..209a71e 100644
--- a/crates/audio/src/script_music.rs
+++ b/crates/audio/src/script_music.rs
@@ -12,7 +12,7 @@ pub(crate) struct ScriptMusicPlayback {
 }
 
 pub(crate) fn update_script_music(
-    epoch: Res<frame::ScopeEpoch<frame::MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
     ready: Res<crate::AudioReady>,
     generation: Res<frame::WorldGeneration>,
     runtime: Res<crate::AudioRuntime>,
@@ -23,7 +23,7 @@ pub(crate) fn update_script_music(
     mut mix: ResMut<crate::script_mix::ScriptAudioMix>,
     mut feedback: ResMut<crate::clip_store::CueFeedback>,
 ) {
-    mix.reset_epoch(epoch.0);
+    mix.reset_epoch(crate::backend::presentation_epoch(epoch.as_deref()));
     if playback
         .active
         .as_ref()
@@ -81,7 +81,7 @@ pub(crate) fn update_script_music(
         origin_inches: None,
         emitter: None,
         class: SoundClass::Music,
-        epoch: epoch.0,
+        epoch: crate::backend::presentation_epoch(epoch.as_deref()),
         pitch_scale: 1.0,
         volume_scale: 1.0,
         fallbacks: Vec::new(),
diff --git a/crates/audio/src/shellshock.rs b/crates/audio/src/shellshock.rs
index 66aac1f..7ea8f4b 100644
--- a/crates/audio/src/shellshock.rs
+++ b/crates/audio/src/shellshock.rs
@@ -25,7 +25,7 @@ pub(crate) fn update_shellshock_tinnitus(
     runtime: Res<crate::AudioRuntime>,
     mut sources: ResMut<ShellshockSources>,
     mut play: MessageWriter<crate::AliasCommand>,
-    epoch: Res<frame::ScopeEpoch<frame::MatchScope>>,
+    epoch: Option<Res<net::EntityEventCursor>>,
 ) {
     let local_id = local.as_ref().map(|l| l.0.0);
     let life = local.as_ref().and_then(|local| {
@@ -51,7 +51,11 @@ pub(crate) fn update_shellshock_tinnitus(
         sources.was_active = false;
         return;
     };
-    let context = (epoch.0, local.0.0, life.unwrap_or(0));
+    let context = (
+        crate::backend::presentation_epoch(epoch.as_deref()),
+        local.0.0,
+        life.unwrap_or(0),
+    );
     if sources.context != Some(context) {
         sources.source = None;
         sources.was_active = false;
@@ -87,7 +91,7 @@ pub(crate) fn update_shellshock_tinnitus(
                     alias: parms.loop_alias.clone(),
                     emitter: Some(local.0.0),
                     scope: crate::backend::AudioScope::Match,
-                    epoch: epoch.0,
+                    epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                     group: None,
                 })
             {
@@ -98,7 +102,7 @@ pub(crate) fn update_shellshock_tinnitus(
                 sources.source = Some(DesiredSource {
                     key: SourceKey {
                         scope: crate::backend::AudioScope::Match,
-                        epoch: epoch.0,
+                        epoch: crate::backend::presentation_epoch(epoch.as_deref()),
                         object: u64::from(local.0.0),
                         slot: 5,
                     },
diff --git a/crates/bootstrap/src/launch.rs b/crates/bootstrap/src/launch.rs
index 001ef6e..227939c 100644
--- a/crates/bootstrap/src/launch.rs
+++ b/crates/bootstrap/src/launch.rs
@@ -222,7 +222,7 @@ fn install_class_catalog(
         if key.contains('+')
             && asset_core::AssetKey::parse(key)
                 .is_ok_and(|key| key.namespace == asset_core::AssetNamespace::Iw4)
-            && menus.material_images.contains_key(&preview.image)
+            && menus.material_images().contains_key(&preview.image)
         {
             preview.image = format!("iw4:material/{}", preview.image);
         }
@@ -735,6 +735,7 @@ fn run_map(
         .insert_resource(cheats)
         .insert_resource(probe)
         .insert_resource(menus)
+        .insert_resource(assets::CurrentMatchLoad(Some(Default::default())))
         .insert_resource(MatchLoadRequest {
             request_id: 0,
             load_key: Default::default(),
diff --git a/crates/fastfile_iw4/src/lib.rs b/crates/fastfile_iw4/src/lib.rs
index ed1b71c..c3b1b7e 100644
--- a/crates/fastfile_iw4/src/lib.rs
+++ b/crates/fastfile_iw4/src/lib.rs
@@ -21,9 +21,9 @@ pub use envelope::{
     MAGIC_UNSIGNED, Signing, ZONE_VERSION_PC, parse_file_header,
 };
 pub use load::{
-    AssetLinkSink, FontCapture, GlyphCapture, MenuChoiceValue, MenuDefCapture, MenuItemLayout,
-    MenuRectCapture, MenuScriptKind, load_asset_at, load_asset_at_observed, load_asset_at_with,
-    load_asset_body,
+    AssetLinkSink, FontCapture, GlyphCapture, ItemExpressionField, MenuChoiceValue, MenuDefCapture,
+    MenuItemLayout, MenuRectCapture, MenuScriptKind, load_asset_at, load_asset_at_observed,
+    load_asset_at_with, load_asset_body,
 };
 pub use stream::{
     alloc_stream_pos, convert_offset_to_alias, convert_offset_to_pointer, inc_stream_pos,
diff --git a/crates/fastfile_iw4/src/load/menu.rs b/crates/fastfile_iw4/src/load/menu.rs
index 6373746..5f0bcfb 100644
--- a/crates/fastfile_iw4/src/load/menu.rs
+++ b/crates/fastfile_iw4/src/load/menu.rs
@@ -1,6 +1,6 @@
 use asset_iw4::size as sz;
 
-use super::{AssetLinkSink, asset_ptr_at, asset_ptr_at_linked, follow_name};
+use super::{AssetLinkSink, ItemExpressionField, asset_ptr_at, asset_ptr_at_linked, follow_name};
 use crate::asset_type::AssetType;
 use crate::zone::{Ptr, Result, XFILE_BLOCK_VIRTUAL, ZonePtr, ZoneStream};
 
@@ -911,7 +911,7 @@ fn load_event_handler(
                 let c = s.alloc_load(4, s.layout(sz::CONDITIONAL_SCRIPT, 16))?;
                 let mut condition_buf = [0u8; ITEM_STATEMENT_DUMP];
                 let mut condition_len = 0;
-                capture_expr_body_or_alias(s, c, s.layout(4, 8), cache, |dump| {
+                capture_expr_body_or_alias(s, c, s.layout(4, 8), cache, |_source, dump| {
                     condition_len = copy_into(dump, &mut condition_buf).len();
                 })?;
                 let condition = core::str::from_utf8(&condition_buf[..condition_len]).unwrap_or("");
@@ -933,7 +933,7 @@ fn load_event_handler(
                 let name = copy_into(string_at(s, v, 0), &mut name_buf);
 
                 let mut captured = Ok(());
-                capture_expr_body_or_alias(s, v, s.layout(4, 8), cache, |expr| {
+                capture_expr_body_or_alias(s, v, s.layout(4, 8), cache, |_source, expr| {
                     captured = links.capture_menu_set_local_var(menu, item, kind, t, name, expr);
                 })?;
                 captured?;
@@ -1110,21 +1110,51 @@ fn load_item_def(
         for i in 0..float_expression_count {
             let e = arr.at(i * s.layout(sz::ITEM_FLOAT_EXPRESSION, 16));
             let key = s.u32_at(e, 0).unwrap_or(0);
-            capture_expr_body_or_alias(s, e, s.layout(4, 8), cache, |dump| {
+            capture_expr_body_or_alias(s, e, s.layout(4, 8), cache, |source, dump| {
+                let _ = links.capture_item_expression_reference(
+                    menu_name,
+                    item_name,
+                    ItemExpressionField::Float(key),
+                    source,
+                );
                 let _ = links.capture_item_float_exp(menu_name, item_name, key, dump);
             })?;
         }
     }
-    capture_expr_body_or_alias(s, p, s.layout(324, 416), cache, |dump| {
-        let _ = links.capture_item_visible_exp(menu_name, item_name, dump);
+    capture_expr_body_or_alias(s, p, s.layout(324, 416), cache, |source, dump| {
+        let _ = links.capture_item_expression_reference(
+            menu_name,
+            item_name,
+            ItemExpressionField::Visible,
+            source,
+        );
+        let _ = links.capture_item_visible_reference(menu_name, item_name, source, dump);
     })?;
-    capture_expr_body_or_alias(s, p, s.layout(328, 424), cache, |dump| {
+    capture_expr_body_or_alias(s, p, s.layout(328, 424), cache, |source, dump| {
+        let _ = links.capture_item_expression_reference(
+            menu_name,
+            item_name,
+            ItemExpressionField::Disabled,
+            source,
+        );
         let _ = links.capture_item_disabled_exp(menu_name, item_name, dump);
     })?;
-    capture_expr_body_or_alias(s, p, s.layout(332, 432), cache, |dump| {
+    capture_expr_body_or_alias(s, p, s.layout(332, 432), cache, |source, dump| {
+        let _ = links.capture_item_expression_reference(
+            menu_name,
+            item_name,
+            ItemExpressionField::Text,
+            source,
+        );
         let _ = links.capture_item_text_exp(menu_name, item_name, dump);
     })?;
-    capture_expr_body_or_alias(s, p, s.layout(336, 440), cache, |dump| {
+    capture_expr_body_or_alias(s, p, s.layout(336, 440), cache, |source, dump| {
+        let _ = links.capture_item_expression_reference(
+            menu_name,
+            item_name,
+            ItemExpressionField::Material,
+            source,
+        );
         let _ = links.capture_item_material_exp(menu_name, item_name, dump);
     })?;
     Ok(())
@@ -1135,24 +1165,27 @@ fn capture_expr_body_or_alias(
     parent: Ptr,
     field: usize,
     cache: &mut StatementCache,
-    mut on_dump: impl FnMut(&str),
+    mut on_dump: impl FnMut(Ptr, &str),
 ) -> Result<()> {
     if s.begin_body(parent.at(field))? {
         let mut buf = [0u8; ITEM_STATEMENT_DUMP];
-        let dump = dump_item_statement(s, &mut buf, cache)?;
-        if !dump.is_empty() {
-            on_dump(dump);
-        }
+        let mut dump = ExpDump {
+            buf: &mut buf,
+            used: 0,
+        };
+        let source = load_statement_rec(s, &mut dump, cache)?;
+        cache.insert(source, dump.as_str());
+        s.expr_stmt_insert(source, dump.as_str());
+        s.fixup_slot(parent.at(field), source)?;
+        on_dump(source, dump.as_str());
         return Ok(());
     }
-    let Ok(ZonePtr::Offset(stmt)) = s.ptr_at(parent, field) else {
+    let ZonePtr::Offset(stmt) = s.ptr_at(parent, field)? else {
         return Ok(());
     };
     let body = s.resolve_alias(stmt);
     if let Some(cached) = s.expr_stmt_get(body).or_else(|| cache.get(body)) {
-        if !cached.is_empty() {
-            on_dump(cached);
-        }
+        on_dump(body, cached);
         return Ok(());
     }
     let mut buf = [0u8; ITEM_STATEMENT_DUMP];
@@ -1160,9 +1193,12 @@ fn capture_expr_body_or_alias(
         buf: &mut buf,
         used: 0,
     };
-    let _ = dump_loaded_statement(s, body, &mut dump, cache, 0, None);
+    dump_loaded_statement(s, body, &mut dump, cache, 0, None)?;
+    if dump.used == 0 || dump.as_str().contains("fnmiss") {
+        return Err(crate::ZoneError::UnresolvedPointer(body));
+    }
     if dump.used > 0 {
-        on_dump(dump.as_str());
+        on_dump(body, dump.as_str());
     }
     Ok(())
 }
diff --git a/crates/fastfile_iw4/src/load/mod.rs b/crates/fastfile_iw4/src/load/mod.rs
index abaa6e3..2447d13 100644
--- a/crates/fastfile_iw4/src/load/mod.rs
+++ b/crates/fastfile_iw4/src/load/mod.rs
@@ -159,6 +159,15 @@ fn load_asset_body_observed(
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ItemExpressionField {
+    Visible,
+    Disabled,
+    Text,
+    Material,
+    Float(u32),
+}
+
 pub trait AssetLinkSink {
     fn loaded(
         &mut self,
@@ -264,6 +273,28 @@ pub trait AssetLinkSink {
         Ok(())
     }
 
+    fn capture_item_expression_reference(
+        &mut self,
+        menu: &str,
+        item: &str,
+        field: ItemExpressionField,
+        source: Ptr,
+    ) -> Result<()> {
+        let _ = (menu, item, field, source);
+        Ok(())
+    }
+
+    fn capture_item_visible_reference(
+        &mut self,
+        menu: &str,
+        item: &str,
+        source: Ptr,
+        dump: &str,
+    ) -> Result<()> {
+        let _ = source;
+        self.capture_item_visible_exp(menu, item, dump)
+    }
+
     fn capture_item_visible_exp(&mut self, menu: &str, item: &str, dump: &str) -> Result<()> {
         let _ = (menu, item, dump);
         Ok(())
diff --git a/crates/fastfile_t5/src/lib.rs b/crates/fastfile_t5/src/lib.rs
index e1e4157..ad07787 100644
--- a/crates/fastfile_t5/src/lib.rs
+++ b/crates/fastfile_t5/src/lib.rs
@@ -30,13 +30,13 @@ pub use size::{
 };
 pub use zone::{
     ALIGN_WASTE_SITE_COUNT, AlignWasteSite, AlignWasteStats, BLOCK_STACK_CAP, BlockType,
-    ClipMapGeometry, ComWorldGeometry, FxEffectDefGeometry, GfxImageGeometry, GfxLightGridGeometry,
-    GfxLightmapImages, GfxWorldGeometry, MAX_LIGHTMAP_PAGES, MAX_XFILE_COUNT, MapEntsGeometry,
-    MaterialGeometry, PTR_SIZE, Ptr, Result, ShaderGeometry, TECHNIQUE_ARGUMENT_CAP,
-    TECHNIQUE_PASS_ROW_CAP, TechniqueArgumentGeometry, TechniqueGraphGeometry,
-    TechniquePassGeometry, TechniqueSetGeometry, VertexDeclGeometry, WeaponGeometry,
-    XAnimPartsGeometry, XFILE_BLOCK_LARGE, XFILE_BLOCK_LARGE_RUNTIME, XFILE_BLOCK_PHYSICAL,
-    XFILE_BLOCK_PHYSICAL_RUNTIME, XFILE_BLOCK_RUNTIME, XFILE_BLOCK_TEMP, XFILE_BLOCK_VIRTUAL,
-    XFILE_HEADER_LEN, XModelGeometry, ZoneError, ZoneHeader, ZonePtr, ZoneStream,
-    block_is_aliasable, parse_zone_header,
+    ClipMapGeometry, ComWorldGeometry, FLAME_TABLE_MATERIAL_COUNT, FxEffectDefGeometry,
+    GfxImageGeometry, GfxLightGridGeometry, GfxLightmapImages, GfxWorldGeometry,
+    MAX_LIGHTMAP_PAGES, MAX_XFILE_COUNT, MapEntsGeometry, MaterialGeometry, PTR_SIZE, Ptr, Result,
+    ShaderGeometry, TECHNIQUE_ARGUMENT_CAP, TECHNIQUE_PASS_ROW_CAP, TechniqueArgumentGeometry,
+    TechniqueGraphGeometry, TechniquePassGeometry, TechniqueSetGeometry, VertexDeclGeometry,
+    WeaponGeometry, XAnimPartsGeometry, XFILE_BLOCK_LARGE, XFILE_BLOCK_LARGE_RUNTIME,
+    XFILE_BLOCK_PHYSICAL, XFILE_BLOCK_PHYSICAL_RUNTIME, XFILE_BLOCK_RUNTIME, XFILE_BLOCK_TEMP,
+    XFILE_BLOCK_VIRTUAL, XFILE_HEADER_LEN, XModelGeometry, ZoneError, ZoneHeader, ZonePtr,
+    ZoneStream, block_is_aliasable, parse_zone_header,
 };
diff --git a/crates/fastfile_t5/src/load/material.rs b/crates/fastfile_t5/src/load/material.rs
index 5dffc72..27969da 100644
--- a/crates/fastfile_t5/src/load/material.rs
+++ b/crates/fastfile_t5/src/load/material.rs
@@ -328,6 +328,7 @@ pub(super) fn load_material(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSin
         surface_type_bits: s.u32_at(p, 0x18)?,
         layered_surface_types: s.u32_at(p, 0x1c)?,
         sort_key: s.u8_at(p, 9)?,
+        texture_atlas: [s.u8_at(p, 10)?, s.u8_at(p, 11)?],
         info_game_flags: s.u8_at(p, sz::MATERIAL_INFO_GAME_FLAGS_OFF)?,
         state_flags: s.u8_at(p, sz::MATERIAL_STATE_FLAGS_OFF)?,
         camera_region: s.u8_at(p, sz::MATERIAL_CAMERA_REGION_OFF)?,
diff --git a/crates/fastfile_t5/src/load/weapon.rs b/crates/fastfile_t5/src/load/weapon.rs
index 8b8e416..7229bb6 100644
--- a/crates/fastfile_t5/src/load/weapon.rs
+++ b/crates/fastfile_t5/src/load/weapon.rs
@@ -1,7 +1,10 @@
 use super::{AssetLinkSink, asset_ptr_at, follow_name, load_asset_at_observed};
 use crate::asset_type::AssetType;
 use crate::size as sz;
-use crate::zone::{Ptr, Result, WeaponGeometry, XFILE_BLOCK_VIRTUAL, ZonePtr, ZoneStream};
+use crate::zone::{
+    FLAME_TABLE_MATERIAL_COUNT, Ptr, Result, WeaponGeometry, XFILE_BLOCK_VIRTUAL, ZonePtr,
+    ZoneStream,
+};
 
 pub(super) fn load_weapon(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink) -> Result<()> {
     let p = s.alloc_load(4, sz::WEAPON_VARIANT_DEF)?;
@@ -19,6 +22,14 @@ pub(super) fn load_weapon(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink)
                     kill_icon: material_name_at(s, links, body.at(sz::WEAPON_DEF_KILL_ICON_OFF)),
                     reticle_center: material_name_at(s, links, body.at(0x1a0)),
                     reticle_side: material_name_at(s, links, body.at(0x1a4)),
+                    flame_materials: [0x7f0, 0x7f4].map(|off| match s.ptr_at(body, off) {
+                        Ok(ZonePtr::Offset(t)) => {
+                            let table = s.resolve_alias(t);
+                            FLAME_TABLE_MATERIAL_OFFS
+                                .map(|m| material_name_at(s, links, table.at(m)))
+                        }
+                        _ => [None; FLAME_TABLE_MATERIAL_COUNT],
+                    }),
                     ..WeaponAssets::default()
                 },
             )
@@ -71,6 +82,7 @@ pub(super) fn load_weapon(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink)
         overlay_material_lowres_name,
         reticle_center_name: assets.reticle_center,
         reticle_side_name: assets.reticle_side,
+        flame_material_names: assets.flame_materials,
         alternate_weapon_name,
         alternate_raise_time_ms: s.i32_at(p, 0x3c)?,
         alternate_drop_time_ms: weap_def
@@ -208,15 +220,21 @@ fn load_weapon_def(
         follow_name(s, p, off)?;
     }
 
-    if s.begin_body(p.at(0x7f0))? {
-        let ft = s.alloc_load(4, sz::FLAME_TABLE)?;
-        s.fixup_slot(p.at(0x7f0), ft)?;
-        load_flame_table(s, links, ft)?;
-    }
-    if s.begin_body(p.at(0x7f4))? {
-        let ft = s.alloc_load(4, sz::FLAME_TABLE)?;
-        s.fixup_slot(p.at(0x7f4), ft)?;
-        load_flame_table(s, links, ft)?;
+    let mut flame_materials = [[None; FLAME_TABLE_MATERIAL_COUNT]; 2];
+    for (view, off) in [0x7f0, 0x7f4].into_iter().enumerate() {
+        flame_materials[view] = if s.begin_body(p.at(off))? {
+            let ft = s.alloc_load(4, sz::FLAME_TABLE)?;
+            s.fixup_slot(p.at(off), ft)?;
+            load_flame_table(s, links, ft)?
+        } else {
+            match s.ptr_at(p, off)? {
+                ZonePtr::Offset(t) => {
+                    let table = s.resolve_alias(t);
+                    FLAME_TABLE_MATERIAL_OFFS.map(|m| material_name_at(s, links, table.at(m)))
+                }
+                _ => [None; FLAME_TABLE_MATERIAL_COUNT],
+            }
+        };
     }
 
     asset_ptr_at(s, links, AssetType::Fx, p.at(0x7f8))?;
@@ -230,6 +248,7 @@ fn load_weapon_def(
         world: world0,
         reticle_center,
         reticle_side,
+        flame_materials,
     })
 }
 
@@ -336,15 +355,23 @@ fn follow_xmodel_ptr(
         }))
 }
 
-fn load_flame_table(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink, p: Ptr) -> Result<()> {
+const FLAME_TABLE_MATERIAL_OFFS: [usize; FLAME_TABLE_MATERIAL_COUNT] =
+    [0x1ac, 0x1b0, 0x1b4, 0x1b8, 0x1bc, 0x1c0, 0x1c4, 0x1c8];
+
+fn load_flame_table(
+    s: &mut ZoneStream<'_>,
+    links: &mut dyn AssetLinkSink,
+    p: Ptr,
+) -> Result<[Option<Ptr>; FLAME_TABLE_MATERIAL_COUNT]> {
     follow_name(s, p, 0x1a8)?;
-    for off in [0x1ac, 0x1b0, 0x1b4, 0x1b8, 0x1bc, 0x1c0, 0x1c4, 0x1c8] {
-        asset_ptr_at(s, links, AssetType::Material, p.at(off))?;
+    let mut names = [None; FLAME_TABLE_MATERIAL_COUNT];
+    for (name, off) in names.iter_mut().zip(FLAME_TABLE_MATERIAL_OFFS) {
+        *name = follow_material_name(s, links, p.at(off))?;
     }
     for off in [0x1cc, 0x1d0, 0x1d4, 0x1d8] {
         follow_name(s, p, off)?;
     }
-    Ok(())
+    Ok(names)
 }
 
 #[derive(Clone, Copy, Debug, Default)]
@@ -408,4 +435,5 @@ struct WeaponAssets {
     world: Option<Ptr>,
     reticle_center: Option<Ptr>,
     reticle_side: Option<Ptr>,
+    flame_materials: [[Option<Ptr>; FLAME_TABLE_MATERIAL_COUNT]; 2],
 }
diff --git a/crates/fastfile_t5/src/size.rs b/crates/fastfile_t5/src/size.rs
index 127b2a6..f12740b 100644
--- a/crates/fastfile_t5/src/size.rs
+++ b/crates/fastfile_t5/src/size.rs
@@ -582,6 +582,8 @@ pub const WEAPON_DEF_SND_RELOAD_START_OFF: usize = 0xf8;
 pub const WEAPON_DEF_SND_RELOAD_START_PLAYER_OFF: usize = 0xfc;
 pub const WEAPON_DEF_SND_RELOAD_END_OFF: usize = 0x100;
 pub const WEAPON_DEF_SND_RELOAD_END_PLAYER_OFF: usize = 0x104;
+pub const WEAPON_DEF_SND_ALT_SWITCH_OFF: usize = 0x148;
+pub const WEAPON_DEF_SND_ALT_SWITCH_PLAYER_OFF: usize = 0x14c;
 pub const WEAPON_DEF_SND_RAISE_PLAYER_OFF: usize = 0x154;
 pub const WEAPON_DEF_SND_PUTAWAY_PLAYER_OFF: usize = 0x164;
 pub const WEAPON_DEF_AMMO_COUNTER_CLIP_OFF: usize = 0x338;
@@ -592,6 +594,16 @@ pub const WEAPON_DEF_AMMO_COUNT_CLIP_RELATIVE_OFF: usize = 0x359;
 
 pub const WEAPON_DEF_SHOT_COUNT_OFF: usize = 0x348;
 pub const WEAPON_DEF_DAMAGE_OFF: usize = 0x35c;
+pub const WEAPON_DEF_DAMAGE_INTERVAL_OFF: usize = 0x364;
+pub const WEAPON_DEF_FUEL_TANK_WEAPON_OFF: usize = 0x61;
+pub const WEAPON_DEF_TANK_LIFE_TIME_OFF: usize = 0x64;
+pub const WEAPON_DEF_FLAME_TABLE_FIRST_PERSON_OFF: usize = 0x7f0;
+pub const WEAPON_DEF_FLAME_TABLE_THIRD_PERSON_OFF: usize = 0x7f4;
+pub const FLAME_TABLE_STREAM_FUEL_LENGTH_OFF: usize = 0xa8;
+pub const FLAME_TABLE_STREAM_FLAME_LENGTH_OFF: usize = 0xbc;
+pub const FLAME_TABLE_IGNITE_SOUND_OFF: usize = 0x1d0;
+pub const FLAME_TABLE_ON_LOOP_SOUND_OFF: usize = 0x1d4;
+pub const FLAME_TABLE_COOLDOWN_SOUND_OFF: usize = 0x1d8;
 
 pub const WEAPON_DEF_FIRE_DELAY_OFF: usize = 0x378;
 pub const WEAPON_DEF_MELEE_DAMAGE_OFF: usize = 0x36c;
diff --git a/crates/fastfile_t5/src/zone.rs b/crates/fastfile_t5/src/zone.rs
index 5601047..3dec211 100644
--- a/crates/fastfile_t5/src/zone.rs
+++ b/crates/fastfile_t5/src/zone.rs
@@ -382,6 +382,8 @@ pub struct FxEffectDefGeometry {
     pub elem_def_count: usize,
 }
 
+pub const FLAME_TABLE_MATERIAL_COUNT: usize = 8;
+
 #[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct WeaponGeometry {
     pub kill_icon_name: Option<Ptr>,
@@ -389,6 +391,9 @@ pub struct WeaponGeometry {
     pub overlay_material_lowres_name: Option<Ptr>,
     pub reticle_center_name: Option<Ptr>,
     pub reticle_side_name: Option<Ptr>,
+    /// Material names of the first- and third-person flame tables, in
+    /// `FlameTable` order: fire, smoke, heat, drips, fuel, fuel2, flame, flame2.
+    pub flame_material_names: [[Option<Ptr>; FLAME_TABLE_MATERIAL_COUNT]; 2],
     pub name: Option<Ptr>,
     pub alternate_weapon_name: Option<Ptr>,
     pub alternate_raise_time_ms: i32,
@@ -632,6 +637,7 @@ pub struct MaterialGeometry {
     pub surface_type_bits: u32,
     pub layered_surface_types: u32,
     pub sort_key: u8,
+    pub texture_atlas: [u8; 2],
 
     pub info_game_flags: u8,
 
diff --git a/crates/fastfile_t6/src/weapon.rs b/crates/fastfile_t6/src/weapon.rs
index 549a09a..6eae72b 100644
--- a/crates/fastfile_t6/src/weapon.rs
+++ b/crates/fastfile_t6/src/weapon.rs
@@ -50,6 +50,8 @@ pub mod def {
     pub const FIRE_TYPE: u32 = 48;
     pub const OFFHAND_CLASS: u32 = 96;
     pub const OFFHAND_SLOT: u32 = 100;
+    pub const VIEW_FLASH_EFFECT: u32 = 108;
+    pub const WORLD_FLASH_EFFECT: u32 = 112;
     pub const PULLBACK_SOUND: u32 = 168;
     pub const PULLBACK_SOUND_PLAYER: u32 = 172;
     pub const FIRE_SOUND: u32 = 176;
@@ -62,6 +64,8 @@ pub mod def {
     pub const MELEE_SWIPE_SOUND_PLAYER: u32 = 252;
     pub const MELEE_HIT_SOUND: u32 = 256;
     pub const MELEE_MISS_SOUND: u32 = 260;
+    pub const ALT_SWITCH_SOUND: u32 = 376;
+    pub const ALT_SWITCH_SOUND_PLAYER: u32 = 380;
     pub const RAISE_SOUND: u32 = 384;
     pub const RAISE_SOUND_PLAYER: u32 = 388;
     pub const FIRST_RAISE_SOUND: u32 = 392;
diff --git a/crates/frame/src/lib.rs b/crates/frame/src/lib.rs
index 16f0f36..22fba79 100644
--- a/crates/frame/src/lib.rs
+++ b/crates/frame/src/lib.rs
@@ -35,8 +35,9 @@ pub use session::{
     DisplayEncodedCamera, Headless, HostClassLoadouts, HostClassSlot, HudDraw, HudInputView,
     InstalledMatch, LaunchIdentity, LaunchReport, LifeEndCause, LifeEnded, LifeStartReason,
     LifeStarted, LocalLoadKey, LocalSpawnArmed, MapLoadApproved, MapLoadFailed, MatchKey,
-    ReadinessState, RuntimeRole, TeardownReason, UiCamera, UiDraw, UiOverlayInput, UiPointerFree,
-    ViewSubject, WorldGeneration, WorldProducts, WorldReadiness, WorldStamp,
+    PresentationContext, ReadinessState, RuntimeRole, TeardownReason, UiCamera, UiDraw,
+    UiOverlayInput, UiPointerFree, ViewSubject, WorldGeneration, WorldProducts, WorldReadiness,
+    WorldStamp,
 };
 pub use settings::{DisplayResolution, GameSettings, OtherGame};
 pub use ui::{
diff --git a/crates/frame/src/scope.rs b/crates/frame/src/scope.rs
index 56324f4..dbc28bb 100644
--- a/crates/frame/src/scope.rs
+++ b/crates/frame/src/scope.rs
@@ -240,12 +240,6 @@ fn retire_state<S: States>(
         }
         world.resource_mut::<ScopeEpoch<S>>().0 =
             world.resource::<ScopeEpoch<S>>().0.wrapping_add(1);
-        // Match-epoch consumers (audio voices) must also drop what a restarted
-        // timeline played.
-        if TypeId::of::<S>() == TypeId::of::<Timeline>() {
-            world.resource_mut::<ScopeEpoch<MatchScope>>().0 =
-                world.resource::<ScopeEpoch<MatchScope>>().0.wrapping_add(1);
-        }
         if !actions.is_empty() {
             world.resource_mut::<crate::Retiring>().mark_teardown();
             let mut registry = world.resource_mut::<ScopeRegistry>();
diff --git a/crates/frame/src/session.rs b/crates/frame/src/session.rs
index 6cfa2c0..ec6b2ed 100644
--- a/crates/frame/src/session.rs
+++ b/crates/frame/src/session.rs
@@ -239,6 +239,21 @@ impl LocalLoadKey {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct PresentationContext {
+    pub installation: LocalLoadKey,
+    pub timeline: u64,
+}
+
+impl PresentationContext {
+    pub fn new(installation: LocalLoadKey, timeline: u64) -> Self {
+        Self {
+            installation,
+            timeline,
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub struct AdmissionKey {
     pub match_key: MatchKey,
diff --git a/crates/fx/src/elem.rs b/crates/fx/src/elem.rs
index 9a54166..cd1f189 100644
--- a/crates/fx/src/elem.rs
+++ b/crates/fx/src/elem.rs
@@ -15,6 +15,7 @@ pub struct FxElemSlot {
     pub visual_count: u8,
     pub sequence: u8,
     pub at_rest_fraction: u8,
+    pub supported_since_ms: Option<i32>,
 
     pub emit_residual: u8,
     pub next_elem_handle: u16,
@@ -51,6 +52,7 @@ impl Default for FxElemSlot {
             visual_count: 0,
             sequence: 0,
             at_rest_fraction: FX_ELEM_AT_REST_NONE,
+            supported_since_ms: None,
             emit_residual: 0,
             next_elem_handle: FX_ELEM_HANDLE_NONE,
             prev_elem_handle: FX_ELEM_HANDLE_NONE,
diff --git a/crates/fx/src/motion.rs b/crates/fx/src/motion.rs
index e5a63fa..1b3c899 100644
--- a/crates/fx/src/motion.rs
+++ b/crates/fx/src/motion.rs
@@ -65,6 +65,7 @@ pub fn evaluate_elem_collide_motion(
             base_vel: q.base_vel,
             remove: false,
             at_rest_fraction: Some(q.at_rest_fraction),
+            supported_since_ms: q.supported_since_ms,
             spawn_impact: None,
         });
     }
@@ -107,6 +108,7 @@ pub fn evaluate_elem_collide_motion(
                 effect_axis: q.effect_axis,
                 orient: q.orient,
                 at_rest_fraction: q.at_rest_fraction,
+                supported_since_ms: q.supported_since_ms,
             };
             let free = integrate_free_flight(
                 flags,
@@ -127,6 +129,9 @@ pub fn evaluate_elem_collide_motion(
                 orientation_pos_to_world(q.orient.origin, q.orient.axis, end_local),
             );
             let hit = trace(start, end, coll_mins, coll_maxs, mask);
+            if !hit.complete {
+                return None;
+            }
             if hit.allsolid || (hit.startsolid && !leaves_start_solid) {
                 base_vel = [0.0; 3];
                 break;
@@ -222,6 +227,7 @@ pub fn evaluate_elem_collide_motion(
         base_vel,
         remove,
         at_rest_fraction,
+        supported_since_ms: None,
         spawn_impact,
     })
 }
@@ -241,12 +247,20 @@ pub fn evaluate_elem_physics_motion(
     q: FxElemMotionQuery<'_>,
     mut trace: impl FnMut([f32; 3], [f32; 3], [f32; 3], [f32; 3], u32) -> FxElemTraceHit,
 ) -> FxElemMotionResult {
-    let mut landed = (q.at_rest_fraction != FX_ELEM_AT_REST_NONE).then_some(q.at_rest_fraction);
+    let mut landed = (q.at_rest_fraction != FX_ELEM_AT_REST_NONE && q.base_vel == [0.0; 3])
+        .then_some(q.at_rest_fraction);
+    let mut supported_since =
+        if q.at_rest_fraction != FX_ELEM_AT_REST_NONE && q.base_vel != [0.0; 3] {
+            None
+        } else {
+            q.supported_since_ms
+        };
     let mut result = FxElemMotionResult {
         origin_delta: [0.0; 3],
         base_vel: q.base_vel,
         remove: false,
         at_rest_fraction: landed,
+        supported_since_ms: q.supported_since_ms,
         spawn_impact: None,
     };
     if landed.is_some() && q.base_vel == [0.0; 3] {
@@ -279,20 +293,39 @@ pub fn evaluate_elem_physics_motion(
             pos[2] + vel[2] * dt,
         ];
         let hit = trace(pos, end, mins, maxs, mask);
+        if !hit.complete {
+            result.remove = true;
+            return result;
+        }
         if hit.allsolid {
-            vel = [0.0; 3];
+            supported_since = None;
             match lift_out_of_solid(pos, mins, maxs, mask, &mut trace) {
                 Some(lifted) => {
                     pos = lifted;
                     continue;
                 }
                 None => {
-                    landed.get_or_insert(at_rest_byte(step.msec_start, q.msec_begin, q.life_ms));
+                    result.remove = true;
                     break;
                 }
             }
         }
         if hit.fraction >= 1.0 {
+            if supported_since.is_some()
+                && vec3_length_sq(vel) < FX_PHYS_REST_SPEED * FX_PHYS_REST_SPEED
+            {
+                let support = trace(end, [end[0], end[1], end[2] - 0.5], mins, maxs, mask);
+                if !support.complete
+                    || support.allsolid
+                    || support.startsolid
+                    || support.fraction >= 1.0
+                    || !collide_on_ground(support.normal[2])
+                {
+                    supported_since = None;
+                }
+            } else {
+                supported_since = None;
+            }
             pos = end;
             continue;
         }
@@ -302,6 +335,9 @@ pub fn evaluate_elem_physics_motion(
             pos[2] + (end[2] - pos[2]) * hit.fraction,
         ];
         let n = hit.normal;
+        for (position, normal) in pos.iter_mut().zip(n) {
+            *position += normal * FX_PHYS_CONTACT_SLOP;
+        }
         let into = dot(vel, n);
         if into < 0.0 {
             let push = (1.0 + FX_PHYS_BOUNCE) * into;
@@ -314,12 +350,16 @@ pub fn evaluate_elem_physics_motion(
                 *v = normal_part + (*v - normal_part) * (1.0 - FX_PHYS_FRICTION);
             }
         }
-        if collide_on_ground(n[2]) {
-            landed.get_or_insert(at_rest_byte(step.msec_end, q.msec_begin, q.life_ms));
-            if vec3_length_sq(vel) < FX_PHYS_REST_SPEED * FX_PHYS_REST_SPEED {
+        if collide_on_ground(n[2]) && vec3_length_sq(vel) < FX_PHYS_REST_SPEED * FX_PHYS_REST_SPEED
+        {
+            let since = *supported_since.get_or_insert(step.msec_start);
+            if step.msec_end.saturating_sub(since) >= 200 {
+                landed = Some(at_rest_byte(step.msec_end, q.msec_begin, q.life_ms));
                 vel = [0.0; 3];
                 break;
             }
+        } else {
+            supported_since = None;
         }
     }
     let stored = orientation_pos_from_world(q.orient.origin, q.orient.axis, pos);
@@ -330,6 +370,7 @@ pub fn evaluate_elem_physics_motion(
     ];
     result.base_vel = vel;
     result.at_rest_fraction = landed;
+    result.supported_since_ms = supported_since;
     result
 }
 
@@ -345,7 +386,7 @@ fn lift_out_of_solid(
     while dz <= cap {
         let lifted = [pos[0], pos[1], pos[2] + dz];
         let probe = trace(lifted, lifted, mins, maxs, mask);
-        if !probe.startsolid && !probe.allsolid {
+        if probe.complete && !probe.startsolid && !probe.allsolid {
             return Some(lifted);
         }
         dz *= 2.0;
@@ -422,6 +463,7 @@ fn integrate_free_flight(
         base_vel,
         remove: false,
         at_rest_fraction: None,
+        supported_since_ms: None,
         spawn_impact: None,
     }
 }
diff --git a/crates/fx/src/spawn.rs b/crates/fx/src/spawn.rs
index 1b53444..92b995c 100644
--- a/crates/fx/src/spawn.rs
+++ b/crates/fx/src/spawn.rs
@@ -506,6 +506,7 @@ fn spawn_elem(
         visual_count: elem_def.visual_count,
         sequence,
         at_rest_fraction: FX_ELEM_AT_REST_NONE,
+        supported_since_ms: None,
         emit_residual: 0,
         next_elem_handle: prev_head,
         prev_elem_handle: FX_ELEM_HANDLE_NONE,
diff --git a/crates/fx/src/update.rs b/crates/fx/src/update.rs
index da5efa5..7f786bc 100644
--- a/crates/fx/src/update.rs
+++ b/crates/fx/src/update.rs
@@ -48,6 +48,7 @@ pub struct FxElemMotionQuery<'a> {
     pub orient: fx_iw4::FxOrientation,
 
     pub at_rest_fraction: u8,
+    pub supported_since_ms: Option<i32>,
 }
 
 #[derive(Clone, Debug)]
@@ -70,6 +71,7 @@ pub struct PendingCollide {
     effect_axis: [[f32; 3]; 3],
     orient: fx_iw4::FxOrientation,
     at_rest_fraction: u8,
+    supported_since_ms: Option<i32>,
 }
 
 impl PendingCollide {
@@ -92,6 +94,7 @@ impl PendingCollide {
             effect_axis: self.effect_axis,
             orient: self.orient,
             at_rest_fraction: self.at_rest_fraction,
+            supported_since_ms: self.supported_since_ms,
         }
     }
 }
@@ -104,6 +107,7 @@ pub struct FxElemMotionResult {
     pub remove: bool,
 
     pub at_rest_fraction: Option<u8>,
+    pub supported_since_ms: Option<i32>,
 
     pub spawn_impact: Option<FxImpactSpawn>,
 }
@@ -138,6 +142,7 @@ pub struct FxChildSpawnRequest<'a> {
 
 #[derive(Clone, Copy, Debug)]
 pub struct FxElemTraceHit {
+    pub complete: bool,
     pub fraction: f32,
     pub normal: [f32; 3],
     pub startsolid: bool,
@@ -424,6 +429,7 @@ fn pending_collide_for_elem(
         effect_axis: now.axis,
         orient,
         at_rest_fraction: elem.at_rest_fraction,
+        supported_since_ms: elem.supported_since_ms,
     })
 }
 
@@ -620,6 +626,7 @@ fn update_element(
     let elem_type = elem.elem_type;
     let spark_handle = elem.spark_cloud_handle;
     let at_rest_fraction = elem.at_rest_fraction;
+    let supported_since_ms = elem.supported_since_ms;
     let (def_name, catalog_index, now, alt, products, mark_entity) =
         match host.effect_at(effect_slot) {
             Some(e) => (
@@ -672,6 +679,7 @@ fn update_element(
         effect_axis: now.axis,
         orient,
         at_rest_fraction,
+        supported_since_ms,
     };
     match collide_cache
         .get(&handle)
@@ -687,9 +695,10 @@ fn update_element(
             if let Some(elem) = host.elems.get_mut(slot) {
                 elem.origin = origin_end;
                 elem.base_vel = result.base_vel;
-                if let Some(frac) = result.at_rest_fraction {
-                    elem.at_rest_fraction = frac;
-                }
+                elem.at_rest_fraction = result
+                    .at_rest_fraction
+                    .unwrap_or(fx_iw4::FX_ELEM_AT_REST_NONE);
+                elem.supported_since_ms = result.supported_since_ms;
             }
             let emit_residual = host.elems.get(slot).map(|e| e.emit_residual).unwrap_or(0);
             if let Some(sched) = on_emit(FxEmitQuery {
diff --git a/crates/hud/src/chrome.rs b/crates/hud/src/chrome.rs
index 3224ab4..a5c7955 100644
--- a/crates/hud/src/chrome.rs
+++ b/crates/hud/src/chrome.rs
@@ -288,7 +288,10 @@ pub(crate) fn item_screen_rects(
     };
     let mut out = Vec::new();
     for (index, item) in menu.items.iter().enumerate() {
-        if !matches!(exprs.is_true(&item.vis_exp, host), Ok(true)) {
+        if !matches!(
+            exprs.is_true_source(item.visibility_expression, &item.vis_exp, host),
+            Ok(true)
+        ) {
             continue;
         }
         let Ok(style) = evaluate_item_style(
@@ -333,7 +336,7 @@ fn paint_item(
     owner_draw: Option<&mut dyn FnMut(OwnerDrawArgs<'_>, &mut ChromeFrame) -> OwnerDrawPaint>,
     frame: &mut ChromeFrame,
 ) {
-    match exprs.is_true(&item.vis_exp, host) {
+    match exprs.is_true_source(item.visibility_expression, &item.vis_exp, host) {
         Ok(false) => {
             frame.coverage.vis_false();
             return;
@@ -835,7 +838,11 @@ fn resolved_material(
     exprs: &mut MenuExprCache,
 ) -> Result<Option<String>, ExprError> {
     if !item.material_exp.is_empty() {
-        let name = exprs.evaluate_string(&item.material_exp, host)?;
+        let name = exprs.string_source(
+            item.expression_ids.get("Material").copied(),
+            &item.material_exp,
+            host,
+        )?;
         if name.is_empty() {
             return Ok(background_stem(background.unwrap_or(&item.background)));
         }
@@ -901,7 +908,11 @@ fn evaluate_item_style(
             style.unsupported.get_or_insert(key);
             continue;
         }
-        let value = match exprs.evaluate_float(dump, host) {
+        let value = match exprs.float_source(
+            item.expression_ids.get(&format!("Float({key})")).copied(),
+            dump,
+            host,
+        ) {
             Ok(value) => value,
             Err(err) if key <= FLOAT_RECT_H => return Err(err),
             Err(_) => {
@@ -973,7 +984,7 @@ pub(crate) fn atlas_frame_st(
     let [rows, columns] = catalog
         .and_then(|catalog| {
             catalog
-                .material_2d_plans
+                .material_2d_plans()
                 .get(&material.to_ascii_lowercase())
         })
         .map(|plan| plan.texture_atlas.map(|n| u32::from(n.max(1))))
diff --git a/crates/hud/src/expr_cache.rs b/crates/hud/src/expr_cache.rs
index 3a156ed..0524bff 100644
--- a/crates/hud/src/expr_cache.rs
+++ b/crates/hud/src/expr_cache.rs
@@ -5,6 +5,7 @@ use hud_iw4::{ExprError, ExprHost, Statement};
 #[derive(Resource, Default)]
 pub(crate) struct MenuExprCache {
     by_dump: HashMap<String, Result<Statement, ExprError>>,
+    by_source: HashMap<asset_game::ExpressionId, Result<Statement, ExprError>>,
 }
 
 impl MenuExprCache {
@@ -20,6 +21,46 @@ impl MenuExprCache {
         }
     }
 
+    fn source_statement(
+        &mut self,
+        id: Option<asset_game::ExpressionId>,
+        dump: &str,
+    ) -> Result<&Statement, ExprError> {
+        let Some(id) = id else {
+            return self.statement(dump);
+        };
+        let parsed = self
+            .by_source
+            .entry(id)
+            .or_insert_with(|| Statement::parse(dump));
+        parsed.as_ref().map_err(Clone::clone)
+    }
+
+    pub(crate) fn is_true_source(
+        &mut self,
+        id: Option<asset_game::ExpressionId>,
+        dump: &str,
+        host: &impl ExprHost,
+    ) -> Result<bool, ExprError> {
+        self.source_statement(id, dump)?.is_true(host)
+    }
+    pub(crate) fn float_source(
+        &mut self,
+        id: Option<asset_game::ExpressionId>,
+        dump: &str,
+        host: &impl ExprHost,
+    ) -> Result<f32, ExprError> {
+        self.source_statement(id, dump)?.evaluate_float(host)
+    }
+    pub(crate) fn string_source(
+        &mut self,
+        id: Option<asset_game::ExpressionId>,
+        dump: &str,
+        host: &impl ExprHost,
+    ) -> Result<String, ExprError> {
+        self.source_statement(id, dump)?.evaluate_string(host)
+    }
+
     pub(crate) fn is_true(&mut self, dump: &str, host: &impl ExprHost) -> Result<bool, ExprError> {
         self.statement(dump)?.is_true(host)
     }
diff --git a/crates/hud/src/images.rs b/crates/hud/src/images.rs
index b7625d9..b542b53 100644
--- a/crates/hud/src/images.rs
+++ b/crates/hud/src/images.rs
@@ -72,7 +72,7 @@ pub(crate) struct BloodMaterialBinding {
 fn blood_material_binding(catalog: &MenuCatalog) -> Result<BloodMaterialBinding, String> {
     let pass = "splatter_alt/unlit/pass 0";
     let plan = catalog
-        .material_2d_plans
+        .material_2d_plans()
         .get("splatter_alt")
         .ok_or_else(|| format!("{pass}: material plan missing"))?;
     if plan.unlit_pass_count != Some(1) || plan.unlit_pass_states.len() != 1 {
@@ -152,7 +152,7 @@ pub struct HudImages {
     zone_samplers: HashMap<String, u8>,
     blood_plan: Option<Result<BloodMaterialBinding, String>>,
     zone_installed: bool,
-    zone_identity: Option<u64>,
+    zone_identity: Option<asset_game::ImageProductRevision>,
     zone_uploaded: bool,
     iwd_warmed: bool,
 }
@@ -235,7 +235,9 @@ impl HudImages {
     }
 
     pub fn install_zone_catalog(&mut self, catalog: &MenuCatalog) {
-        let identity = catalog.image_identity();
+        let identity = catalog
+            .image_revision()
+            .unwrap_or_else(|| asset_game::ImageProductRevision(catalog.image_identity()));
         if self.zone_identity == Some(identity) {
             return;
         }
@@ -246,17 +248,17 @@ impl HudImages {
         self.blood_plan = Some(blood_material_binding(catalog));
         self.zone_srgb_reads.extend(
             catalog
-                .material_srgb_reads
+                .material_srgb_reads()
                 .iter()
                 .map(|(name, &srgb)| (cache_key(name), srgb)),
         );
         self.material_images.extend(
             catalog
-                .material_images
+                .material_images()
                 .iter()
                 .map(|(material, image)| (cache_key(material), image.clone())),
         );
-        for (name, plan) in &catalog.material_2d_plans {
+        for (name, plan) in catalog.material_2d_plans() {
             let binding =
                 plan.textures
                     .iter()
@@ -268,13 +270,13 @@ impl HudImages {
                         })
                     });
             if let Some(binding) = binding
-                && catalog.material_images.get(name) == binding.image.as_ref()
+                && catalog.material_images().get(name) == binding.image.as_ref()
             {
                 self.zone_samplers
                     .insert(cache_key(name), binding.sampler_state);
             }
         }
-        for (name, state) in &catalog.material_state_bits {
+        for (name, state) in catalog.material_state_bits() {
             let compiled = state.agreed().and_then(|words| {
                 let compiled = asset_material::compile_material_state(HUD_CHROME_NAMESPACE, words);
                 if let Some(fields) = compiled.unsupported_host_fields() {
@@ -285,11 +287,11 @@ impl HudImages {
                 }
             });
             self.zone_states.insert(name.clone(), compiled);
-            if catalog.zone_images.contains_key(name) && state.agreed().is_none() {
+            if catalog.zone_images().contains_key(name) && state.agreed().is_none() {
                 diag::warn!(Ui, "hud material state gap: {name}: {state:?}");
             }
         }
-        for (key, atlas) in &catalog.zone_images {
+        for (key, atlas) in catalog.zone_images() {
             self.zone_rgba
                 .insert(key.clone(), (atlas.width, atlas.height, atlas.rgba.clone()));
             self.zone_image_name
diff --git a/crates/hud/src/menus/mod.rs b/crates/hud/src/menus/mod.rs
index e628e06..d4f9219 100644
--- a/crates/hud/src/menus/mod.rs
+++ b/crates/hud/src/menus/mod.rs
@@ -297,6 +297,7 @@ pub(crate) fn update_script_menus(
         }
         return;
     }
+    menus.reconcile(catalog);
     let screen_changed = menus.screen.map(|s| s == AppScreen::MainMenu) != Some(frontend);
     if screen_changed {
         out.binding.command = None;
diff --git a/crates/hud/src/menus/runtime.rs b/crates/hud/src/menus/runtime.rs
index 6a68478..93c50fb 100644
--- a/crates/hud/src/menus/runtime.rs
+++ b/crates/hud/src/menus/runtime.rs
@@ -355,6 +355,7 @@ impl Runner<'_, '_> {
             focus: None,
             hover: None,
             items: vec![ItemState::default(); def.items.len()],
+            item_ids: super::state::item_ids(def),
         });
         diag::info!(Ui, "menu open: {}", def.name);
         let name = def.name.clone();
@@ -586,7 +587,13 @@ impl Runner<'_, '_> {
             }
             let enabled = item.disabled_exp.is_empty()
                 || matches!(self.exprs.is_true(&item.disabled_exp, &host), Ok(false));
-            if enabled && matches!(self.exprs.is_true(&item.vis_exp, &host), Ok(true)) {
+            if enabled
+                && matches!(
+                    self.exprs
+                        .is_true_source(item.visibility_expression, &item.vis_exp, &host),
+                    Ok(true)
+                )
+            {
                 out.push(index);
             }
         }
diff --git a/crates/hud/src/menus/state.rs b/crates/hud/src/menus/state.rs
index fd9d4b2..dccf02f 100644
--- a/crates/hud/src/menus/state.rs
+++ b/crates/hud/src/menus/state.rs
@@ -15,6 +15,7 @@ pub(crate) struct OpenMenu {
     pub(crate) focus: Option<usize>,
     pub(crate) hover: Option<usize>,
     pub(crate) items: Vec<ItemState>,
+    pub(crate) item_ids: Vec<String>,
 }
 
 #[derive(Clone, Debug)]
@@ -42,7 +43,92 @@ pub struct ScriptMenus {
     pub(crate) bind_requests: Vec<String>,
 }
 
+pub(crate) fn item_ids(def: &asset_game::MenuDef) -> Vec<String> {
+    let mut occurrences = std::collections::HashMap::<String, usize>::new();
+    def.items
+        .iter()
+        .map(|item| {
+            let name = if !item.authored_id.is_empty() {
+                format!("authored:{}", item.authored_id.to_ascii_lowercase())
+            } else if item.name.is_empty() {
+                format!(
+                    "anonymous:{}:{}:{}:{}",
+                    item.item_type, item.owner_draw, item.dvar, item.text_key
+                )
+            } else {
+                item.name.to_ascii_lowercase()
+            };
+            let occurrence = occurrences.entry(name.clone()).or_default();
+            let id = format!("{name}#{}", *occurrence);
+            *occurrence += 1;
+            id
+        })
+        .collect()
+}
+
 impl ScriptMenus {
+    pub(crate) fn reconcile(&mut self, catalog: &asset_game::MenuCatalog) {
+        self.stack.retain(|open| catalog.get(&open.name).is_some());
+        for open in &mut self.stack {
+            let Some(def) = catalog.get(&open.name) else {
+                continue;
+            };
+            let ids = item_ids(def);
+            if open.item_ids == ids {
+                continue;
+            }
+            let remap = |index: Option<usize>| {
+                index
+                    .and_then(|index| open.item_ids.get(index))
+                    .and_then(|id| ids.iter().position(|next| next == id))
+            };
+            open.focus = remap(open.focus);
+            open.hover = remap(open.hover);
+            if let Some(editing) = &mut self.editing
+                && editing.menu.eq_ignore_ascii_case(&open.name)
+            {
+                if let Some(next) = remap(Some(editing.item)) {
+                    editing.item = next;
+                } else {
+                    self.editing = None;
+                }
+            }
+            if let Some((menu, index)) = &mut self.slider_drag
+                && menu.eq_ignore_ascii_case(&open.name)
+            {
+                if let Some(next) = remap(Some(*index)) {
+                    *index = next;
+                } else {
+                    self.slider_drag = None;
+                }
+            }
+            let mut states: std::collections::HashMap<_, _> = open
+                .item_ids
+                .drain(..)
+                .zip(std::mem::take(&mut open.items))
+                .collect();
+            open.items = ids
+                .iter()
+                .map(|id| states.remove(id).unwrap_or_default())
+                .collect();
+            open.item_ids = ids;
+        }
+        if self
+            .editing
+            .as_ref()
+            .is_some_and(|editing| !self.is_open(&editing.menu))
+        {
+            self.editing = None;
+        }
+        if self
+            .slider_drag
+            .as_ref()
+            .is_some_and(|(menu, _)| !self.is_open(menu))
+        {
+            self.slider_drag = None;
+        }
+    }
+
     pub fn captures_input(&self) -> bool {
         self.input_menu().is_some()
     }
diff --git a/crates/iw4l-master/src/limits.rs b/crates/iw4l-master/src/limits.rs
new file mode 100644
index 0000000..2309b96
--- /dev/null
+++ b/crates/iw4l-master/src/limits.rs
@@ -0,0 +1,21 @@
+use master_protocol::budget::TransportBudget;
+use std::sync::OnceLock;
+
+pub(crate) fn configured() -> Result<TransportBudget, String> {
+    static BUDGET: OnceLock<Result<TransportBudget, String>> = OnceLock::new();
+    BUDGET
+        .get_or_init(|| {
+            TransportBudget::from_settings(TransportBudget::SETTINGS.into_iter().filter_map(
+                |name| {
+                    std::env::var(name)
+                        .ok()
+                        .map(|value| (name.to_owned(), value))
+                },
+            ))
+        })
+        .clone()
+}
+
+pub(crate) fn values() -> TransportBudget {
+    configured().unwrap_or_default()
+}
diff --git a/crates/iw4l-master/src/main.rs b/crates/iw4l-master/src/main.rs
index 543b5d1..ddb1400 100644
--- a/crates/iw4l-master/src/main.rs
+++ b/crates/iw4l-master/src/main.rs
@@ -1,5 +1,7 @@
 #![forbid(unsafe_code)]
 
+mod limits;
+
 mod updates;
 
 use std::collections::HashMap;
@@ -22,20 +24,53 @@ use master_protocol::{
 use quinn::crypto::rustls::{QuicClientConfig, QuicServerConfig};
 use rustls::pki_types::{CertificateDer, PrivateKeyDer};
 use rustls_platform_verifier::ConfigVerifierExt;
-use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::{Mutex, Semaphore};
 
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Result<T> = std::result::Result<T, Error>;
 
 const MAX_ROOMS: usize = 10_000;
-const CONTROL_CAP: usize = 32;
 const CONTROL_PRIORITY: i32 = 0;
 
+struct QueuedControl {
+    frame: ControlFrame,
+    deadline: tokio::time::Instant,
+    _bytes: tokio::sync::OwnedSemaphorePermit,
+}
+
+#[derive(Clone)]
+struct ControlSender {
+    tx: tokio::sync::mpsc::Sender<QueuedControl>,
+    bytes: Arc<Semaphore>,
+}
+
+impl ControlSender {
+    fn try_send(&self, frame: ControlFrame) -> Result<()> {
+        let len = encode_stream_frame(&frame)?.len();
+        let bytes = self
+            .bytes
+            .clone()
+            .try_acquire_many_owned(len as u32)
+            .map_err(|_| "control byte budget exhausted")?;
+        self.tx
+            .try_send(QueuedControl::new(frame, bytes))
+            .map_err(|_| "control queue exhausted")?;
+        Ok(())
+    }
+}
+
+impl QueuedControl {
+    fn new(frame: ControlFrame, bytes: tokio::sync::OwnedSemaphorePermit) -> Self {
+        Self {
+            frame,
+            deadline: tokio::time::Instant::now() + limits::values().queue_age,
+            _bytes: bytes,
+        }
+    }
+}
+
 const BOOTSTRAP_PRIORITY: i32 = -32;
 const CLI_DEADLINE: Duration = Duration::from_secs(8);
-const BOOTSTRAP_FORWARD: Duration = SESSION_IDLE;
-const HELLO_DEADLINE: Duration = Duration::from_secs(20);
 const MAX_CONNECTIONS: usize = 256;
 /// A household or a LAN party shares one address.
 const MAX_CONNECTIONS_PER_ADDRESS: usize = 32;
@@ -122,7 +157,7 @@ struct Peer {
     online: Option<Instant>,
     player_name: String,
     connection: quinn::Connection,
-    control_tx: tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: ControlSender,
 }
 
 struct PasswordVerifier {
@@ -184,7 +219,7 @@ impl ServiceState {
         connection_id: u64,
         player_name: String,
         connection: quinn::Connection,
-        control_tx: tokio::sync::mpsc::Sender<ControlFrame>,
+        control_tx: ControlSender,
     ) {
         self.peers.insert(
             connection_id,
@@ -395,6 +430,7 @@ impl ServiceState {
 
 #[tokio::main]
 async fn main() -> Result<()> {
+    limits::configured()?;
     match parse_args()? {
         Command::Serve {
             bind,
@@ -549,9 +585,6 @@ async fn serve(bind: SocketAddr, cert_path: &Path, key_path: &Path) -> Result<()
     transport.keep_alive_interval(Some(SESSION_KEEP_ALIVE));
     transport.datagram_receive_buffer_size(Some(128 * 1024));
     transport.datagram_send_buffer_size(DATAGRAM_SEND_BUFFER);
-    transport.congestion_controller_factory(Arc::new(
-        master_protocol::congestion::StallTolerantConfig::default(),
-    ));
 
     let endpoint = quinn::Endpoint::server(config, bind)?;
     let state = Arc::new(Mutex::new(ServiceState::default()));
@@ -660,11 +693,11 @@ async fn run_connection(
     connection_id: u64,
     connection: quinn::Connection,
 ) -> Result<()> {
-    let (mut send, recv) = tokio::time::timeout(HELLO_DEADLINE, connection.accept_bi())
+    let (mut send, recv) = tokio::time::timeout(limits::values().response, connection.accept_bi())
         .await
         .map_err(|_| "hello deadline (accept_bi)")??;
     send.set_priority(CONTROL_PRIORITY)?;
-    let (recv, hello) = tokio::time::timeout(HELLO_DEADLINE, read_owned_frame(recv))
+    let (recv, hello) = tokio::time::timeout(limits::values().response, read_owned_frame(recv))
         .await
         .map_err(|_| "hello deadline (first frame)")?;
     let hello = hello?;
@@ -679,7 +712,12 @@ async fn run_connection(
         hello.game_protocol,
         hello.build
     );
-    let (control_tx, mut control_rx) = tokio::sync::mpsc::channel::<ControlFrame>(CONTROL_CAP);
+    let (tx, mut control_rx) =
+        tokio::sync::mpsc::channel::<QueuedControl>(limits::values().queue_items);
+    let control_tx = ControlSender {
+        tx,
+        bytes: Arc::new(Semaphore::new(limits::values().queue_bytes)),
+    };
     state.lock().await.attach_peer(
         connection_id,
         normalize_player_name(&hello.player_name),
@@ -691,7 +729,9 @@ async fn run_connection(
     children.spawn(async move {
         let result = async {
             while let Some(frame) = control_rx.recv().await {
-                write_frame(&mut send, &frame).await?;
+                tokio::time::timeout_at(frame.deadline, write_frame(&mut send, &frame.frame))
+                    .await
+                    .map_err(|_| "control queue/write deadline")??;
             }
             Result::<()>::Ok(())
         }
@@ -782,7 +822,7 @@ async fn dispatch_publishes(state: &Mutex<ServiceState>, publishes: Vec<(u64, Co
             };
             match peer.control_tx.try_send(frame) {
                 Ok(()) => {}
-                Err(TrySendError::Full(_)) | Err(TrySendError::Closed(_)) => {
+                Err(_) => {
                     failed.push(connection_id);
                     peer.connection
                         .close(0_u8.into(), b"control delivery failed");
@@ -1363,8 +1403,8 @@ async fn bootstrap_forward(
     mut recv: quinn::RecvStream,
     _permit: tokio::sync::OwnedSemaphorePermit,
 ) -> ConnTask {
-    let result = tokio::time::timeout(BOOTSTRAP_FORWARD, async {
-        let bytes = recv.read_to_end(MAX_BOOTSTRAP_STREAM_BYTES).await?;
+    let result = tokio::time::timeout(limits::values().transfer, async {
+        let bytes = read_transfer(&mut recv).await?;
         let relay = decode_relay_stream(&bytes)?;
         let (target, outgoing) = {
             let current = state.lock().await;
@@ -1372,11 +1412,17 @@ async fn bootstrap_forward(
         };
         let mut send = target.open_uni().await?;
         send.set_priority(BOOTSTRAP_PRIORITY)?;
-        send.write_all(&outgoing).await?;
-        send.finish()?;
+        let result = write_transfer(&mut send, &outgoing).await;
+        if result.is_err() {
+            let _ = send.reset(0_u8.into());
+        }
+        result?;
         Result::<()>::Ok(())
     })
     .await;
+    if !matches!(result, Ok(Ok(()))) {
+        let _ = recv.stop(0_u8.into());
+    }
     match result {
         Ok(Ok(())) => {}
         Ok(Err(error)) => {
@@ -1585,6 +1631,46 @@ async fn rpc(
     }
 }
 
+async fn read_transfer(recv: &mut quinn::RecvStream) -> Result<Vec<u8>> {
+    let mut bytes = Vec::new();
+    loop {
+        let chunk =
+            tokio::time::timeout(limits::values().progress, recv.read_chunk(16 * 1024, true))
+                .await
+                .map_err(|_| "transfer progress deadline")??;
+        let Some(chunk) = chunk else {
+            return Ok(bytes);
+        };
+        if chunk.bytes.is_empty() || bytes.len() + chunk.bytes.len() > MAX_BOOTSTRAP_STREAM_BYTES {
+            return Err("transfer byte budget exceeded".into());
+        }
+        bytes.extend_from_slice(&chunk.bytes);
+    }
+}
+
+async fn write_transfer(send: &mut quinn::SendStream, bytes: &[u8]) -> Result<()> {
+    let mut offset = 0;
+    while offset < bytes.len() {
+        let end = (offset + 16 * 1024).min(bytes.len());
+        let written =
+            tokio::time::timeout(limits::values().progress, send.write(&bytes[offset..end]))
+                .await
+                .map_err(|_| "transfer progress deadline")??;
+        if written == 0 {
+            return Err("transfer made no progress".into());
+        }
+        offset += written;
+    }
+    send.finish()?;
+    if let Some(code) = tokio::time::timeout(limits::values().progress, send.stopped())
+        .await
+        .map_err(|_| "transfer acknowledgement deadline")??
+    {
+        return Err(format!("transfer refused with code {code}").into());
+    }
+    Ok(())
+}
+
 async fn read_owned_frame(
     mut recv: quinn::RecvStream,
 ) -> (quinn::RecvStream, Result<ControlFrame>) {
diff --git a/crates/master_protocol/Cargo.toml b/crates/master_protocol/Cargo.toml
index 5d0fa02..3a244c0 100644
--- a/crates/master_protocol/Cargo.toml
+++ b/crates/master_protocol/Cargo.toml
@@ -7,6 +7,3 @@ description = "Versioned control and opaque relay protocol shared by iw4l and iw
 
 [lints]
 workspace = true
-
-[dependencies]
-quinn-proto = { version = "0.11.17", default-features = false }
diff --git a/crates/master_protocol/src/budget.rs b/crates/master_protocol/src/budget.rs
new file mode 100644
index 0000000..237d7d8
--- /dev/null
+++ b/crates/master_protocol/src/budget.rs
@@ -0,0 +1,98 @@
+use core::time::Duration;
+
+#[derive(Clone, Copy, Debug)]
+pub struct TransportBudget {
+    pub response: Duration,
+    pub progress: Duration,
+    pub transfer: Duration,
+    pub queue_age: Duration,
+    pub connect: Duration,
+    pub shutdown: Duration,
+    pub loading: Duration,
+    pub silence: Duration,
+    pub admission: Duration,
+    pub queue_items: usize,
+    pub queue_bytes: usize,
+}
+
+impl Default for TransportBudget {
+    fn default() -> Self {
+        Self {
+            response: Duration::from_secs(20),
+            progress: Duration::from_secs(5),
+            transfer: Duration::from_secs(90),
+            queue_age: Duration::from_secs(20),
+            connect: Duration::from_secs(60),
+            shutdown: Duration::from_millis(500),
+            loading: Duration::from_secs(120),
+            silence: Duration::from_secs(60),
+            admission: Duration::from_secs(60),
+            queue_items: 32,
+            queue_bytes: 8 * 1024 * 1024,
+        }
+    }
+}
+
+impl TransportBudget {
+    pub const SETTINGS: [&'static str; 11] = [
+        "IW4L_NET_RESPONSE_MS",
+        "IW4L_NET_PROGRESS_MS",
+        "IW4L_NET_TRANSFER_MS",
+        "IW4L_NET_QUEUE_AGE_MS",
+        "IW4L_NET_CONNECT_MS",
+        "IW4L_NET_SHUTDOWN_MS",
+        "IW4L_NET_LOADING_MS",
+        "IW4L_NET_SILENCE_MS",
+        "IW4L_NET_ADMISSION_MS",
+        "IW4L_NET_QUEUE_ITEMS",
+        "IW4L_NET_QUEUE_BYTES",
+    ];
+
+    pub fn from_settings(
+        settings: impl IntoIterator<Item = (String, String)>,
+    ) -> Result<Self, String> {
+        let mut budget = Self::default();
+        for (name, text) in settings {
+            let n = text
+                .parse::<u64>()
+                .map_err(|_| format!("{name} must be a positive integer"))?;
+            match name.as_str() {
+                "IW4L_NET_QUEUE_ITEMS" if (1..=1024).contains(&n) => {
+                    budget.queue_items = n as usize
+                }
+                "IW4L_NET_QUEUE_BYTES" if (256 * 1024..=64 * 1024 * 1024).contains(&n) => {
+                    budget.queue_bytes = n as usize
+                }
+                "IW4L_NET_RESPONSE_MS"
+                | "IW4L_NET_PROGRESS_MS"
+                | "IW4L_NET_TRANSFER_MS"
+                | "IW4L_NET_QUEUE_AGE_MS"
+                | "IW4L_NET_CONNECT_MS"
+                | "IW4L_NET_SHUTDOWN_MS"
+                | "IW4L_NET_LOADING_MS"
+                | "IW4L_NET_SILENCE_MS"
+                | "IW4L_NET_ADMISSION_MS"
+                    if (1..=600_000).contains(&n) =>
+                {
+                    let duration = Duration::from_millis(n);
+                    match name.as_str() {
+                        "IW4L_NET_RESPONSE_MS" => budget.response = duration,
+                        "IW4L_NET_PROGRESS_MS" => budget.progress = duration,
+                        "IW4L_NET_TRANSFER_MS" => budget.transfer = duration,
+                        "IW4L_NET_CONNECT_MS" => budget.connect = duration,
+                        "IW4L_NET_SHUTDOWN_MS" => budget.shutdown = duration,
+                        "IW4L_NET_LOADING_MS" => budget.loading = duration,
+                        "IW4L_NET_SILENCE_MS" => budget.silence = duration,
+                        "IW4L_NET_ADMISSION_MS" => budget.admission = duration,
+                        _ => budget.queue_age = duration,
+                    }
+                }
+                _ => return Err(format!("invalid transport setting {name}={text}")),
+            }
+        }
+        if budget.progress > budget.transfer {
+            return Err("transfer progress deadline exceeds total transfer deadline".into());
+        }
+        Ok(budget)
+    }
+}
diff --git a/crates/master_protocol/src/congestion.rs b/crates/master_protocol/src/congestion.rs
deleted file mode 100644
index f44de11..0000000
--- a/crates/master_protocol/src/congestion.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-use std::{
-    any::Any,
-    sync::Arc,
-    time::{Duration, Instant},
-};
-
-use quinn_proto::{
-    RttEstimator,
-    congestion::{BbrConfig, Controller, ControllerFactory},
-};
-
-const STALL: Duration = Duration::from_secs(1);
-
-#[derive(Debug, Default)]
-pub struct StallTolerantConfig(BbrConfig);
-
-impl ControllerFactory for StallTolerantConfig {
-    fn build(self: Arc<Self>, now: Instant, current_mtu: u16) -> Box<dyn Controller> {
-        Box::new(StallTolerant {
-            inner: Arc::new(self.0.clone()).build(now, current_mtu),
-            waiting_since: None,
-            stalled: false,
-        })
-    }
-}
-
-struct StallTolerant {
-    inner: Box<dyn Controller>,
-    waiting_since: Option<Instant>,
-    stalled: bool,
-}
-
-impl Controller for StallTolerant {
-    fn on_sent(&mut self, now: Instant, bytes: u64, last_packet_number: u64) {
-        let since = *self.waiting_since.get_or_insert(now);
-        self.stalled = now.saturating_duration_since(since) >= STALL;
-        self.inner.on_sent(now, bytes, last_packet_number);
-    }
-
-    fn on_ack(
-        &mut self,
-        now: Instant,
-        sent: Instant,
-        bytes: u64,
-        app_limited: bool,
-        rtt: &RttEstimator,
-    ) {
-        self.inner.on_ack(now, sent, bytes, app_limited, rtt);
-    }
-
-    fn on_end_acks(
-        &mut self,
-        now: Instant,
-        in_flight: u64,
-        app_limited: bool,
-        largest_packet_num_acked: Option<u64>,
-    ) {
-        self.waiting_since = (in_flight > 0).then_some(now);
-        self.stalled = false;
-        self.inner
-            .on_end_acks(now, in_flight, app_limited, largest_packet_num_acked);
-    }
-
-    fn on_congestion_event(
-        &mut self,
-        now: Instant,
-        sent: Instant,
-        is_persistent_congestion: bool,
-        lost_bytes: u64,
-    ) {
-        self.inner
-            .on_congestion_event(now, sent, is_persistent_congestion, lost_bytes);
-    }
-
-    fn on_mtu_update(&mut self, new_mtu: u16) {
-        self.inner.on_mtu_update(new_mtu);
-    }
-
-    fn window(&self) -> u64 {
-        if self.stalled {
-            u64::MAX
-        } else {
-            self.inner.window()
-        }
-    }
-
-    fn clone_box(&self) -> Box<dyn Controller> {
-        Box::new(StallTolerant {
-            inner: self.inner.clone_box(),
-            waiting_since: self.waiting_since,
-            stalled: self.stalled,
-        })
-    }
-
-    fn initial_window(&self) -> u64 {
-        self.inner.initial_window()
-    }
-
-    fn into_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-}
diff --git a/crates/master_protocol/src/lib.rs b/crates/master_protocol/src/lib.rs
index 8784e44..ecb67f9 100644
--- a/crates/master_protocol/src/lib.rs
+++ b/crates/master_protocol/src/lib.rs
@@ -2,7 +2,7 @@
 
 use core::{fmt, str::FromStr};
 
-pub mod congestion;
+pub mod budget;
 
 pub const PROTOCOL_VERSION: u16 = 10;
 pub const ALPN: &[u8] = b"iw4l-master/10";
diff --git a/crates/net/src/client/presentation/centity_runtime.rs b/crates/net/src/client/presentation/centity_runtime.rs
index f41b4a8..ed631ed 100644
--- a/crates/net/src/client/presentation/centity_runtime.rs
+++ b/crates/net/src/client/presentation/centity_runtime.rs
@@ -353,6 +353,7 @@ pub fn corpse_slot_to_entity_state(slot: &PlayerCorpseSlot) -> EntityState {
     es.client_num = i32::try_from(slot.victim.0).unwrap_or(0);
     es.time2 = slot.spawn_time_ms;
     es.e_flags = slot.e_flags;
+    es.weapon_model = slot.weapon_model;
     es.tr_type = slot.tr_type;
     es.tr_time = slot.tr_time;
     es.tr_duration = slot.tr_duration;
diff --git a/crates/net/src/client/presentation/entities.rs b/crates/net/src/client/presentation/entities.rs
index 66b194b..6b40410 100644
--- a/crates/net/src/client/presentation/entities.rs
+++ b/crates/net/src/client/presentation/entities.rs
@@ -12,12 +12,20 @@ use crate::{AuthoritySet, ClientSet, LastAdoptedSnapshot, ServerTick};
 
 pub const CLIENT_ENTITY_SLOT_COUNT: usize = ENTITYNUM_NONE as usize;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct CorpseIdentity {
+    pub match_key: frame::MatchKey,
+    pub slot: u16,
+    pub spawn_sequence: u64,
+}
+
 #[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
 #[component(immutable)]
 #[require(bevy::prelude::DespawnOnExit<frame::Timeline> = bevy::prelude::DespawnOnExit(frame::Timeline::Running))]
 pub struct CEntity {
     number: u16,
     client: Option<ClientId>,
+    corpse: Option<CorpseIdentity>,
 }
 
 impl CEntity {
@@ -25,6 +33,10 @@ impl CEntity {
         self.number
     }
 
+    pub const fn corpse_identity(&self) -> Option<CorpseIdentity> {
+        self.corpse
+    }
+
     pub const fn client(&self) -> Option<ClientId> {
         self.client
     }
@@ -119,12 +131,14 @@ pub fn sync_client_entities(
     proxy: Option<Res<crate::RemoteProxyState>>,
     clock: Option<Res<crate::FrameClock>>,
     local: Option<Res<crate::LocalPresentClient>>,
-    mut selected_tick: Local<Option<(sim::Tick, bool)>>,
+    mut selected_tick: Local<Option<(sim::Tick, bool, u64)>>,
+    timeline: Res<crate::EntityEventCursor>,
     mut slots: ResMut<CEntitySlots>,
     mut gaps: ResMut<NetIdentityGaps>,
     identities: Query<&CEntity>,
     mut runtimes: Query<&mut CEntityRuntime>,
     mut census: ResMut<CEntityBirthCensus>,
+    installed: Res<frame::InstalledMatch>,
 ) {
     let archived = adopted.next().is_some_and(|snap| {
         snap.players.iter().any(|(id, ps)| {
@@ -141,7 +155,7 @@ pub fn sync_client_entities(
         None
     };
     let next = selected.as_deref().or_else(|| adopted.next());
-    let key = next.map(|snap| (snap.tick, archived));
+    let key = next.map(|snap| (snap.tick, archived, timeline.timeline()));
     if archived {
         if *selected_tick == key {
             return;
@@ -182,6 +196,7 @@ pub fn sync_client_entities(
             .flatten(),
         CEntitySyncArm::Client,
         Some(&mut census),
+        installed.load_key.match_key,
     );
 }
 
@@ -193,6 +208,7 @@ pub(crate) fn sync_authority_entities(
     identities: Query<&CEntity>,
     mut runtimes: Query<&mut CEntityRuntime>,
     mut census: ResMut<CEntityBirthCensus>,
+    installed: Res<frame::InstalledMatch>,
 ) {
     let players = server_tick
         .0
@@ -230,6 +246,7 @@ pub(crate) fn sync_authority_entities(
         None,
         CEntitySyncArm::Authority,
         Some(&mut census),
+        installed.load_key.match_key,
     );
 }
 
@@ -237,12 +254,14 @@ pub(crate) fn sync_authority_entities(
 struct WantedOccupant {
     client: Option<ClientId>,
     next_state: entity_iw4::EntityState,
+    corpse_sequence: Option<u64>,
 }
 
 fn occupant_from_player(client: ClientId, ps: &playerstate_iw4::PlayerState) -> WantedOccupant {
     WantedOccupant {
         client: Some(client),
         next_state: player_state_to_entity_state(client, ps),
+        corpse_sequence: None,
     }
 }
 
@@ -250,6 +269,7 @@ fn occupant_from_corpse(slot: &PlayerCorpseSlot) -> WantedOccupant {
     WantedOccupant {
         client: Some(slot.victim),
         next_state: corpse_slot_to_entity_state(slot),
+        corpse_sequence: Some(slot.spawn_sequence),
     }
 }
 
@@ -260,6 +280,7 @@ fn occupant_from_replicated(es: entity_iw4::EntityState) -> WantedOccupant {
     WantedOccupant {
         client,
         next_state: es,
+        corpse_sequence: None,
     }
 }
 
@@ -288,6 +309,7 @@ fn sync_snapshot_entities(
     seated_viewer: Option<ClientId>,
     arm: CEntitySyncArm,
     mut census: Option<&mut CEntityBirthCensus>,
+    match_key: frame::MatchKey,
 ) {
     if pair_ready {
         for mut runtime in runtimes.iter_mut() {
@@ -350,11 +372,17 @@ fn sync_snapshot_entities(
         let index = usize::from(number);
         let client = occupant.client;
         let next_state = occupant.next_state;
+        let corpse = occupant
+            .corpse_sequence
+            .map(|spawn_sequence| CorpseIdentity {
+                match_key,
+                slot: number,
+                spawn_sequence,
+            });
         let valid = slots.slots[index].is_some_and(|slot| {
-            identities
-                .get(slot.entity)
-                .is_ok_and(|identity| identity.number == number && identity.client == client)
-                && runtimes.get(slot.entity).is_ok()
+            identities.get(slot.entity).is_ok_and(|identity| {
+                identity.number == number && identity.client == client && identity.corpse == corpse
+            }) && runtimes.get(slot.entity).is_ok()
         });
         if valid {
             let entity = slots.slots[index].expect("valid slot").entity;
@@ -374,7 +402,16 @@ fn sync_snapshot_entities(
         }
         let mut runtime = CEntityRuntime::default();
         reset_entity(&mut runtime, next_state, at_time_ms, true);
-        let entity = commands.spawn((CEntity { number, client }, runtime)).id();
+        let entity = commands
+            .spawn((
+                CEntity {
+                    number,
+                    client,
+                    corpse,
+                },
+                runtime,
+            ))
+            .id();
         slots.slots[index] = Some(CEntitySlot { client, entity });
         if let Some(census) = census.as_mut() {
             census.note_birth(arm);
diff --git a/crates/net/src/client/presentation/entity_event_dispatch.rs b/crates/net/src/client/presentation/entity_event_dispatch.rs
index 74c9fcf..3128420 100644
--- a/crates/net/src/client/presentation/entity_event_dispatch.rs
+++ b/crates/net/src/client/presentation/entity_event_dispatch.rs
@@ -158,7 +158,7 @@ struct DeferredEntityEvent {
     target: DeferredTarget,
 }
 
-#[derive(Resource, Default, Debug)]
+#[derive(Resource, Debug)]
 pub struct EntityEventCursor {
     seen_through: u32,
 
@@ -172,6 +172,32 @@ pub struct EntityEventCursor {
     deferred: VecDeque<DeferredEntityEvent>,
 }
 
+fn fresh_timeline() -> u64 {
+    static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
+    NEXT.fetch_update(
+        std::sync::atomic::Ordering::Relaxed,
+        std::sync::atomic::Ordering::Relaxed,
+        |next| next.checked_add(1),
+    )
+    .expect("presentation timeline exhausted")
+}
+
+impl Default for EntityEventCursor {
+    fn default() -> Self {
+        Self {
+            seen_through: 0,
+            archived_through: None,
+            archive_tick: None,
+            archive_start_tick: None,
+            in_killcam: false,
+            timeline: fresh_timeline(),
+            predicted_shots: 0,
+            authority_shots: 0,
+            deferred: VecDeque::new(),
+        }
+    }
+}
+
 #[derive(Resource, Default, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AppliedEntityEventWalk {
     pub walked: u32,
@@ -308,7 +334,7 @@ fn dispatch_entity_events(
             .is_some_and(|(next, old)| next.0 < old.0);
     cursor.archive_tick = pending.archive_tick;
     if killcam_transition {
-        cursor.timeline = cursor.timeline.wrapping_add(1);
+        cursor.timeline = fresh_timeline();
         cursor.in_killcam = pending.in_killcam;
         cursor.archived_through = None;
         cursor.archive_start_tick = pending.archive_tick;
@@ -744,6 +770,10 @@ pub fn register_entity_event_dispatch(app: &mut App) {
                     .in_set(frame::InMatch)
                     .in_set(ClientSet::Reconcile)
                     .after(crate::sync_client_entities),
+                crate::client::runtime::publish_accepted_impacts
+                    .in_set(frame::InMatch)
+                    .in_set(frame::OwnerEventsPublished)
+                    .after(dispatch_owner_events),
                 dispatch_owner_events
                     .in_set(frame::InMatch)
                     .in_set(frame::OwnerEventsPublished)
diff --git a/crates/net/src/client/proxy.rs b/crates/net/src/client/proxy.rs
index acb6ef6..0e64ca6 100644
--- a/crates/net/src/client/proxy.rs
+++ b/crates/net/src/client/proxy.rs
@@ -123,6 +123,34 @@ impl RemoteProxy {
         Self::default()
     }
 
+    pub(crate) fn impact_window(
+        &self,
+        after: Option<sim::Tick>,
+        through: sim::Tick,
+    ) -> (Option<sim::Tick>, Vec<(sim::Tick, sim::PelletFxRecord)>) {
+        let oldest = self.buffer.front().map(|entry| entry.snap.tick);
+        let gap =
+            oldest.filter(|oldest| after.is_some_and(|after| after.0.saturating_add(1) < oldest.0));
+        let records = self
+            .buffer
+            .iter()
+            .filter(|entry| {
+                entry.snap.tick.0 <= through.0
+                    && after.is_none_or(|after| entry.snap.tick.0 > after.0)
+            })
+            .flat_map(|entry| {
+                entry
+                    .snap
+                    .meta
+                    .pellet_fx
+                    .iter()
+                    .copied()
+                    .map(move |record| (entry.snap.tick, record))
+            })
+            .collect();
+        (gap, records)
+    }
+
     pub fn delay_ms(&self) -> i32 {
         self.delay_ms
     }
diff --git a/crates/net/src/client/runtime.rs b/crates/net/src/client/runtime.rs
index 608e2fc..da3ea02 100644
--- a/crates/net/src/client/runtime.rs
+++ b/crates/net/src/client/runtime.rs
@@ -41,6 +41,140 @@ pub struct PendingPresentedEntityEvents {
     pub in_killcam: bool,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ImpactOccurrence {
+    pub installation: frame::LocalLoadKey,
+    pub timeline: u64,
+    pub tick: sim::Tick,
+    pub cause: Option<sim::FireCause>,
+    pub attacker: i32,
+    pub correlation: u32,
+    pub pellet: u16,
+    pub segment: u16,
+}
+
+#[derive(Message, Clone, Copy, Debug)]
+pub struct AcceptedImpact {
+    pub occurrence: ImpactOccurrence,
+    pub world: frame::WorldStamp,
+    pub record: sim::PelletFxRecord,
+}
+
+#[derive(Message, Clone, Copy, Debug)]
+pub struct ImpactReconstruction {
+    pub context: frame::PresentationContext,
+    pub retained_from: Option<sim::Tick>,
+}
+
+#[derive(Resource, Default)]
+pub struct PendingAcceptedImpacts(Vec<(frame::WorldStamp, sim::Tick, sim::PelletFxRecord)>);
+
+#[derive(Resource, Default)]
+pub(crate) struct ImpactCursor {
+    replay_tick: Option<sim::Tick>,
+    context: Option<(frame::LocalLoadKey, u64)>,
+    seen: std::collections::HashSet<ImpactOccurrence>,
+    order: VecDeque<ImpactOccurrence>,
+}
+
+pub(crate) fn publish_accepted_impacts(
+    mut pending: ResMut<PendingAcceptedImpacts>,
+    mut cursor: ResMut<ImpactCursor>,
+    installed: Res<frame::InstalledMatch>,
+    timeline: Res<crate::EntityEventCursor>,
+    mut impacts: MessageWriter<AcceptedImpact>,
+    presented: Res<PresentedSnapshot>,
+    mut visuals: ResMut<PendingPelletFx>,
+    proxy: Res<RemoteProxyState>,
+    mut reconstruction: MessageWriter<ImpactReconstruction>,
+) {
+    let context = Some((installed.load_key, timeline.timeline()));
+    if cursor.context != context {
+        cursor.context = context;
+        cursor.seen.clear();
+        cursor.order.clear();
+        cursor.replay_tick = None;
+        reconstruction.write(ImpactReconstruction {
+            context: frame::PresentationContext::new(installed.load_key, timeline.timeline()),
+            retained_from: None,
+        });
+    }
+    let mut accepted = std::mem::take(&mut pending.0);
+    if presented.is_archived_replay()
+        && let Some(snapshot) = presented.snapshot()
+    {
+        let world = frame::WorldStamp::from_install(installed.request_id);
+        let (gap, records) = proxy.0.impact_window(cursor.replay_tick, snapshot.tick);
+        if gap.is_some() {
+            cursor.seen.clear();
+            cursor.order.clear();
+            reconstruction.write(ImpactReconstruction {
+                context: frame::PresentationContext::new(installed.load_key, timeline.timeline()),
+                retained_from: gap,
+            });
+        }
+        if records.is_empty() && cursor.replay_tick != Some(snapshot.tick) {
+            accepted.extend(
+                snapshot
+                    .meta
+                    .pellet_fx
+                    .iter()
+                    .copied()
+                    .map(|record| (world, snapshot.tick, record)),
+            );
+        } else {
+            accepted.extend(
+                records
+                    .into_iter()
+                    .map(|(tick, record)| (world, tick, record)),
+            );
+        }
+        cursor.replay_tick = Some(snapshot.tick);
+    }
+    for (world, tick, record) in accepted {
+        if world != frame::WorldStamp::from_install(installed.request_id)
+            || record.normal == [0.0; 3]
+        {
+            continue;
+        }
+        let occurrence = ImpactOccurrence {
+            installation: installed.load_key,
+            timeline: timeline.timeline(),
+            tick: if record.fire_cause.is_some() {
+                sim::Tick(0)
+            } else {
+                tick
+            },
+            cause: record.fire_cause,
+            attacker: record.attacker,
+            correlation: record.correlation,
+            pellet: record.pellet,
+            segment: record.segment,
+        };
+        if !cursor.seen.insert(occurrence) {
+            continue;
+        }
+        cursor.order.push_back(occurrence);
+        while cursor.order.len() > 4096 {
+            if let Some(old) = cursor.order.pop_front() {
+                cursor.seen.remove(&old);
+            }
+        }
+        if presented.is_archived_replay() {
+            visuals
+                .0
+                .push((world, crate::EntityEventDomain::Snapshot, record));
+        }
+        impacts.write(AcceptedImpact {
+            occurrence,
+            world,
+            record,
+        });
+    }
+    let excess = visuals.0.len().saturating_sub(8192);
+    visuals.0.drain(..excess);
+}
+
 #[derive(Resource, Default)]
 pub struct PendingPelletFx(
     pub(crate)  Vec<(
@@ -559,6 +693,7 @@ pub fn reconcile_prediction(
     mut pending: ResMut<PendingClientSends>,
     mut entity_events: ResMut<PendingPresentedEntityEvents>,
     mut pellet_fx: ResMut<PendingPelletFx>,
+    mut accepted: ResMut<PendingAcceptedImpacts>,
     role: Res<RuntimeRole>,
     cg_clock: Res<FrameClock>,
     trace: Option<ResMut<ClientPhaseTrace>>,
@@ -584,9 +719,17 @@ pub fn reconcile_prediction(
             tick.snapshot.meta.world_objects.map_round_epoch == match_key.match_epoch
         };
         if same_match {
+            accepted.0.extend(
+                tick.snapshot
+                    .meta
+                    .pellet_fx
+                    .iter()
+                    .copied()
+                    .map(|record| (reliable.generation.stamp(), tick.snapshot.tick, record)),
+            );
             pellet_fx
                 .0
-                .extend(tick.snapshot.meta.pellet_fx.drain(..).map(|record| {
+                .extend(tick.snapshot.meta.pellet_fx.iter().copied().map(|record| {
                     (
                         reliable.generation.stamp(),
                         crate::EntityEventDomain::Snapshot,
@@ -2031,6 +2174,10 @@ pub fn register_client_runtime(app: &mut App) {
         .scoped::<PresentLocalCensus>(frame::Timeline::Running)
         .scoped::<PendingPresentedEntityEvents>(frame::Timeline::Running)
         .scoped::<PendingPelletFx>(frame::Timeline::Running)
+        .scoped::<PendingAcceptedImpacts>(frame::Timeline::Running)
+        .scoped::<ImpactCursor>(frame::Timeline::Running)
+        .scoped_message::<AcceptedImpact>(frame::Timeline::Running)
+        .scoped_message::<ImpactReconstruction>(frame::Timeline::Running)
         .scoped::<PendingClientSends>(frame::MatchScope::Live)
         .init_resource::<ClientCmdTemplate>()
         .scoped::<WeaponSelect>(frame::MatchScope::Live)
diff --git a/crates/net/src/lib.rs b/crates/net/src/lib.rs
index aa01700..b0f2aee 100644
--- a/crates/net/src/lib.rs
+++ b/crates/net/src/lib.rs
@@ -53,8 +53,8 @@ pub use client::presentation::centity_runtime::{
     remote_body_submits, remote_pose_sample,
 };
 pub use client::presentation::entities::{
-    CEntity, CEntityBirthCensus, CEntitySlots, CLIENT_ENTITY_SLOT_COUNT, register_client_entities,
-    sync_client_entities,
+    CEntity, CEntityBirthCensus, CEntitySlots, CLIENT_ENTITY_SLOT_COUNT, CorpseIdentity,
+    register_client_entities, sync_client_entities,
 };
 pub use client::presentation::entity_event_dispatch::{
     AppliedEntityEventWalk, DispatchedEntityEvent, EntityBulletHit, EntityEjectBrass,
@@ -80,14 +80,15 @@ pub use client::proxy::{
 };
 pub use client::realtime::ClientRealtime;
 pub use client::runtime::{
-    ClientClock, ClientCmdTemplate, ClientPhaseTrace, ClientPredictionState, ClientReliableAck,
-    ClockTick, FireCommandVerdicts, LastAdoptedSnapshot, LocationCursor, PendingClientSends,
-    PendingPelletFx, PendingPresentedEntityEvents, ReceivedTicks, ReliableControlEvent,
-    RemoteProxyState, WeaponSelect, advance_cg_frame_clock, advance_cls_realtime,
-    arm_listen_prediction, cycle_weapon_select, follow_held_weapon_select,
-    listen_prediction_needs_content, predict_local_move, publish_presented, receive_ticks,
-    reconcile_prediction, register_client_runtime, register_listen_prediction_arm,
-    sample_client_input, send_pending_commands,
+    AcceptedImpact, ClientClock, ClientCmdTemplate, ClientPhaseTrace, ClientPredictionState,
+    ClientReliableAck, ClockTick, FireCommandVerdicts, ImpactOccurrence, ImpactReconstruction,
+    LastAdoptedSnapshot, LocationCursor, PendingClientSends, PendingPelletFx,
+    PendingPresentedEntityEvents, ReceivedTicks, ReliableControlEvent, RemoteProxyState,
+    WeaponSelect, advance_cg_frame_clock, advance_cls_realtime, arm_listen_prediction,
+    cycle_weapon_select, follow_held_weapon_select, listen_prediction_needs_content,
+    predict_local_move, publish_presented, receive_ticks, reconcile_prediction,
+    register_client_runtime, register_listen_prediction_arm, sample_client_input,
+    send_pending_commands,
 };
 pub use gaps::{NetGap, NetGapCause, NetIdentityGaps, ScriptNotify};
 pub use plugin::NetPlugin;
@@ -174,6 +175,6 @@ pub use transport::wire::{WireError, WireReader, WireWriter};
 
 pub use svc_script_audio::SvcScriptAudio;
 
-pub const PROTOCOL_VERSION: u32 = 118;
+pub const PROTOCOL_VERSION: u32 = 119;
 
 pub use client::fire_verdict::{FireVerdictState, PredictedFireStatus};
diff --git a/crates/net/src/session_core.rs b/crates/net/src/session_core.rs
index ec4574a..0cecb7e 100644
--- a/crates/net/src/session_core.rs
+++ b/crates/net/src/session_core.rs
@@ -53,10 +53,6 @@ pub(crate) fn format_session_transition(
     )
 }
 
-pub const LOADING_DEADLINE_MS: u64 = 120_000;
-pub const RUNNING_SILENCE_MS: u64 = 60_000;
-pub const PEER_ADMISSION_DEADLINE_MS: u64 = master_protocol::SESSION_IDLE.as_millis() as u64;
-
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ProgressPhase {
     Idle,
@@ -102,10 +98,16 @@ impl ProgressWatch {
         match self.phase {
             ProgressPhase::Idle => false,
             ProgressPhase::Loading => {
-                now_ms.saturating_sub(self.phase_started_at) >= LOADING_DEADLINE_MS
+                now_ms.saturating_sub(self.phase_started_at)
+                    >= crate::transport::master::limits::values()
+                        .loading
+                        .as_millis() as u64
             }
             ProgressPhase::Running => {
-                now_ms.saturating_sub(self.last_progress_ms) >= RUNNING_SILENCE_MS
+                now_ms.saturating_sub(self.last_progress_ms)
+                    >= crate::transport::master::limits::values()
+                        .silence
+                        .as_millis() as u64
             }
         }
     }
@@ -230,7 +232,7 @@ pub enum PeerPhase {
 pub struct PeerAdmission {
     pub phase: PeerPhase,
     pub map_loaded: Option<HostWorldReady>,
-    pub started_at_ms: u64,
+    pub started_at_ms: Option<u64>,
     pub connection_id: Option<u64>,
 }
 
@@ -239,7 +241,7 @@ impl Default for PeerAdmission {
         Self {
             phase: PeerPhase::Waiting,
             map_loaded: None,
-            started_at_ms: 0,
+            started_at_ms: None,
             connection_id: None,
         }
     }
@@ -251,6 +253,11 @@ pub enum HostMatchEvent {
         match_key: MatchKey,
         now_ms: u64,
     },
+    PeerRoster {
+        match_key: MatchKey,
+        members: Vec<MemberId>,
+        now_ms: u64,
+    },
     AuthorityReady {
         ready: HostWorldReady,
         now_ms: u64,
@@ -363,6 +370,7 @@ impl TransitionIds {
     fn from_event(event: &HostMatchEvent, elapsed_from: u64) -> Self {
         match event {
             HostMatchEvent::Start { now_ms, .. }
+            | HostMatchEvent::PeerRoster { now_ms, .. }
             | HostMatchEvent::AuthorityReady { now_ms, .. }
             | HostMatchEvent::AuthorityProgress { now_ms }
             | HostMatchEvent::Tick { now_ms } => Self {
@@ -526,6 +534,26 @@ impl HostMatchCore {
                 self.progress.set_phase(ProgressPhase::Loading, now_ms);
                 self.finish(&ids, before, "start loading", Vec::new())
             }
+            HostMatchEvent::PeerRoster {
+                match_key,
+                members,
+                now_ms,
+            } => {
+                if match_key != self.match_key
+                    || !matches!(self.phase, MatchPhase::Loading | MatchPhase::Running)
+                    || members.len() > master_protocol::MAX_SESSION_MEMBERS as usize
+                {
+                    return self.reject(&ids, before, "stale or invalid peer roster");
+                }
+                self.peers.retain(|member, _| members.contains(member));
+                for member in members {
+                    self.peers.entry(member).or_insert_with(|| PeerAdmission {
+                        started_at_ms: Some(now_ms),
+                        ..Default::default()
+                    });
+                }
+                self.finish(&ids, before, "peer roster", Vec::new())
+            }
             HostMatchEvent::AuthorityReady { ready, now_ms } => {
                 if !epoch_applies(ready.epoch, self.match_key.match_epoch) {
                     return self.reject(&ids, before, "stale host world");
@@ -539,10 +567,8 @@ impl HostMatchCore {
                     self.phase = MatchPhase::Running;
                     self.progress.set_phase(ProgressPhase::Running, now_ms);
                     for peer in self.peers.values_mut() {
-                        peer.started_at_ms = now_ms;
+                        peer.started_at_ms = Some(now_ms);
                     }
-                } else {
-                    self.progress.beat(now_ms);
                 }
                 let match_key = self.match_key;
                 let effects = self
@@ -568,12 +594,14 @@ impl HostMatchCore {
                 {
                     return self.reject(&ids, before, "stale map loaded");
                 }
-                let peer = self.peers.entry(member).or_default();
+                let Some(peer) = self.peers.get_mut(&member) else {
+                    return self.reject(&ids, before, "map loaded outside peer roster");
+                };
                 if matches!(peer.phase, PeerPhase::Failed | PeerPhase::Cancelled) {
                     return self.reject(&ids, before, "map loaded after admission ended");
                 }
-                if self.phase == MatchPhase::Running && peer.started_at_ms == 0 {
-                    peer.started_at_ms = now_ms;
+                if self.phase == MatchPhase::Running && peer.started_at_ms.is_none() {
+                    peer.started_at_ms = Some(now_ms);
                 }
                 peer.map_loaded = Some(loaded);
                 let effects = self
@@ -721,9 +749,12 @@ impl HostMatchCore {
                 if self.phase == MatchPhase::Running {
                     for (member, peer) in &self.peers {
                         if matches!(peer.phase, PeerPhase::Waiting | PeerPhase::Syncing { .. })
-                            && peer.started_at_ms != 0
-                            && now_ms.saturating_sub(peer.started_at_ms)
-                                >= PEER_ADMISSION_DEADLINE_MS
+                            && peer.started_at_ms.is_some_and(|started| {
+                                now_ms.saturating_sub(started)
+                                    >= crate::transport::master::limits::values()
+                                        .admission
+                                        .as_millis() as u64
+                            })
                         {
                             expired.push(*member);
                         }
diff --git a/crates/net/src/transport/archive.rs b/crates/net/src/transport/archive.rs
index 145cf4e..c936372 100644
--- a/crates/net/src/transport/archive.rs
+++ b/crates/net/src/transport/archive.rs
@@ -53,6 +53,8 @@ fn archived_snapshot_bytes(snapshot: &Snapshot) -> usize {
         .sum();
     SNAPSHOT_BASE
         + snapshot.players.len() * core::mem::size_of::<PlayerState>()
+        + snapshot.meta.pellet_fx.len() * core::mem::size_of::<sim::PelletFxRecord>()
+        + snapshot.meta.entity_events.len() * core::mem::size_of::<sim::EntityEventRecord>()
         + snapshot.projectiles.len() * 64
         + snapshot.meta.entities.len() * core::mem::size_of::<entity_iw4::EntityState>()
         + hud_elems * core::mem::size_of::<hud_iw4::HudElem>()
@@ -98,6 +100,9 @@ impl FrameArchive {
     }
 
     pub fn push(&mut self, frame: ArchivedFrame) -> bool {
+        if frame.bytes() > ARCHIVE_BYTE_BUDGET {
+            return false;
+        }
         if let Some(newest) = self.frames.back()
             && frame.tick.0 <= newest.tick.0
         {
diff --git a/crates/net/src/transport/bootstrap.rs b/crates/net/src/transport/bootstrap.rs
index b5386d9..a7141f6 100644
--- a/crates/net/src/transport/bootstrap.rs
+++ b/crates/net/src/transport/bootstrap.rs
@@ -225,8 +225,15 @@ pub struct BootstrapAck {
 
 pub struct BootstrapLane {
     pub(super) host_map_ready: Mutex<HashSet<master_protocol::MemberId>>,
-    to_worker: Mutex<VecDeque<(Option<master_protocol::MemberId>, Vec<u8>)>>,
-    from_worker: Mutex<VecDeque<BootstrapIngress>>,
+    to_worker: Mutex<
+        VecDeque<(
+            Option<master_protocol::MemberId>,
+            Vec<u8>,
+            std::time::Instant,
+        )>,
+    >,
+    from_worker: Mutex<VecDeque<(BootstrapIngress, std::time::Instant)>>,
+    fault: Mutex<Option<&'static str>>,
     acks: Mutex<VecDeque<BootstrapAck>>,
     epoch: AtomicU32,
     entered_bootstrap: AtomicU32,
@@ -240,6 +247,7 @@ impl BootstrapLane {
             to_worker: Mutex::new(VecDeque::new()),
             from_worker: Mutex::new(VecDeque::new()),
             acks: Mutex::new(VecDeque::new()),
+            fault: Mutex::new(None),
             epoch: AtomicU32::new(0),
             entered_bootstrap: AtomicU32::new(0),
             entered_client: AtomicU32::new(0),
@@ -249,6 +257,7 @@ impl BootstrapLane {
     pub fn set_epoch(&self, epoch: u32) {
         let prev = self.epoch.swap(epoch, Ordering::AcqRel);
         if prev != epoch {
+            *self.fault.lock().expect("bootstrap fault poisoned") = None;
             self.host_map_ready
                 .lock()
                 .expect("bootstrap readiness poisoned")
@@ -291,16 +300,36 @@ impl BootstrapLane {
         bytes: Vec<u8>,
     ) -> Result<(), &'static str> {
         let mut queue = self.to_worker.lock().expect("bootstrap lane poisoned");
-        if queue.len() >= MAX_BOOTSTRAP_PENDING {
+        if queue.len() >= MAX_BOOTSTRAP_PENDING.min(super::master::limits::values().queue_items)
+            || bytes.len() > master_protocol::MAX_BOOTSTRAP_STREAM_BYTES
+            || queue.iter().map(|(_, bytes, _)| bytes.len()).sum::<usize>() + bytes.len()
+                > super::master::limits::values().queue_bytes
+        {
             return Err("bootstrap to-worker queue is full");
         }
-        queue.push_back((peer, bytes));
+        queue.push_back((
+            peer,
+            bytes,
+            std::time::Instant::now() + super::master::limits::values().queue_age,
+        ));
         Ok(())
     }
 
     pub fn take_to_worker(&self) -> Vec<(Option<master_protocol::MemberId>, Vec<u8>)> {
         let mut queue = self.to_worker.lock().expect("bootstrap lane poisoned");
-        queue.drain(..).collect()
+        let entries: Vec<_> = queue.drain(..).collect();
+        if entries
+            .iter()
+            .any(|(_, _, deadline)| *deadline <= std::time::Instant::now())
+        {
+            *self.fault.lock().expect("bootstrap fault poisoned") =
+                Some("bootstrap queue deadline");
+            return Vec::new();
+        }
+        entries
+            .into_iter()
+            .map(|(peer, bytes, _)| (peer, bytes))
+            .collect()
     }
 
     pub fn push_from_worker(
@@ -309,16 +338,60 @@ impl BootstrapLane {
         bytes: Vec<u8>,
     ) -> Result<(), &'static str> {
         let mut queue = self.from_worker.lock().expect("bootstrap lane poisoned");
-        if queue.len() >= MAX_BOOTSTRAP_PENDING {
+        if queue.len() >= MAX_BOOTSTRAP_PENDING.min(super::master::limits::values().queue_items)
+            || bytes.len() > master_protocol::MAX_BOOTSTRAP_STREAM_BYTES
+            || queue
+                .iter()
+                .map(|(entry, _)| entry.bytes.len())
+                .sum::<usize>()
+                + bytes.len()
+                > super::master::limits::values().queue_bytes
+        {
             return Err("bootstrap from-worker queue is full");
         }
-        queue.push_back(BootstrapIngress { member_id, bytes });
+        queue.push_back((
+            BootstrapIngress { member_id, bytes },
+            std::time::Instant::now() + super::master::limits::values().queue_age,
+        ));
         Ok(())
     }
 
     pub fn take_from_worker(&self) -> Vec<BootstrapIngress> {
         let mut queue = self.from_worker.lock().expect("bootstrap lane poisoned");
-        queue.drain(..).collect()
+        let entries: Vec<_> = queue.drain(..).collect();
+        if entries
+            .iter()
+            .any(|(_, deadline)| *deadline <= std::time::Instant::now())
+        {
+            *self.fault.lock().expect("bootstrap fault poisoned") =
+                Some("bootstrap ingress queue deadline");
+            return Vec::new();
+        }
+        entries.into_iter().map(|(entry, _)| entry).collect()
+    }
+
+    pub fn check_deadline(&self) -> Result<(), &'static str> {
+        let now = std::time::Instant::now();
+        if self
+            .to_worker
+            .lock()
+            .expect("bootstrap lane poisoned")
+            .iter()
+            .any(|(_, _, deadline)| *deadline <= now)
+            || self
+                .from_worker
+                .lock()
+                .expect("bootstrap lane poisoned")
+                .iter()
+                .any(|(_, deadline)| *deadline <= now)
+        {
+            *self.fault.lock().expect("bootstrap fault poisoned") =
+                Some("bootstrap queue deadline");
+        }
+        match *self.fault.lock().expect("bootstrap fault poisoned") {
+            Some(fault) => Err(fault),
+            None => Ok(()),
+        }
     }
 
     pub fn push_ack(&self, ack: BootstrapAck) -> Result<(), &'static str> {
diff --git a/crates/net/src/transport/master.rs b/crates/net/src/transport/master.rs
index 639a511..cfede4f 100644
--- a/crates/net/src/transport/master.rs
+++ b/crates/net/src/transport/master.rs
@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant};
 
 use bevy::prelude::*;
 use master_protocol::{
@@ -29,6 +29,7 @@ use crate::transport::fragment::{Fragmenter, Reassembler};
 use crate::transport::protocol::{ContentFingerprint, HandshakeHello, MatchDescriptor};
 use crate::transport::udp_session::{RelayMailbox, UdpAuthorityHub, UdpClientLink};
 
+pub(crate) mod limits;
 mod population;
 pub use population::CommunityPlayerCounts;
 
@@ -59,16 +60,105 @@ pub fn content_names(flags: ContentFlags) -> String {
 
 const RELAY_PACKET_BYTES: usize = crate::transport::protocol::MAX_PACKET_BYTES as usize;
 const HOST_DATA_CAP: usize = 64;
-const HOST_CONTROL_CAP: usize = 32;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum MasterOperationOutcome {
+    Succeeded,
+    Refused(String),
+    RemoteOutcomeUnknown(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct MasterOperationResult {
+    pub request_id: u64,
+    pub outcome: MasterOperationOutcome,
+}
+
+struct QueuedControl {
+    frame: ControlFrame,
+    deadline: tokio::time::Instant,
+    _bytes: tokio::sync::OwnedSemaphorePermit,
+}
+
+struct ControlSender {
+    tx: tokio::sync::mpsc::Sender<QueuedControl>,
+    pending: Mutex<HashMap<u64, tokio::time::Instant>>,
+    outcomes: Arc<Mutex<VecDeque<MasterOperationResult>>>,
+    bytes: Arc<tokio::sync::Semaphore>,
+}
+
+impl ControlSender {
+    fn complete_response(&self, response: &ControlResponse) -> Option<tokio::time::Instant> {
+        let deadline = self
+            .pending
+            .lock()
+            .expect("control requests poisoned")
+            .remove(&response.request_id)?;
+        let outcome = if deadline <= tokio::time::Instant::now() {
+            MasterOperationOutcome::RemoteOutcomeUnknown("response deadline".into())
+        } else if let ResponseBody::Error(error) = &response.body {
+            MasterOperationOutcome::Refused(error.to_string())
+        } else {
+            MasterOperationOutcome::Succeeded
+        };
+        self.outcomes
+            .lock()
+            .expect("control outcomes poisoned")
+            .push_back(MasterOperationResult {
+                request_id: response.request_id,
+                outcome,
+            });
+        Some(deadline)
+    }
+
+    fn close_pending(&self) {
+        let mut pending = self.pending.lock().expect("control requests poisoned");
+        let mut outcomes = self.outcomes.lock().expect("control outcomes poisoned");
+        outcomes.extend(
+            pending
+                .drain()
+                .map(|(request_id, _)| MasterOperationResult {
+                    request_id,
+                    outcome: MasterOperationOutcome::RemoteOutcomeUnknown(
+                        "connection closed before correlated response".into(),
+                    ),
+                }),
+        );
+    }
+
+    fn expire(&self, role: &'static str) -> std::result::Result<(), TransportFault> {
+        let now = tokio::time::Instant::now();
+        let mut pending = self.pending.lock().expect("control requests poisoned");
+        if let Some(id) = pending
+            .iter()
+            .find_map(|(id, deadline)| (*deadline <= now).then_some(*id))
+        {
+            pending.remove(&id);
+            self.outcomes
+                .lock()
+                .expect("control outcomes poisoned")
+                .push_back(MasterOperationResult {
+                    request_id: id,
+                    outcome: MasterOperationOutcome::RemoteOutcomeUnknown(
+                        "response deadline".into(),
+                    ),
+                });
+            return Err(TransportFault::new(
+                "control_response",
+                role,
+                format!("request {id} deadline; remote outcome unknown"),
+            ));
+        }
+        Ok(())
+    }
+}
 
 const BOOTSTRAP_PRIORITY: i32 = -32;
 const DNS_DEADLINE: Duration = Duration::from_secs(8);
 const CONNECT_RETRY_FIRST: Duration = Duration::from_secs(1);
 const CONNECT_RETRY_MAX: Duration = Duration::from_secs(6);
 const CONNECT_RACE: usize = 4;
-const CONNECT_BUDGET: Duration = SESSION_IDLE;
 const CLIENT_KEEP_ALIVE: Duration = Duration::from_millis(250);
-const LEAVE_DRAIN: Duration = Duration::from_millis(500);
 const DATAGRAM_SEND_BUFFER: usize = 1024 * 1024;
 const QUEUE_POLL: Duration = Duration::from_millis(5);
 const WATCHDOG_INTERVAL: Duration = Duration::from_secs(1);
@@ -80,10 +170,12 @@ fn blocking_runtime() -> std::io::Result<tokio::runtime::Runtime> {
 }
 
 fn now_ms() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis() as u64)
-        .unwrap_or(0)
+    static START: std::sync::OnceLock<Instant> = std::sync::OnceLock::new();
+    START
+        .get_or_init(Instant::now)
+        .elapsed()
+        .as_millis()
+        .min(u64::MAX as u128) as u64
 }
 
 fn endpoint_build() -> String {
@@ -103,9 +195,52 @@ fn relay_reassembler() -> Reassembler {
     Reassembler::new(master_protocol::MAX_OPAQUE_PAYLOAD, RELAY_PACKET_BYTES)
 }
 
-fn take_commands(commands: &Mutex<Vec<MasterBridgeCommand>>) -> Vec<MasterBridgeCommand> {
+struct QueuedCommand {
+    command: MasterBridgeCommand,
+    deadline: tokio::time::Instant,
+}
+
+fn take_commands(
+    commands: &Mutex<Vec<QueuedCommand>>,
+    role: &'static str,
+) -> std::result::Result<Vec<MasterBridgeCommand>, TransportFault> {
     let mut queue = commands.lock().expect("master command queue poisoned");
-    std::mem::take(&mut *queue)
+    let commands = std::mem::take(&mut *queue);
+    if commands
+        .iter()
+        .any(|command| command.deadline <= tokio::time::Instant::now())
+    {
+        return Err(TransportFault::new(
+            "local_command",
+            role,
+            "command queue deadline",
+        ));
+    }
+    Ok(commands
+        .into_iter()
+        .map(|command| command.command)
+        .collect())
+}
+
+async fn command_deadline(
+    commands: &Mutex<Vec<QueuedCommand>>,
+    role: &'static str,
+) -> TransportFault {
+    loop {
+        if commands
+            .lock()
+            .expect("master command queue poisoned")
+            .iter()
+            .any(|command| command.deadline <= tokio::time::Instant::now())
+        {
+            return TransportFault::new(
+                "local_command",
+                role,
+                "command expired before connection; not sent",
+            );
+        }
+        tokio::time::sleep(QUEUE_POLL).await;
+    }
 }
 
 fn classify_try_send<T>(
@@ -485,7 +620,9 @@ enum MasterBridgeCommand {
     MatchEnded {
         match_key: frame::MatchKey,
     },
-    AuthorityProgress,
+    AuthorityProgress {
+        now_ms: u64,
+    },
     AdmitEnter {
         member_id: MemberId,
         epoch: u32,
@@ -496,6 +633,19 @@ enum MasterBridgeCommand {
     Shutdown,
 }
 
+impl MasterBridgeCommand {
+    fn queued_bytes(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + match self {
+                Self::SetPassword { password } => password.capacity(),
+                Self::UpdateLobby { map, mode } | Self::StartMatch { map, mode } => {
+                    map.capacity() + mode.capacity()
+                }
+                _ => 0,
+            }
+    }
+}
+
 #[derive(Resource, Default)]
 pub struct PendingMasterMenuAction(pub Option<MasterMenuAction>);
 
@@ -623,7 +773,8 @@ impl MasterBridgeState {
 #[derive(Resource)]
 pub struct MasterBridge {
     state: Arc<Mutex<MasterBridgeState>>,
-    commands: Arc<Mutex<Vec<MasterBridgeCommand>>>,
+    commands: Arc<Mutex<Vec<QueuedCommand>>>,
+    outcomes: Arc<Mutex<VecDeque<MasterOperationResult>>>,
     installed_load: Arc<Mutex<Option<frame::LocalLoadKey>>>,
     mailbox: RelayMailbox,
     bootstrap: Arc<BootstrapLane>,
@@ -652,15 +803,52 @@ impl MasterBridge {
         self.close.cancel();
     }
 
+    pub fn take_operation_results(&self) -> Vec<MasterOperationResult> {
+        self.outcomes
+            .lock()
+            .expect("control outcomes poisoned")
+            .drain(..)
+            .collect()
+    }
+
     pub fn mailbox(&self) -> RelayMailbox {
         self.mailbox.clone()
     }
 
     fn send(&self, command: MasterBridgeCommand) {
-        self.commands
-            .lock()
-            .expect("master command queue poisoned")
-            .push(command);
+        let mut commands = self.commands.lock().expect("master command queue poisoned");
+        if matches!(command, MasterBridgeCommand::AuthorityProgress { .. })
+            && let Some(queued) = commands.iter_mut().find(|queued| {
+                matches!(
+                    queued.command,
+                    MasterBridgeCommand::AuthorityProgress { .. }
+                )
+            })
+        {
+            queued.command = command;
+            return;
+        }
+        if commands.len() >= limits::values().queue_items
+            || commands
+                .iter()
+                .map(|queued| queued.command.queued_bytes())
+                .sum::<usize>()
+                .saturating_add(command.queued_bytes())
+                > limits::values().queue_bytes
+        {
+            drop(commands);
+            publish_failed(
+                &self.state,
+                self.state().identity(),
+                TransportFault::new("local_command", "local", "command budget exhausted"),
+            );
+            self.close.cancel();
+            return;
+        }
+        commands.push(QueuedCommand {
+            command,
+            deadline: tokio::time::Instant::now() + limits::values().queue_age,
+        });
     }
 
     pub fn set_installed_load(&self, load: Option<frame::LocalLoadKey>) {
@@ -692,7 +880,7 @@ impl MasterBridge {
     }
 
     pub fn report_authority_progress(&self) {
-        self.send(MasterBridgeCommand::AuthorityProgress);
+        self.send(MasterBridgeCommand::AuthorityProgress { now_ms: now_ms() });
     }
 
     pub fn report_match_ended(&self, match_key: frame::MatchKey) {
@@ -736,7 +924,10 @@ impl MasterBridge {
 impl Drop for MasterBridge {
     fn drop(&mut self) {
         if let Ok(mut queue) = self.commands.lock() {
-            queue.push(MasterBridgeCommand::Shutdown);
+            queue.push(QueuedCommand {
+                command: MasterBridgeCommand::Shutdown,
+                deadline: tokio::time::Instant::now() + limits::values().shutdown,
+            });
         }
         self.close.cancel();
         let _ = self.worker.take();
@@ -1112,9 +1303,11 @@ async fn browse(
             }),
         )
         .await?;
+        let response_deadline = tokio::time::Instant::now() + limits::values().response;
         let (generation, adverts) = loop {
             let frame = tokio::select! {
                 _ = cancel.cancelled() => return Ok(()),
+                _ = tokio::time::sleep_until(response_deadline) => return Err("room list response deadline".into()),
                 frame = read_frame(&mut recv) => frame?,
             };
             match frame {
@@ -1127,9 +1320,9 @@ async fn browse(
                         },
                 }) if id == request_id => break (generation, adverts),
                 ControlFrame::Response(ControlResponse {
+                    request_id: id,
                     body: ResponseBody::Error(error),
-                    ..
-                }) => return Err(error.into()),
+                }) if id == request_id => return Err(error.into()),
                 ControlFrame::Response(_)
                 | ControlFrame::RoomView(_)
                 | ControlFrame::Closed { .. }
@@ -1188,7 +1381,8 @@ async fn wait_for_refresh(refresh: &AtomicU64, cancel: &CancellationToken) -> bo
 struct WorkerCtx {
     player_name: String,
     state: Arc<Mutex<MasterBridgeState>>,
-    commands: Arc<Mutex<Vec<MasterBridgeCommand>>>,
+    commands: Arc<Mutex<Vec<QueuedCommand>>>,
+    outcomes: Arc<Mutex<VecDeque<MasterOperationResult>>>,
     installed_load: Arc<Mutex<Option<frame::LocalLoadKey>>>,
     mailbox: RelayMailbox,
     bootstrap: Arc<BootstrapLane>,
@@ -1223,6 +1417,7 @@ fn spawn_worker(role: &'static str, kind: SessionKind, player_name: String) -> M
     }
     let state = Arc::new(Mutex::new(MasterBridgeState::Connecting { identity }));
     let commands = Arc::new(Mutex::new(Vec::new()));
+    let outcomes = Arc::new(Mutex::new(VecDeque::new()));
     let installed_load = Arc::new(Mutex::new(None));
     let bootstrap = BootstrapLane::new();
     let mailbox = RelayMailbox::new(HOST_DATA_CAP);
@@ -1234,6 +1429,7 @@ fn spawn_worker(role: &'static str, kind: SessionKind, player_name: String) -> M
         player_name,
         state: Arc::clone(&state),
         commands: Arc::clone(&commands),
+        outcomes: Arc::clone(&outcomes),
         installed_load: Arc::clone(&installed_load),
         mailbox: mailbox.clone(),
         bootstrap: Arc::clone(&bootstrap),
@@ -1257,6 +1453,7 @@ fn spawn_worker(role: &'static str, kind: SessionKind, player_name: String) -> M
     MasterBridge {
         state,
         commands,
+        outcomes,
         installed_load,
         mailbox,
         bootstrap,
@@ -1382,6 +1579,8 @@ fn report_committed_authority_progress(
     bridge: Option<Res<MasterBridge>>,
     server_tick: Option<Res<crate::authority::runtime::ServerTick>>,
     hold: Option<Res<crate::AuthorityLoadHold>>,
+    installed: Option<Res<frame::InstalledMatch>>,
+    mut reported: Local<Option<(u64, frame::LocalLoadKey, sim::Tick)>>,
 ) {
     let Some(bridge) = bridge else {
         return;
@@ -1389,9 +1588,23 @@ fn report_committed_authority_progress(
     if hold.is_some_and(|hold| hold.0) {
         return;
     }
-    if server_tick.is_some_and(|tick| tick.0.is_some()) {
-        bridge.report_authority_progress();
+    let (Some(installed), Some(tick)) = (
+        installed,
+        server_tick
+            .as_ref()
+            .and_then(|tick| tick.0.as_ref())
+            .map(|tick| tick.snapshot.tick),
+    ) else {
+        return;
+    };
+    let context = (bridge.incarnation(), installed.load_key);
+    if reported.is_some_and(|(incarnation, key, previous)| {
+        (incarnation, key) == context && tick.0 <= previous.0
+    }) {
+        return;
     }
+    *reported = Some((context.0, context.1, tick));
+    bridge.report_authority_progress();
 }
 
 fn open_hosted_epoch_when_world_is_live(
@@ -1449,6 +1662,14 @@ fn observe_master_bridge(
     let Some(bridge) = bridge else {
         return;
     };
+    for result in bridge.take_operation_results() {
+        diag::info!(
+            Net,
+            "master operation: request={} outcome={:?}",
+            result.request_id,
+            result.outcome
+        );
+    }
     let current = bridge.state();
     let identity = current.identity();
     if current.in_match()
@@ -1532,7 +1753,7 @@ fn execute_host_match_effects(
     effects: Vec<HostMatchEffect>,
     map_ready: &Mutex<HashSet<MemberId>>,
     facts: &Mutex<Vec<MasterLifecycleFact>>,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: &ControlSender,
     request_id: &mut u64,
     role: &'static str,
 ) -> std::result::Result<(), TransportFault> {
@@ -1633,6 +1854,7 @@ async fn session_main(
         player_name,
         state,
         commands,
+        outcomes,
         installed_load,
         mailbox,
         bootstrap,
@@ -1667,9 +1889,11 @@ async fn session_main(
         target.server_name,
         endpoint_build()
     );
-    let (_endpoint, connection) = connect(&target, &cancel)
-        .await
-        .map_err(|error| TransportFault::new("connect", role, error.to_string()))?;
+    let (_endpoint, connection) = tokio::select! {
+        _ = close.cancelled() => return Ok(()),
+        fault = command_deadline(&commands, role) => return Err(fault),
+        result = connect(&target, &cancel) => result.map_err(|error| TransportFault::new("connect", role, error.to_string()))?,
+    };
     diag::info!(
         Net,
         "master {role} hello build={} wire={} game={} attempt={}",
@@ -1697,7 +1921,14 @@ async fn session_main(
     .await
     .map_err(|error| TransportFault::with_connection("hello", role, error, &connection))?;
 
-    let (control_tx, mut control_rx) = tokio::sync::mpsc::channel::<ControlFrame>(HOST_CONTROL_CAP);
+    let (tx, mut control_rx) =
+        tokio::sync::mpsc::channel::<QueuedControl>(limits::values().queue_items);
+    let control_tx = ControlSender {
+        tx,
+        pending: Mutex::new(HashMap::new()),
+        outcomes,
+        bytes: Arc::new(tokio::sync::Semaphore::new(limits::values().queue_bytes)),
+    };
     let mut children = tokio::task::JoinSet::new();
     {
         let writer_connection = connection.clone();
@@ -1710,7 +1941,10 @@ async fn session_main(
                     _ = writer_cancel.cancelled() => return Ok(()),
                     frame = control_rx.recv() => {
                         let Some(frame) = frame else { return Ok(()) };
-                        write_frame(&mut writer, &frame).await.map_err(|error| {
+                        tokio::time::timeout_at(frame.deadline, write_frame(&mut writer, &frame.frame))
+                            .await
+                            .map_err(|_| TransportFault::new("control_write", writer_role, "control queue/write deadline"))?
+                            .map_err(|error| {
                             TransportFault::with_connection(
                                 "control_write",
                                 writer_role,
@@ -1743,10 +1977,12 @@ async fn session_main(
         role,
         is_host,
     ));
-    let (bootstrap_jobs, bootstrap_rx) =
-        tokio::sync::mpsc::channel::<(frame::MatchKey, MemberId, Vec<u8>)>(
-            MAX_CONCURRENT_BOOTSTRAP as usize,
-        );
+    let (bootstrap_tx, bootstrap_rx) =
+        tokio::sync::mpsc::channel::<BootstrapJob>(MAX_CONCURRENT_BOOTSTRAP as usize);
+    let bootstrap_jobs = BootstrapSender {
+        tx: bootstrap_tx,
+        bytes: Arc::new(tokio::sync::Semaphore::new(limits::values().queue_bytes)),
+    };
     let (prepared_tx, mut prepared_rx) =
         tokio::sync::mpsc::channel::<HostMatchEvent>(MAX_CONCURRENT_BOOTSTRAP as usize);
     children.spawn(bootstrap_egress(
@@ -1806,6 +2042,9 @@ async fn session_main(
         if cancel.is_cancelled() {
             break Ok(());
         }
+        if !closing && let Err(error) = control_tx.expire(role) {
+            break Err(error);
+        }
         if !closing
             && let Err(error) = pump_local_queues(
                 identity.match_key(),
@@ -1820,6 +2059,9 @@ async fn session_main(
         {
             break Err(error);
         }
+        if let Err(error) = mailbox.check_control_deadlines() {
+            break Err(TransportFault::new("relay_queue", role, error));
+        }
         let mut control_error = None;
         for (member_id, payload) in mailbox.take_control_outbound() {
             let envelope = if is_host {
@@ -1853,7 +2095,11 @@ async fn session_main(
             break Err(error);
         }
         let mut command_error = None;
-        for command in take_commands(&commands) {
+        let queued = match take_commands(&commands, role) {
+            Ok(commands) => commands,
+            Err(error) => break Err(error),
+        };
+        for command in queued {
             match handle_command(
                 command,
                 &installed_load,
@@ -1875,7 +2121,7 @@ async fn session_main(
                     );
                     closing = true;
                     leave_request = Some(request_id);
-                    leave_at = Some(tokio::time::Instant::now() + LEAVE_DRAIN);
+                    leave_at = Some(tokio::time::Instant::now() + limits::values().shutdown);
                 }
                 Err(error) => {
                     command_error = Some(error);
@@ -1888,7 +2134,14 @@ async fn session_main(
         }
         tokio::select! {
             _ = cancel.cancelled() => break Ok(()),
-            _ = close.cancelled(), if !closing => {}
+            _ = close.cancelled(), if !closing => {
+                let id = take_id(&mut request_id);
+                let body = if is_host { RequestBody::CloseRoom } else { RequestBody::LeaveRoom };
+                if let Err(error) = enqueue_control(&control_tx, ControlFrame::Request(ControlRequest { request_id: id, body }), role) { break Err(error); }
+                closing = true;
+                leave_request = Some(id);
+                leave_at = Some(tokio::time::Instant::now() + limits::values().shutdown);
+            }
             _ = async {
                 match leave_at {
                     Some(at) => tokio::time::sleep_until(at).await,
@@ -1898,7 +2151,7 @@ async fn session_main(
                 diag::warn!(
                     Net,
                     "master {role} closed: relay did not confirm within {}ms",
-                    LEAVE_DRAIN.as_millis()
+                    limits::values().shutdown.as_millis()
                 );
                 break Ok(());
             }
@@ -1938,6 +2191,9 @@ async fn session_main(
                 }
             }
             (recv, frame) = async {
+                while facts.lock().expect("master facts poisoned").len() >= limits::values().queue_items.max(master_protocol::MAX_SESSION_MEMBERS as usize + 1) {
+                    tokio::time::sleep(QUEUE_POLL).await;
+                }
                 mailbox.wait_control_inbound_capacity().await;
                 (&mut next_control).await
             } => {
@@ -2012,10 +2268,11 @@ async fn session_main(
         }
     };
 
+    control_tx.close_pending();
     cancel.cancel();
     connection.close(0_u8.into(), b"session closed");
     drop(bootstrap_jobs);
-    let _ = tokio::time::timeout(LEAVE_DRAIN, async {
+    let _ = tokio::time::timeout(limits::values().shutdown, async {
         while children.join_next().await.is_some() {}
     })
     .await;
@@ -2037,19 +2294,46 @@ fn take_id(request_id: &mut u64) -> u64 {
 }
 
 fn enqueue_control(
-    tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    tx: &ControlSender,
     frame: ControlFrame,
     role: &'static str,
 ) -> std::result::Result<(), TransportFault> {
-    classify_try_send(tx.try_send(frame), "control_write").map_err(|loss| {
-        TransportFault::new(
-            match loss {
-                QueueLoss::Full { operation } | QueueLoss::Closed { operation } => operation,
-            },
+    let encoded = encode_stream_frame(&frame)
+        .map_err(|error| TransportFault::new("control_encode", role, error.to_string()))?;
+    let bytes = tx
+        .bytes
+        .clone()
+        .try_acquire_many_owned(encoded.len() as u32)
+        .map_err(|_| TransportFault::new("control_write", role, "control byte budget exhausted"))?;
+    let deadline = tokio::time::Instant::now() + limits::values().queue_age;
+    let id = match &frame {
+        ControlFrame::Request(request) => Some(request.request_id),
+        _ => None,
+    };
+    let mut pending = tx.pending.lock().expect("control requests poisoned");
+    if id.is_some()
+        && pending.len() + tx.outcomes.lock().expect("control outcomes poisoned").len()
+            >= limits::values().queue_items
+    {
+        return Err(TransportFault::new(
+            "control_request",
             role,
-            loss.to_string(),
-        )
-    })
+            "pending request budget exhausted",
+        ));
+    }
+    classify_try_send(
+        tx.tx.try_send(QueuedControl {
+            frame,
+            deadline,
+            _bytes: bytes,
+        }),
+        "control_write",
+    )
+    .map_err(|loss| TransportFault::new("control_write", role, loss.to_string()))?;
+    if let Some(id) = id {
+        pending.insert(id, tokio::time::Instant::now() + limits::values().response);
+    }
+    Ok(())
 }
 
 fn flatten_task(
@@ -2202,7 +2486,7 @@ fn sync_membership_facts(
 fn handle_command(
     command: MasterBridgeCommand,
     installed_load: &Mutex<Option<frame::LocalLoadKey>>,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: &ControlSender,
     request_id: &mut u64,
     facts: &Mutex<Vec<MasterLifecycleFact>>,
     host_match: &mut HostMatchCore,
@@ -2369,14 +2653,11 @@ fn handle_command(
                 role,
             )?;
         }
-        MasterBridgeCommand::AuthorityProgress => {
+        MasterBridgeCommand::AuthorityProgress { now_ms } => {
             if !is_host {
                 return Ok(CommandEffect::Continue);
             }
-            let applied = apply_host(
-                host_match,
-                HostMatchEvent::AuthorityProgress { now_ms: now_ms() },
-            );
+            let applied = apply_host(host_match, HostMatchEvent::AuthorityProgress { now_ms });
             execute_host_match_effects(
                 applied.effects,
                 map_ready,
@@ -2457,7 +2738,7 @@ fn handle_frame(
     frame: ControlFrame,
     state: &Mutex<MasterBridgeState>,
     facts: &Mutex<Vec<MasterLifecycleFact>>,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: &ControlSender,
     request_id: &mut u64,
     bootstrap: &BootstrapLane,
     session: &mut SessionCore,
@@ -2484,6 +2765,20 @@ fn handle_frame(
             "service sent a request on the client stream",
         )),
         ControlFrame::Response(response) => {
+            let deadline = control_tx.complete_response(&response);
+            let Some(deadline) = deadline else {
+                return Ok(());
+            };
+            if deadline <= tokio::time::Instant::now() {
+                return Err(TransportFault::new(
+                    "control_response",
+                    role,
+                    format!(
+                        "request {} deadline; remote outcome unknown",
+                        response.request_id
+                    ),
+                ));
+            }
             let (view, member) = match response.body {
                 ResponseBody::RoomCreated { member_id, view }
                 | ResponseBody::RoomJoined { member_id, view } => (view, member_id),
@@ -2581,7 +2876,7 @@ fn apply_room_view(
     local_member: MemberId,
     state: &Mutex<MasterBridgeState>,
     facts: &Mutex<Vec<MasterLifecycleFact>>,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: &ControlSender,
     request_id: &mut u64,
     bootstrap: &BootstrapLane,
     session: &mut SessionCore,
@@ -2631,6 +2926,29 @@ fn apply_room_view(
         )?;
         *started_epoch = view.epoch;
     }
+    if is_host && view.phase.in_match() {
+        let applied = apply_host(
+            host_match,
+            HostMatchEvent::PeerRoster {
+                match_key: identity.match_key(),
+                members: view
+                    .members
+                    .iter()
+                    .copied()
+                    .filter(|member| *member != local_member)
+                    .collect(),
+                now_ms: now_ms(),
+            },
+        );
+        execute_host_match_effects(
+            applied.effects,
+            map_ready,
+            facts,
+            control_tx,
+            request_id,
+            role,
+        )?;
+    }
     if is_host && !view.phase.in_match() && *started_epoch != 0 {
         let applied = apply_host(
             host_match,
@@ -2665,7 +2983,7 @@ fn apply_room_view(
 fn apply_peer_event(
     event: master_protocol::PeerEvent,
     facts: &Mutex<Vec<MasterLifecycleFact>>,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
+    control_tx: &ControlSender,
     request_id: &mut u64,
     session: &mut SessionCore,
     host_match: &mut HostMatchCore,
@@ -2815,9 +3133,22 @@ fn apply_peer_event(
     Ok(())
 }
 
+struct BootstrapSender {
+    tx: tokio::sync::mpsc::Sender<BootstrapJob>,
+    bytes: Arc<tokio::sync::Semaphore>,
+}
+
+struct BootstrapJob {
+    _bytes: tokio::sync::OwnedSemaphorePermit,
+    match_key: frame::MatchKey,
+    member: MemberId,
+    bytes: Vec<u8>,
+    deadline: tokio::time::Instant,
+}
+
 fn enqueue_bootstrap_job(
     match_key: frame::MatchKey,
-    jobs: &tokio::sync::mpsc::Sender<(frame::MatchKey, MemberId, Vec<u8>)>,
+    jobs: &BootstrapSender,
     member: MemberId,
     bytes: Vec<u8>,
     role: &'static str,
@@ -2826,7 +3157,24 @@ fn enqueue_bootstrap_job(
     {
         return Ok(());
     }
-    classify_try_send(jobs.try_send((match_key, member, bytes)), "bootstrap_job").map_err(|loss| {
+    let permit = jobs
+        .bytes
+        .clone()
+        .try_acquire_many_owned(bytes.len() as u32)
+        .map_err(|_| {
+            TransportFault::new("bootstrap_job", role, "bootstrap byte budget exhausted")
+        })?;
+    classify_try_send(
+        jobs.tx.try_send(BootstrapJob {
+            _bytes: permit,
+            match_key,
+            member,
+            bytes,
+            deadline: tokio::time::Instant::now() + limits::values().queue_age,
+        }),
+        "bootstrap_job",
+    )
+    .map_err(|loss| {
         TransportFault::new(
             match loss {
                 QueueLoss::Full { operation } | QueueLoss::Closed { operation } => operation,
@@ -2840,13 +3188,16 @@ fn enqueue_bootstrap_job(
 fn pump_local_queues(
     match_key: frame::MatchKey,
     bootstrap: &BootstrapLane,
-    control_tx: &tokio::sync::mpsc::Sender<ControlFrame>,
-    jobs: &tokio::sync::mpsc::Sender<(frame::MatchKey, MemberId, Vec<u8>)>,
+    control_tx: &ControlSender,
+    jobs: &BootstrapSender,
     role: &'static str,
     is_host: bool,
     request_id: &mut u64,
     map_ready: &Mutex<HashSet<MemberId>>,
 ) -> std::result::Result<(), TransportFault> {
+    bootstrap
+        .check_deadline()
+        .map_err(|error| TransportFault::new("bootstrap_queue", role, error))?;
     for (peer, bytes) in bootstrap.take_to_worker() {
         if is_host {
             let Some(member) = peer else {
@@ -2904,7 +3255,7 @@ fn pump_local_queues(
 
 async fn bootstrap_egress(
     connection: quinn::Connection,
-    mut jobs: tokio::sync::mpsc::Receiver<(frame::MatchKey, MemberId, Vec<u8>)>,
+    mut jobs: tokio::sync::mpsc::Receiver<BootstrapJob>,
     prepared: tokio::sync::mpsc::Sender<HostMatchEvent>,
     cancel: CancellationToken,
     role: &'static str,
@@ -2913,9 +3264,10 @@ async fn bootstrap_egress(
         tokio::select! {
             _ = cancel.cancelled() => return Ok(()),
             job = jobs.recv() => {
-                let Some((match_key, member, bytes)) = job else {
+                let Some(BootstrapJob { match_key, member, bytes, deadline, _bytes }) = job else {
                     return Ok(());
                 };
+                if deadline <= tokio::time::Instant::now() { return Err(TransportFault::new("bootstrap_job", role, "bootstrap queue deadline")); }
                 send_bootstrap_stream(&connection, member, &bytes, &cancel, role).await?;
                 if let Ok(Some(BootstrapMessage::Offer {
                     bootstrap_id,
@@ -2956,7 +3308,7 @@ async fn datagram_ingress(
     role: &'static str,
     is_host: bool,
 ) -> std::result::Result<(), TransportFault> {
-    let mut reassemblers: HashMap<MemberId, Reassembler> = HashMap::new();
+    let mut reassemblers: HashMap<MemberId, (Reassembler, Instant)> = HashMap::new();
     loop {
         tokio::select! {
             _ = cancel.cancelled() => return Ok(()),
@@ -2991,7 +3343,15 @@ async fn datagram_ingress(
                         continue;
                     }
                 };
-                let reassembler = reassemblers.entry(member).or_insert_with(relay_reassembler);
+                let now = Instant::now();
+                reassemblers.retain(|_, (_, seen)| now.duration_since(*seen) < limits::values().queue_age);
+                if !reassemblers.contains_key(&member)
+                    && reassemblers.len() >= master_protocol::MAX_SESSION_MEMBERS as usize
+                {
+                    continue;
+                }
+                let (reassembler, seen) = reassemblers.entry(member).or_insert_with(|| (relay_reassembler(), now));
+                *seen = now;
                 match reassembler.push(payload) {
                     Ok(Some(packet)) => {
                         if mailbox.push_inbound(member, packet) {
@@ -3031,7 +3391,12 @@ async fn uni_ingress(
                 };
                 let bytes = tokio::select! {
                     _ = cancel.cancelled() => return Ok(()),
-                    read = recv.read_to_end(MAX_BOOTSTRAP_STREAM_BYTES) => match read {
+                    read = tokio::time::timeout(limits::values().transfer, read_transfer(&mut recv)) => match read {
+                        Err(_) => {
+                            let _ = recv.stop(0_u8.into());
+                            return Err(TransportFault::new("bootstrap_uni_read", role, "bootstrap transfer deadline"));
+                        }
+                        Ok(read) => match read {
                         Ok(bytes) => bytes,
                         Err(error) => {
                             return Err(TransportFault::with_connection(
@@ -3041,6 +3406,7 @@ async fn uni_ingress(
                                 &connection,
                             ));
                         }
+                        },
                     },
                 };
                 match decode_relay_stream(&bytes) {
@@ -3081,7 +3447,7 @@ async fn gameplay_egress(
     let mut fragmenter = relay_fragmenter();
     // Quinn reserves bookkeeping space even for an empty datagram buffer.
     let empty_buffer_space = connection.datagram_send_buffer_space();
-    let mut pending: VecDeque<(MemberId, Vec<u8>)> = VecDeque::new();
+    let mut pending: VecDeque<(MemberId, Vec<u8>, tokio::time::Instant)> = VecDeque::new();
     let mut tick = tokio::time::interval(QUEUE_POLL);
     let mut sampled = tokio::time::Instant::now();
     loop {
@@ -3104,13 +3470,19 @@ async fn gameplay_egress(
                     // Gameplay packets carry the newest input/snapshot plus
                     // unacknowledged reliable rows. Replace unsent older state
                     // for this peer rather than building a latency backlog.
-                    if let Some((_, previous)) = pending.iter_mut().find(|(id, _)| *id == member) {
+                    if let Some((_, previous, _)) = pending.iter_mut().find(|(id, _, _)| *id == member) {
                         *previous = packet;
                     } else {
-                        pending.push_back((member, packet));
+                        if pending.len() >= master_protocol::MAX_SESSION_MEMBERS as usize {
+                            return Err(TransportFault::new("send_datagram", role, "pending peer budget exhausted"));
+                        }
+                        pending.push_back((member, packet, tokio::time::Instant::now() + limits::values().queue_age));
                     }
                 }
-                while let Some((member, packet)) = pending.front() {
+                while let Some((member, packet, deadline)) = pending.front() {
+                    if *deadline <= tokio::time::Instant::now() {
+                        return Err(TransportFault::new("send_datagram", role, "gameplay queue deadline"));
+                    }
                     let fragments = match fragmenter.split(packet) {
                         Ok(fragments) => fragments,
                         Err(error) => {
@@ -3200,14 +3572,56 @@ async fn send_bootstrap_stream(
     send.set_priority(BOOTSTRAP_PRIORITY).map_err(|error| {
         TransportFault::with_connection("bootstrap_priority", role, error, connection)
     })?;
-    cancellable(cancel, send.write_all(&bytes))
+    let result = tokio::select! {
+        _ = cancel.cancelled() => Err("session canceled".into()),
+        result = tokio::time::timeout(limits::values().transfer, write_transfer(&mut send, &bytes)) =>
+            result.map_err(|_| Error::from("transfer total deadline")).and_then(|result| result),
+    };
+    if result.is_err() {
+        let _ = send.reset(0_u8.into());
+    }
+    result.map_err(|error| {
+        TransportFault::with_connection("bootstrap_uni_write", role, error, connection)
+    })
+}
+
+async fn read_transfer(recv: &mut quinn::RecvStream) -> Result<Vec<u8>> {
+    let mut bytes = Vec::new();
+    loop {
+        let chunk =
+            tokio::time::timeout(limits::values().progress, recv.read_chunk(16 * 1024, true))
+                .await
+                .map_err(|_| "transfer progress deadline")??;
+        let Some(chunk) = chunk else {
+            return Ok(bytes);
+        };
+        if chunk.bytes.is_empty() || bytes.len() + chunk.bytes.len() > MAX_BOOTSTRAP_STREAM_BYTES {
+            return Err("transfer byte budget exceeded".into());
+        }
+        bytes.extend_from_slice(&chunk.bytes);
+    }
+}
+
+async fn write_transfer(send: &mut quinn::SendStream, bytes: &[u8]) -> Result<()> {
+    let mut offset = 0;
+    while offset < bytes.len() {
+        let end = (offset + 16 * 1024).min(bytes.len());
+        let written =
+            tokio::time::timeout(limits::values().progress, send.write(&bytes[offset..end]))
+                .await
+                .map_err(|_| "transfer progress deadline")??;
+        if written == 0 {
+            return Err("transfer made no progress".into());
+        }
+        offset += written;
+    }
+    send.finish()?;
+    if let Some(code) = tokio::time::timeout(limits::values().progress, send.stopped())
         .await
-        .map_err(|error| {
-            TransportFault::with_connection("bootstrap_uni_write", role, error, connection)
-        })?;
-    send.finish().map_err(|error| {
-        TransportFault::with_connection("bootstrap_uni_finish", role, error, connection)
-    })?;
+        .map_err(|_| "transfer acknowledgement deadline")??
+    {
+        return Err(format!("transfer refused with code {code}").into());
+    }
     Ok(())
 }
 
@@ -3228,7 +3642,12 @@ async fn read_frame(recv: &mut quinn::RecvStream) -> Result<ControlFrame> {
 }
 
 async fn write_frame(send: &mut quinn::SendStream, frame: &ControlFrame) -> Result<()> {
-    send.write_all(&encode_stream_frame(frame)?).await?;
+    tokio::time::timeout(
+        limits::values().response,
+        send.write_all(&encode_stream_frame(frame)?),
+    )
+    .await
+    .map_err(|_| "control write deadline")??;
     Ok(())
 }
 
@@ -3238,7 +3657,9 @@ async fn cancellable<T>(
 ) -> Result<T> {
     tokio::select! {
         _ = cancel.cancelled() => Err("session cancelled".into()),
-        result = fut => result.map_err(Into::into),
+        result = tokio::time::timeout(limits::values().response, fut) => {
+            result.map_err(|_| "operation deadline")?.map_err(Into::into)
+        },
     }
 }
 
@@ -3271,9 +3692,6 @@ fn client_config(target: &MasterTarget) -> Result<quinn::ClientConfig> {
     transport.keep_alive_interval(Some(CLIENT_KEEP_ALIVE));
     transport.datagram_send_buffer_size(DATAGRAM_SEND_BUFFER);
     transport.max_concurrent_uni_streams(MAX_RELAY_UNI_STREAMS.into());
-    transport.congestion_controller_factory(Arc::new(
-        master_protocol::congestion::StallTolerantConfig::default(),
-    ));
     client_config.transport_config(Arc::new(transport));
     Ok(client_config)
 }
@@ -3282,10 +3700,17 @@ async fn connect(
     target: &MasterTarget,
     cancel: &CancellationToken,
 ) -> Result<(quinn::Endpoint, quinn::Connection)> {
-    let address = dns_timeout(cancel, tokio::net::lookup_host(target.address.as_str()))
-        .await?
-        .next()
-        .ok_or_else(|| format!("{} resolved no addresses", target.address))?;
+    limits::configured()?;
+    let started = Instant::now();
+    let deadline = tokio::time::Instant::now() + limits::values().connect;
+    let address = tokio::time::timeout_at(
+        deadline,
+        dns_timeout(cancel, tokio::net::lookup_host(target.address.as_str())),
+    )
+    .await
+    .map_err(|_| "connection deadline during address lookup")??
+    .next()
+    .ok_or_else(|| format!("{} resolved no addresses", target.address))?;
     let client_config = client_config(target)?;
     let bind: std::net::SocketAddr = if address.is_ipv4() {
         "0.0.0.0:0"
@@ -3293,8 +3718,6 @@ async fn connect(
         "[::]:0"
     }
     .parse()?;
-    let started = Instant::now();
-    let deadline = tokio::time::Instant::now() + CONNECT_BUDGET;
     let mut attempts = tokio::task::JoinSet::new();
     let mut in_flight = VecDeque::new();
     let mut next_attempt = tokio::time::Instant::now();
diff --git a/crates/net/src/transport/master/limits.rs b/crates/net/src/transport/master/limits.rs
new file mode 100644
index 0000000..2309b96
--- /dev/null
+++ b/crates/net/src/transport/master/limits.rs
@@ -0,0 +1,21 @@
+use master_protocol::budget::TransportBudget;
+use std::sync::OnceLock;
+
+pub(crate) fn configured() -> Result<TransportBudget, String> {
+    static BUDGET: OnceLock<Result<TransportBudget, String>> = OnceLock::new();
+    BUDGET
+        .get_or_init(|| {
+            TransportBudget::from_settings(TransportBudget::SETTINGS.into_iter().filter_map(
+                |name| {
+                    std::env::var(name)
+                        .ok()
+                        .map(|value| (name.to_owned(), value))
+                },
+            ))
+        })
+        .clone()
+}
+
+pub(crate) fn values() -> TransportBudget {
+    configured().unwrap_or_default()
+}
diff --git a/crates/net/src/transport/meta_wire.rs b/crates/net/src/transport/meta_wire.rs
index 5d6467e..e4d46e1 100644
--- a/crates/net/src/transport/meta_wire.rs
+++ b/crates/net/src/transport/meta_wire.rs
@@ -2180,12 +2180,17 @@ fn phase_from_tag(tag: u8) -> Result<MatchPhase, WireError> {
 
 fn encode_corpse_pool(out: &mut WireWriter, pool: &PlayerCorpsePool) {
     out.put_u8(pool.spawn_ring);
+    out.put_u64(pool.next_spawn_sequence);
     for slot in &pool.slots {
         if !slot.occupied {
             out.put_u8(0);
             continue;
         }
         out.put_u8(1);
+        out.put_u64(slot.spawn_sequence);
+        out.put_u8(slot.weapon_model);
+        out.put_i32(slot.client_state_team);
+        out.put_u8(slot.ffa_team.unwrap_or(u8::MAX));
         out.put_u32(slot.victim.0);
         for v in slot.origin {
             out.put_f32(v);
@@ -2218,8 +2223,13 @@ fn encode_corpse_pool(out: &mut WireWriter, pool: &PlayerCorpsePool) {
 
 fn decode_corpse_pool(input: &mut WireReader<'_>) -> Result<PlayerCorpsePool, WireError> {
     let spawn_ring = input.get_u8()?;
+    let next_spawn_sequence = input.get_u64()?;
+    if spawn_ring >= playerstate_iw4::MAX_CLIENT_CORPSES as u8 {
+        return Err(WireError::Malformed("corpse ring outside slots"));
+    }
     let mut pool = PlayerCorpsePool {
         spawn_ring,
+        next_spawn_sequence,
         ..PlayerCorpsePool::default()
     };
     for slot in &mut pool.slots {
@@ -2228,6 +2238,13 @@ fn decode_corpse_pool(input: &mut WireReader<'_>) -> Result<PlayerCorpsePool, Wi
             1 => {
                 *slot = PlayerCorpseSlot {
                     occupied: true,
+                    spawn_sequence: input.get_u64()?,
+                    weapon_model: input.get_u8()?,
+                    client_state_team: input.get_i32()?,
+                    ffa_team: {
+                        let team = input.get_u8()?;
+                        (team != u8::MAX).then_some(team)
+                    },
                     victim: ClientId(input.get_u32()?),
                     origin: [input.get_f32()?, input.get_f32()?, input.get_f32()?],
                     viewangles: [input.get_f32()?, input.get_f32()?, input.get_f32()?],
@@ -2249,10 +2266,32 @@ fn decode_corpse_pool(input: &mut WireReader<'_>) -> Result<PlayerCorpsePool, Wi
                     spawn_time_ms: input.get_i32()?,
                     shield: decode_corpse_shield(input)?,
                 };
+                if slot.spawn_sequence == 0 || slot.spawn_sequence > next_spawn_sequence {
+                    return Err(WireError::Malformed("invalid corpse spawn sequence"));
+                }
             }
             _ => return Err(WireError::Malformed("bad corpse slot tag")),
         }
     }
+    let mut identities = std::collections::HashSet::new();
+    let mut entities = std::collections::HashSet::new();
+    for slot in pool.slots.iter().filter(|slot| slot.occupied) {
+        if !identities.insert(slot.spawn_sequence)
+            || !entities.insert(slot.entnum)
+            || slot.entnum < playerstate_iw4::PLAYER_CORPSE_ENTITY_BASE
+            || slot.entnum
+                >= playerstate_iw4::PLAYER_CORPSE_ENTITY_BASE + playerstate_iw4::MAX_CLIENT_CORPSES
+            || slot
+                .origin
+                .iter()
+                .chain(slot.viewangles.iter())
+                .chain(slot.tr_base.iter())
+                .chain(slot.tr_delta.iter())
+                .any(|n| !n.is_finite())
+        {
+            return Err(WireError::Malformed("invalid corpse occupancy"));
+        }
+    }
     Ok(pool)
 }
 
diff --git a/crates/net/src/transport/udp_session.rs b/crates/net/src/transport/udp_session.rs
index fe1c433..e68f21f 100644
--- a/crates/net/src/transport/udp_session.rs
+++ b/crates/net/src/transport/udp_session.rs
@@ -36,9 +36,9 @@ pub(crate) const CMDS_PER_PACKET: usize = 16;
 pub struct RelayMailbox {
     inbound: Arc<Mutex<DataLanes>>,
     outbound: Arc<Mutex<DataLanes>>,
-    control_inbound: Arc<Mutex<Vec<(MemberId, Vec<u8>)>>>,
+    control_inbound: Arc<Mutex<Vec<(MemberId, Vec<u8>, std::time::Instant)>>>,
     control_inbound_drained: Arc<tokio::sync::Notify>,
-    control_outbound: Arc<Mutex<Vec<(MemberId, Vec<u8>)>>>,
+    control_outbound: Arc<Mutex<Vec<(MemberId, Vec<u8>, std::time::Instant)>>>,
     cap: usize,
 }
 
@@ -95,6 +95,21 @@ impl RelayMailbox {
         take_mail(&self.control_outbound)
     }
 
+    pub(crate) fn check_control_deadlines(&self) -> Result<(), &'static str> {
+        let now = std::time::Instant::now();
+        for queue in [&self.control_inbound, &self.control_outbound] {
+            if queue
+                .lock()
+                .expect("relay mailbox poisoned")
+                .iter()
+                .any(|(_, _, deadline)| *deadline <= now)
+            {
+                return Err("reliable gameplay queue deadline");
+            }
+        }
+        Ok(())
+    }
+
     pub fn with_default_cap() -> Self {
         Self::new(RELAY_MAIL_CAP)
     }
@@ -118,24 +133,47 @@ impl RelayMailbox {
 
 #[derive(Debug, Default)]
 struct DataLanes {
-    lanes: BTreeMap<MemberId, VecDeque<Vec<u8>>>,
+    lanes: BTreeMap<MemberId, VecDeque<(Vec<u8>, std::time::Instant)>>,
+    bytes: usize,
 }
 
 impl DataLanes {
     fn push(&mut self, cap: usize, member: MemberId, bytes: Vec<u8>) -> bool {
-        let lane = self.lanes.entry(member).or_default();
-        let dropped = lane.len() >= cap;
-        if dropped {
-            lane.pop_front();
+        if bytes.len() > crate::transport::protocol::MAX_PACKET_BYTES as usize
+            || (!self.lanes.contains_key(&member)
+                && self.lanes.len() >= master_protocol::MAX_SESSION_MEMBERS as usize)
+        {
+            return true;
         }
-        lane.push_back(bytes);
+        let lane = self.lanes.entry(member).or_default();
+        let mut dropped = false;
+        while !lane.is_empty()
+            && (lane.len() >= cap
+                || self.bytes + bytes.len() > super::master::limits::values().queue_bytes)
+        {
+            self.bytes -= lane.pop_front().expect("nonempty lane").0.len();
+            dropped = true;
+        }
+        if self.bytes + bytes.len() > super::master::limits::values().queue_bytes || cap == 0 {
+            return true;
+        }
+        self.bytes += bytes.len();
+        lane.push_back((
+            bytes,
+            std::time::Instant::now() + super::master::limits::values().queue_age,
+        ));
         dropped
     }
 
     fn take(&mut self) -> Vec<(MemberId, Vec<u8>)> {
         let mut out = Vec::new();
+        self.bytes = 0;
         for (member, lane) in std::mem::take(&mut self.lanes) {
-            out.extend(lane.into_iter().map(|bytes| (member, bytes)));
+            out.extend(
+                lane.into_iter()
+                    .filter(|(_, deadline)| *deadline > std::time::Instant::now())
+                    .map(|(bytes, _)| (member, bytes)),
+            );
         }
         out
     }
@@ -146,21 +184,36 @@ fn lock_lanes(lanes: &Mutex<DataLanes>) -> std::sync::MutexGuard<'_, DataLanes>
 }
 
 fn push_mail(
-    queue: &Mutex<Vec<(MemberId, Vec<u8>)>>,
+    queue: &Mutex<Vec<(MemberId, Vec<u8>, std::time::Instant)>>,
     cap: usize,
     member: MemberId,
     bytes: Vec<u8>,
 ) -> Result<(), &'static str> {
+    if bytes.len() > crate::transport::protocol::MAX_PACKET_BYTES as usize {
+        return Err("relay packet exceeds byte budget");
+    }
     let mut queue = queue.lock().expect("relay mailbox poisoned");
-    if queue.len() >= cap {
+    if queue.len() >= cap
+        || queue.iter().map(|(_, bytes, _)| bytes.len()).sum::<usize>() + bytes.len()
+            > super::master::limits::values().queue_bytes
+    {
         return Err("relay mailbox full");
     }
-    queue.push((member, bytes));
+    queue.push((
+        member,
+        bytes,
+        std::time::Instant::now() + super::master::limits::values().queue_age,
+    ));
     Ok(())
 }
 
-fn take_mail(queue: &Mutex<Vec<(MemberId, Vec<u8>)>>) -> Vec<(MemberId, Vec<u8>)> {
+fn take_mail(
+    queue: &Mutex<Vec<(MemberId, Vec<u8>, std::time::Instant)>>,
+) -> Vec<(MemberId, Vec<u8>)> {
     std::mem::take(&mut *queue.lock().expect("relay mailbox poisoned"))
+        .into_iter()
+        .map(|(member, bytes, _)| (member, bytes))
+        .collect()
 }
 
 fn relay_send_error(message: &'static str) -> UdpSendError {
diff --git a/crates/render_anim/src/anim/remote_animation.rs b/crates/render_anim/src/anim/remote_animation.rs
index 956bd6f..a40d278 100644
--- a/crates/render_anim/src/anim/remote_animation.rs
+++ b/crates/render_anim/src/anim/remote_animation.rs
@@ -90,15 +90,13 @@ pub fn skip_frozen_corpse_dobj(
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct CorpseOccupationKey {
-    pub spawn_time_ms: i32,
-    pub victim: i32,
+    pub identity: net::CorpseIdentity,
 }
 
-pub fn corpse_occupation_key(es: &entity_iw4::EntityState) -> CorpseOccupationKey {
-    CorpseOccupationKey {
-        spawn_time_ms: es.time2,
-        victim: es.client_num,
-    }
+pub fn corpse_occupation_key(entity: &net::CEntity) -> Option<CorpseOccupationKey> {
+    entity
+        .corpse_identity()
+        .map(|identity| CorpseOccupationKey { identity })
 }
 
 pub fn fresh_corpse_clip_time(age_ms: i32, clip_length_ms: i32) -> f32 {
diff --git a/crates/render_anim/src/occupancy/dyn_ent_phys.rs b/crates/render_anim/src/occupancy/dyn_ent_phys.rs
index f082f70..0cabaa2 100644
--- a/crates/render_anim/src/occupancy/dyn_ent_phys.rs
+++ b/crates/render_anim/src/occupancy/dyn_ent_phys.rs
@@ -18,9 +18,8 @@ const MAX_ITERS: i32 = 2;
 
 const CONTENTS_SOLID: u32 = 1;
 const CONTENTS_ITEMCLIP: u32 = 0x400;
-const WAKE_MASKS: [u32; 2] = [CONTENTS_SOLID | CONTENTS_ITEMCLIP, CONTENTS_SOLID];
+const COLLISION_MASK: u32 = CONTENTS_SOLID | CONTENTS_ITEMCLIP;
 const WAKE_LIFTS: [f32; 6] = [0.0, CONTACT_SLOP, 0.25, 0.5, 1.0, 2.0];
-const WAKE_FOOTPRINTS: [f32; 3] = [1.0, 0.75, 0.5];
 const SLEEP_SPEED: f32 = 4.0;
 const GROUND_NZ: f32 = 0.7;
 const CONTACT_SLOP: f32 = 0.125;
@@ -36,6 +35,11 @@ pub struct DynEntPhysWorld {
 }
 
 impl DynEntPhysWorld {
+    pub fn reset_presentation(&mut self) {
+        self.bodies.clear();
+        self.last_time = None;
+    }
+
     pub fn is_awake(&self, entity: Entity) -> bool {
         self.bodies.contains_key(&entity)
     }
@@ -105,30 +109,33 @@ pub fn step_phys_world0(
         let (mins, maxs) = xmodel_phys_hull(catalog, &inst.current_model);
         let add_vel = impulse.impulse / preset.mass;
         let phys_clip = clip.0.as_deref();
-        world
-            .bodies
-            .entry(entity)
-            .and_modify(|body| {
-                body.vel += add_vel;
-                body.asleep_ms = 0;
-            })
-            .or_insert_with(|| {
-                let pose = phys_clip
-                    .and_then(|clip| clear_wake_pose(clip, transform.translation, mins, maxs));
-                let (origin, mins, maxs, mask) =
-                    pose.unwrap_or((transform.translation, mins, maxs, CONTENTS_SOLID));
-                DynEntPhysBody {
-                    origin,
-                    vel: add_vel,
-                    mins,
-                    maxs,
-                    bounce: preset.bounce,
-                    friction: preset.friction,
-                    mask,
-                    on_ground: false,
-                    asleep_ms: 0,
-                }
-            });
+        if let Some(body) = world.bodies.get_mut(&entity) {
+            body.vel += add_vel;
+            body.asleep_ms = 0;
+            continue;
+        }
+        let Some(clip) = phys_clip else {
+            continue;
+        };
+        let RecoveryOutcome::Recovered(origin) =
+            clear_wake_pose(clip, transform.translation, mins, maxs, COLLISION_MASK)
+        else {
+            continue;
+        };
+        world.bodies.insert(
+            entity,
+            DynEntPhysBody {
+                origin,
+                vel: add_vel,
+                mins,
+                maxs,
+                bounce: preset.bounce,
+                friction: preset.friction,
+                mask: COLLISION_MASK,
+                on_ground: false,
+                asleep_ms: 0,
+            },
+        );
     }
 
     let now = clock
@@ -198,37 +205,31 @@ pub fn step_phys_world0(
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum RecoveryOutcome {
+    Recovered(Vec3),
+    Blocked,
+    Incomplete,
+}
+
 fn clear_wake_pose(
     clip: &ClipCollision,
     origin: Vec3,
     mins: [f32; 3],
     maxs: [f32; 3],
-) -> Option<(Vec3, [f32; 3], [f32; 3], u32)> {
-    for mask in WAKE_MASKS {
-        for scale in WAKE_FOOTPRINTS {
-            let (mins, maxs) = narrowed_footprint(mins, maxs, scale);
-            for lift in WAKE_LIFTS {
-                let at = (origin + Vec3::Z * lift).to_array();
-                let probe = clip.sweep_box(at, at, mins, maxs, mask);
-                if !probe.startsolid && !probe.allsolid {
-                    return Some((Vec3::from_array(at), mins, maxs, mask));
-                }
-            }
+    mask: u32,
+) -> RecoveryOutcome {
+    if clip.coverage != asset_world::CollisionCoverage::Complete {
+        return RecoveryOutcome::Incomplete;
+    }
+    for lift in WAKE_LIFTS {
+        let at = origin + Vec3::Z * lift;
+        let probe = clip.sweep_box(at.to_array(), at.to_array(), mins, maxs, mask);
+        if !probe.startsolid && !probe.allsolid {
+            return RecoveryOutcome::Recovered(at);
         }
     }
-    None
-}
-
-fn narrowed_footprint(mins: [f32; 3], maxs: [f32; 3], scale: f32) -> ([f32; 3], [f32; 3]) {
-    let mut lo = mins;
-    let mut hi = maxs;
-    for axis in 0..2 {
-        let mid = (mins[axis] + maxs[axis]) * 0.5;
-        let half = (maxs[axis] - mins[axis]) * 0.5 * scale;
-        lo[axis] = mid - half;
-        hi[axis] = mid + half;
-    }
-    (lo, hi)
+    RecoveryOutcome::Blocked
 }
 
 fn integrate_free(body: &mut DynEntPhysBody, dt: f32) {
@@ -238,6 +239,12 @@ fn integrate_free(body: &mut DynEntPhysBody, dt: f32) {
 }
 
 fn integrate_body(body: &mut DynEntPhysBody, clip: &ClipCollision, dt: f32) {
+    if clip.coverage != asset_world::CollisionCoverage::Complete {
+        body.vel = Vec3::ZERO;
+        body.on_ground = false;
+        body.asleep_ms = 0;
+        return;
+    }
     body.vel.z += GRAVITY_Z * dt;
     let start = body.origin;
     let end = start + body.vel * dt;
@@ -250,7 +257,8 @@ fn integrate_body(body: &mut DynEntPhysBody, clip: &ClipCollision, dt: f32) {
     );
     if hit.allsolid || hit.startsolid {
         body.vel = Vec3::ZERO;
-        body.on_ground = true;
+        body.on_ground = false;
+        body.asleep_ms = 0;
         return;
     }
     if hit.fraction < 1.0 {
diff --git a/crates/render_anim/src/occupancy/fpv_present.rs b/crates/render_anim/src/occupancy/fpv_present.rs
index 237dcd7..945a2ec 100644
--- a/crates/render_anim/src/occupancy/fpv_present.rs
+++ b/crates/render_anim/src/occupancy/fpv_present.rs
@@ -597,12 +597,15 @@ pub fn tick_fpv_viewmodel(
         product.kind = FpvPoseKind::Hide;
         return;
     }
-    if presented_is_third_person(
+    // Outside the killcam the hidden viewmodel keeps animating: its notetracks
+    // are the player's reload and handling sounds.
+    let hidden = presented_is_third_person(
         &presented,
         local.0,
         view.in_killcam(),
         settings.third_person,
-    ) {
+    );
+    if hidden && view.in_killcam() {
         product.kind = FpvPoseKind::Hide;
         return;
     }
@@ -841,6 +844,10 @@ pub fn tick_fpv_viewmodel(
             snapshot.view_tick(local.0),
         ));
     }
+    if hidden {
+        product.kind = FpvPoseKind::Hide;
+        return;
+    }
     if let FpvPoseKind::Posed(frame) = &mut kind {
         // Nothing downstream of the bones waits for a vertex.
         if let Some(bolt) = frame.secondary_bolt.take() {
diff --git a/crates/render_anim/src/occupancy/killcam.rs b/crates/render_anim/src/occupancy/killcam.rs
index f1cab57..a57e6a8 100644
--- a/crates/render_anim/src/occupancy/killcam.rs
+++ b/crates/render_anim/src/occupancy/killcam.rs
@@ -20,7 +20,6 @@ pub struct KillcamCamera {
     stop: Option<(i32, f32, Vec3, Vec3)>,
     entered_at: i32,
     last_time: i32,
-    last_replay_tick: Option<u32>,
     last_pose: Option<WorldCameraPose>,
     blend_until: i32,
 }
@@ -182,18 +181,9 @@ impl KillcamCamera {
         clip: Option<&ClipCollision>,
     ) -> Option<(WorldCameraPose, f32, Option<f32>)> {
         let ps = presented.player(viewer)?;
-        let replay_tick = presented
-            .snapshot()
-            .map(|snapshot| snapshot.view_tick(viewer).0);
-        if !in_killcam
-            || now < self.last_time
-            || replay_tick
-                .zip(self.last_replay_tick)
-                .is_some_and(|(next, old)| next < old)
-        {
+        if !in_killcam {
             *self = Self::default();
         }
-        self.last_replay_tick = replay_tick;
         let previous_time = self.last_time;
         self.last_time = now;
         if !in_killcam {
diff --git a/crates/render_anim/src/occupancy/remote_body.rs b/crates/render_anim/src/occupancy/remote_body.rs
index 99dbe44..40278b2 100644
--- a/crates/render_anim/src/occupancy/remote_body.rs
+++ b/crates/render_anim/src/occupancy/remote_body.rs
@@ -91,6 +91,7 @@ struct RemoteBodyLightingBinds {
 #[derive(Hash, PartialEq, Eq)]
 struct BodySkinShapeKey {
     world_weapon: bool,
+    product_revision: u64,
     namespace: asset_core::AssetNamespace,
     name: String,
     lod: u8,
@@ -109,9 +110,9 @@ impl BodySkinShapes {
         let same_bodies = self
             .bodies
             .as_ref()
-            .is_some_and(|old| Arc::ptr_eq(old, &bodies.0));
+            .is_some_and(|old| old.identity() != 0 && old.identity() == bodies.0.identity());
         let same_weapons = match (&self.weapons, weapons) {
-            (Some(old), Some(new)) => Arc::ptr_eq(old, &new.0),
+            (Some(old), Some(new)) => old.identity() != 0 && old.identity() == new.0.identity(),
             (None, None) => true,
             _ => false,
         };
@@ -134,8 +135,16 @@ impl BodySkinShapes {
         lod: u8,
         layout: &crate::anim::xmodel_pose::SkinLayout,
     ) -> Arc<render_frame::skinning::PackedSkinShape> {
+        let product_revision = if world_weapon {
+            self.weapons
+                .as_ref()
+                .map_or(0, |weapons| weapons.identity())
+        } else {
+            self.bodies.as_ref().map_or(0, |bodies| bodies.identity())
+        };
         let key = BodySkinShapeKey {
             world_weapon,
+            product_revision,
             namespace,
             name: skel.name.clone(),
             lod,
@@ -382,8 +391,22 @@ fn occupy_remote_scene_ents(
         let meta = presented
             .snapshot()
             .and_then(|snap| snap.meta.for_client(client));
-        let ffa_team = meta.and_then(|m| m.ffa_team);
-        let client_state_team = meta.map(|m| m.client_state_team).unwrap_or(0);
+        let corpse = presented.snapshot().and_then(|snapshot| {
+            snapshot
+                .meta
+                .corpses
+                .slots
+                .iter()
+                .find(|slot| slot.occupied && slot.entnum == i32::from(identity.number()))
+        });
+        let ffa_team = corpse.map_or_else(
+            || meta.and_then(|meta| meta.ffa_team),
+            |corpse| corpse.ffa_team,
+        );
+        let client_state_team = corpse.map_or_else(
+            || meta.map_or(0, |meta| meta.client_state_team),
+            |corpse| corpse.client_state_team,
+        );
         let axis = asset_model::kit_assignment_is_axis(client_state_team, ffa_team);
         let Ok(soldier) = soldiers.side(axis) else {
             continue;
@@ -524,8 +547,22 @@ fn sync_remote_bodies(
         let meta = presented
             .snapshot()
             .and_then(|snap| snap.meta.for_client(client));
-        let ffa_team = meta.and_then(|m| m.ffa_team);
-        let client_state_team = meta.map(|m| m.client_state_team).unwrap_or(0);
+        let corpse = presented.snapshot().and_then(|snapshot| {
+            snapshot
+                .meta
+                .corpses
+                .slots
+                .iter()
+                .find(|slot| slot.occupied && slot.entnum == i32::from(identity.number()))
+        });
+        let ffa_team = corpse.map_or_else(
+            || meta.and_then(|meta| meta.ffa_team),
+            |corpse| corpse.ffa_team,
+        );
+        let client_state_team = corpse.map_or_else(
+            || meta.map_or(0, |meta| meta.client_state_team),
+            |corpse| corpse.client_state_team,
+        );
         let Ok(soldier) = soldiers.side(asset_model::kit_assignment_is_axis(
             client_state_team,
             ffa_team,
@@ -879,13 +916,13 @@ impl<'a> RemotePoseFrame<'a> {
         let persist_key = u32::from(identity.number());
         let is_corpse = runtime.next_state.e_type == ET_PLAYER_CORPSE
             || runtime.pose_e_type == ET_PLAYER_CORPSE as u8;
-        let occupation_key = is_corpse.then(|| corpse_occupation_key(&runtime.next_state));
+        let occupation_key = is_corpse.then(|| corpse_occupation_key(identity)).flatten();
         if let Some(key) = occupation_key {
             let victim = u32::try_from(runtime.next_state.client_num).unwrap_or(0);
             clone_corpse_tree_from_victim(self.trees, persist_key, victim, key);
         }
         let corpse_age_ms =
-            occupation_key.map(|key| runtime.pose_time_ms.wrapping_sub(key.spawn_time_ms));
+            occupation_key.map(|_| runtime.pose_time_ms.wrapping_sub(runtime.next_state.time2));
 
         if runtime.previous_pose.is_none() {
             if let Some(slot) = self.trees.get_mut(persist_key) {
diff --git a/crates/render_anim/src/occupancy/third_person.rs b/crates/render_anim/src/occupancy/third_person.rs
index c8ccf47..a87d16c 100644
--- a/crates/render_anim/src/occupancy/third_person.rs
+++ b/crates/render_anim/src/occupancy/third_person.rs
@@ -71,7 +71,6 @@ const TURN_SAMPLES: usize = 4;
 #[derive(Default)]
 struct MissileTurn {
     missile: Option<(LifeSequence, ProjectileId)>,
-    archived: bool,
     samples: Vec<(i32, [f32; 3])>,
 }
 
@@ -79,17 +78,11 @@ impl MissileTurn {
     fn record(
         &mut self,
         missile: (LifeSequence, ProjectileId),
-        archived: bool,
         snapshot_ms: i32,
         angles: [f32; 3],
     ) {
-        // The final killcam of the pilot's own kill replays the same missile
-        // of the same life from seat snapshots stamped with the live tick,
-        // later than every sample of the flight, so a switch between live and
-        // archived presentation starts a fresh history.
-        if self.missile != Some(missile) || self.archived != archived {
+        if self.missile != Some(missile) {
             self.missile = Some(missile);
-            self.archived = archived;
             self.samples.clear();
         }
         match self.samples.last_mut() {
@@ -153,12 +146,8 @@ impl RemoteMissileView {
             .flatten();
         let snapshot_ms = presented.tick().map_or(at_time, sim::level_time_ms);
         if let Some(missile) = flying {
-            self.turn.record(
-                (life, link.projectile),
-                presented.is_archived_replay(),
-                snapshot_ms,
-                link.angles,
-            );
+            self.turn
+                .record((life, link.projectile), snapshot_ms, link.angles);
             let pose = WorldCameraPose {
                 origin: missile_eye(missile, snapshot_ms, at_time, clip),
                 angles: self.turn.angles_at(at_time).unwrap_or(link.angles),
diff --git a/crates/render_anim/src/occupancy/view_kick.rs b/crates/render_anim/src/occupancy/view_kick.rs
index 5b81a10..c3d8449 100644
--- a/crates/render_anim/src/occupancy/view_kick.rs
+++ b/crates/render_anim/src/occupancy/view_kick.rs
@@ -37,6 +37,7 @@ pub struct PendingViewHurt(pub u32);
 
 #[derive(Resource, Default)]
 pub struct SessionViewKick {
+    context: Option<frame::PresentationContext>,
     pub state: ViewKickState,
     pub sway: ViewSwayState,
 
@@ -138,7 +139,16 @@ pub fn tick_session_view_kick(
     weapons: Option<Res<PreparedWeapons>>,
     walk: Option<Res<AppliedEntityEventWalk>>,
     mut kick: ResMut<SessionViewKick>,
+    context: (Res<frame::InstalledMatch>, Res<net::EntityEventCursor>),
 ) {
+    let context = Some(frame::PresentationContext::new(
+        context.0.load_key,
+        context.1.timeline(),
+    ));
+    if kick.context != context {
+        kick.clear_for_new_life();
+        kick.context = context;
+    }
     let Some(ps) = presented.player(local.0) else {
         return;
     };
@@ -229,7 +239,25 @@ pub fn sync_camera_from_presented(
     view: Res<ViewSubject>,
     death_cam_clip: Res<crate::occupancy::dyn_ent::DynEntPhysClip>,
     mut missile_view: Local<RemoteMissileView>,
+    context: (
+        Local<Option<frame::PresentationContext>>,
+        Res<frame::InstalledMatch>,
+        Res<net::EntityEventCursor>,
+    ),
 ) {
+    let (mut previous, installed, timeline) = context;
+    let current = Some(frame::PresentationContext::new(
+        installed.load_key,
+        timeline.timeline(),
+    ));
+    if *previous != current {
+        *killcam = super::killcam::KillcamCamera::default();
+        *missile_view = RemoteMissileView::default();
+        kick.clear_for_new_life();
+        kick.context = current;
+        hurt.0 = 0;
+        *previous = current;
+    }
     kick.killcam_focus_distance = None;
     if let Some(view) = sim_cam.view_override {
         for mut transform in &mut q {
diff --git a/crates/render_frame/src/skinning.rs b/crates/render_frame/src/skinning.rs
index a806853..23797f7 100644
--- a/crates/render_frame/src/skinning.rs
+++ b/crates/render_frame/src/skinning.rs
@@ -16,6 +16,7 @@ pub struct PackedSkinShape {
     id: u64,
     vertices: Vec<PackedSkinVertex>,
     required_bones: usize,
+    valid: bool,
 }
 
 impl PackedSkinShape {
@@ -36,7 +37,18 @@ impl PackedSkinShape {
             })
             .max()
             .map_or(0, |bone| bone as usize + 1);
+        let valid = vertices.iter().all(|vertex| {
+            vertex.packed[..3]
+                .iter()
+                .all(|word| f32::from_bits(*word).is_finite())
+                && vertex
+                    .weights
+                    .iter()
+                    .all(|weight| weight.is_finite() && *weight >= 0.0 && *weight <= 1.0)
+                && vertex.weights[1..].iter().sum::<f32>() <= 1.0001
+        });
         Arc::new(Self {
+            valid,
             id,
             vertices,
             required_bones,
@@ -69,3 +81,134 @@ pub struct PackedSkinJob {
     pub destination: u32,
     pub offset: [f32; 3],
 }
+
+#[derive(Clone, Copy, Debug)]
+pub struct SkinBatchLimits {
+    pub storage_bytes: u64,
+    pub buffer_bytes: u64,
+    pub storage_alignment: u64,
+    pub uniform_alignment: u64,
+    pub dispatch_groups: u32,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SkinRefusal {
+    InvalidShape,
+    InvalidPalette,
+    InvalidRange,
+    OverlappingOutput,
+    UnsupportedProduct,
+    ResidencyPressure,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SkinBatchFull {
+    OutputPage,
+    Palette,
+    Parameters,
+}
+
+#[derive(Debug)]
+pub struct SkinBatch {
+    pub opened_by: Option<SkinBatchFull>,
+    pub jobs: Vec<usize>,
+    pub output_offset: u64,
+    pub output_bytes: u64,
+    pub palette_bytes: u64,
+    pub parameter_bytes: u64,
+}
+
+pub fn plan_skin_batches(
+    jobs: &[PackedSkinJob],
+    output_bytes: u64,
+    limits: SkinBatchLimits,
+) -> Result<Vec<SkinBatch>, SkinRefusal> {
+    let stride = 48_u64.next_multiple_of(limits.uniform_alignment.max(1));
+    let alignment = limits.storage_alignment.max(32).next_multiple_of(32);
+    let mut order: Vec<usize> = (0..jobs.len())
+        .filter(|index| jobs[*index].ranges.iter().any(|range| range.count != 0))
+        .collect();
+    order.sort_unstable_by_key(|index| jobs[*index].destination);
+    let mut batches: Vec<SkinBatch> = Vec::new();
+    let mut covered = 0_u64;
+    for index in order {
+        let job = &jobs[index];
+        let vertices = job.shape.vertices().len() as u64;
+        if vertices == 0 || !job.shape.valid || job.offset.iter().any(|n| !n.is_finite()) {
+            return Err(SkinRefusal::InvalidShape);
+        }
+        if job.bones.is_empty()
+            || job.shape.required_bones() > job.bones.len()
+            || job.bones.iter().flatten().flatten().any(|n| !n.is_finite())
+        {
+            return Err(SkinRefusal::InvalidPalette);
+        }
+        if job.ranges.iter().any(|range| {
+            range
+                .start
+                .checked_add(range.count)
+                .is_none_or(|end| end as u64 > vertices)
+        }) {
+            return Err(SkinRefusal::InvalidRange);
+        }
+        let start = u64::from(job.destination) * 32;
+        let end = start
+            .checked_add(
+                vertices
+                    .checked_mul(32)
+                    .ok_or(SkinRefusal::UnsupportedProduct)?,
+            )
+            .ok_or(SkinRefusal::UnsupportedProduct)?;
+        if start < covered {
+            return Err(SkinRefusal::OverlappingOutput);
+        }
+        covered = end;
+        if end > output_bytes {
+            return Err(SkinRefusal::InvalidRange);
+        }
+        let palette = job.bones.len() as u64 * 64;
+        let parameters = job.ranges.iter().filter(|range| range.count != 0).count() as u64 * stride;
+        let offset = start / alignment * alignment;
+        if vertices * 64 > limits.storage_bytes
+            || end - offset > limits.storage_bytes
+            || palette > limits.storage_bytes
+            || parameters > limits.buffer_bytes.min(u32::MAX as u64)
+            || job
+                .ranges
+                .iter()
+                .any(|range| range.count.div_ceil(64) > limits.dispatch_groups)
+        {
+            return Err(SkinRefusal::UnsupportedProduct);
+        }
+        let full = batches.last().and_then(|batch| {
+            if end - batch.output_offset > limits.storage_bytes {
+                Some(SkinBatchFull::OutputPage)
+            } else if batch.palette_bytes + palette > limits.storage_bytes {
+                Some(SkinBatchFull::Palette)
+            } else if batch.parameter_bytes + parameters > limits.buffer_bytes.min(u32::MAX as u64)
+            {
+                Some(SkinBatchFull::Parameters)
+            } else {
+                None
+            }
+        });
+        let append = !batches.is_empty() && full.is_none();
+        if append {
+            let batch = batches.last_mut().expect("batch present");
+            batch.jobs.push(index);
+            batch.output_bytes = end - batch.output_offset;
+            batch.palette_bytes += palette;
+            batch.parameter_bytes += parameters;
+        } else {
+            batches.push(SkinBatch {
+                opened_by: full,
+                jobs: vec![index],
+                output_offset: offset,
+                output_bytes: end - offset,
+                palette_bytes: palette,
+                parameter_bytes: parameters,
+            });
+        }
+    }
+    Ok(batches)
+}
diff --git a/crates/render_frontend/Cargo.toml b/crates/render_frontend/Cargo.toml
index 344374b..e51a1e1 100644
--- a/crates/render_frontend/Cargo.toml
+++ b/crates/render_frontend/Cargo.toml
@@ -33,6 +33,7 @@ hud_iw4.workspace = true
 marks_iw4.workspace = true
 math_iw4.workspace = true
 net.workspace = true
+master_protocol.workspace = true
 perf.workspace = true
 playerstate_iw4.workspace = true
 render_anim.workspace = true
diff --git a/crates/render_frontend/src/adapters/anim/dyn_ent_wake.rs b/crates/render_frontend/src/adapters/anim/dyn_ent_wake.rs
index fd1fa7b..a923d13 100644
--- a/crates/render_frontend/src/adapters/anim/dyn_ent_wake.rs
+++ b/crates/render_frontend/src/adapters/anim/dyn_ent_wake.rs
@@ -12,9 +12,7 @@ use crate::adapters::fx::world_mark::FrontendFxScene;
 use crate::prepare::scene::cull::DynEntModelEntity;
 use crate::prepare::scene::world::{WorldDynEntInstance, WorldScene};
 use assets::{BoundWeapons, PreparedWeapons};
-use net::{
-    ClientPredictionState, EntityBulletHit, EntityEventSound, EntityExplosion, EntityPhysicsSphere,
-};
+use net::{ClientPredictionState, EntityEventSound, EntityExplosion, EntityPhysicsSphere};
 use render_fx::{EntityMarks, HostFxSystem, PreparedFxCatalog};
 
 pub const DYNENT_BULLET_FORCE: f32 = 1000.0;
@@ -52,14 +50,6 @@ pub struct DynEntWakeBroadphase {
     pub query_ms: f32,
 }
 
-#[derive(Clone, Copy, Debug, Message)]
-pub struct DynEntPelletHit {
-    pub world: frame::WorldStamp,
-    pub weapon: u32,
-    pub start: Vec3,
-    pub end: Vec3,
-}
-
 #[derive(Clone, Copy, Debug)]
 struct DynEntWakeEntry {
     entity: Entity,
@@ -677,8 +667,9 @@ fn hit_one_dyn_ent(
     }
 }
 
-pub(crate) fn on_entity_bullet_hit(
-    hit: On<EntityBulletHit>,
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn hit_dyn_ents_from_pellets(
+    mut hits: MessageReader<net::AcceptedImpact>,
     weapons: Option<Res<PreparedWeapons>>,
     catalog: Option<Res<asset_world::MapXModelSceneCatalog>>,
     mut broadphase: ResMut<DynEntWakeBroadphase>,
@@ -698,49 +689,44 @@ pub(crate) fn on_entity_bullet_hit(
     scene: Option<Res<WorldScene>>,
     entity_marks: Res<EntityMarks>,
 ) {
-    if hit.event.domain == net::EntityEventDomain::Predicted {
-        return;
-    }
-    let weapons = weapons
-        .as_deref()
-        .and_then(|weapons| weapons.for_event(hit.event.world).ok());
-    let payload = hit.event.payload;
-    let start = Vec3::from_array(payload.origin2);
-    let end = Vec3::from_array(payload.origin);
     let catalog = catalog.as_deref();
-    let mut host = host.as_deref_mut();
     let fx = fx.as_deref();
     let scene = scene.as_deref();
     let marks = entity_marks.as_ref();
-    if let Some((entity, pose, bullet_scale)) =
-        closest_segment_hit(start, end, catalog, &mut broadphase, &instances)
-    {
-        hit_one_dyn_ent(
-            entity,
-            pose,
-            start,
-            end,
-            bullet_scale,
-            weapon_hit_damage(weapons.as_ref(), payload.weapon),
-            &mut instances,
-            &mut impulses,
-            phys.as_mut(),
-            host.as_deref_mut(),
-            fx,
-            scene,
-            marks,
+    for hit in hits.read() {
+        let direct = closest_segment_hit(
+            Vec3::from_array(hit.record.start),
+            Vec3::from_array(hit.record.end),
+            catalog,
+            &mut broadphase,
+            &instances,
         );
-    }
-    if matches!(
-        hit.event.event,
-        EntityEventKind::BULLET_HIT_EXPLODE | EntityEventKind::BULLET_HIT_CLIENT_EXPLODE
-    ) {
-        let Some((inner, outer)) = weapon_radii(weapons.as_ref(), payload.weapon) else {
-            return;
+        let weapons = weapons
+            .as_deref()
+            .and_then(|weapons| weapons.for_event(hit.world).ok());
+        if let Some((entity, pose, bullet_scale)) = direct {
+            hit_one_dyn_ent(
+                entity,
+                pose,
+                Vec3::from_array(hit.record.start),
+                Vec3::from_array(hit.record.end),
+                bullet_scale,
+                weapon_hit_damage(weapons.as_ref(), hit.record.weapon),
+                &mut instances,
+                &mut impulses,
+                phys.as_mut(),
+                host.as_deref_mut(),
+                fx,
+                scene,
+                marks,
+            );
+        }
+        let Some((inner, outer)) = weapon_radii(weapons.as_ref(), hit.record.weapon) else {
+            continue;
         };
         let (inner_damage, outer_damage) =
-            weapon_explosion_damage(weapons.as_ref(), payload.weapon);
-        let origin = end;
+            weapon_explosion_damage(weapons.as_ref(), hit.record.weapon);
+        let origin = Vec3::from_array(hit.record.end);
         let started = Instant::now();
         if let Some(candidates) = broadphase.sphere_candidates(origin, outer) {
             for &entity in candidates {
@@ -795,59 +781,6 @@ pub(crate) fn on_entity_bullet_hit(
     }
 }
 
-#[allow(clippy::too_many_arguments)]
-pub(crate) fn hit_dyn_ents_from_pellets(
-    mut hits: MessageReader<DynEntPelletHit>,
-    weapons: Option<Res<PreparedWeapons>>,
-    catalog: Option<Res<asset_world::MapXModelSceneCatalog>>,
-    mut broadphase: ResMut<DynEntWakeBroadphase>,
-    mut instances: Query<
-        (
-            Entity,
-            &mut WorldDynEntInstance,
-            &Transform,
-            &mut Visibility,
-        ),
-        With<DynEntModelEntity>,
-    >,
-    mut impulses: MessageWriter<DynEntPhysImpulse>,
-    mut phys: ResMut<DynEntPhysWorld>,
-    mut host: Option<ResMut<HostFxSystem>>,
-    fx: Option<Res<PreparedFxCatalog>>,
-    scene: Option<Res<WorldScene>>,
-    entity_marks: Res<EntityMarks>,
-) {
-    let catalog = catalog.as_deref();
-    let fx = fx.as_deref();
-    let scene = scene.as_deref();
-    let marks = entity_marks.as_ref();
-    for hit in hits.read() {
-        let Some((entity, pose, bullet_scale)) =
-            closest_segment_hit(hit.start, hit.end, catalog, &mut broadphase, &instances)
-        else {
-            continue;
-        };
-        let weapons = weapons
-            .as_deref()
-            .and_then(|weapons| weapons.for_event(hit.world).ok());
-        hit_one_dyn_ent(
-            entity,
-            pose,
-            hit.start,
-            hit.end,
-            bullet_scale,
-            weapon_hit_damage(weapons.as_ref(), hit.weapon),
-            &mut instances,
-            &mut impulses,
-            phys.as_mut(),
-            host.as_deref_mut(),
-            fx,
-            scene,
-            marks,
-        );
-    }
-}
-
 pub(crate) fn on_entity_event_sound(
     sound: On<EntityEventSound>,
     weapons: Option<Res<PreparedWeapons>>,
@@ -976,18 +909,66 @@ fn on_physics_sphere(
     }
 }
 
+#[derive(Resource, Default)]
+struct DynEntPresentationCheckpoint {
+    initial: HashMap<Entity, (WorldDynEntInstance, Transform, Visibility)>,
+}
+
+fn reconstruct_dyn_ent_presentation(
+    mut reset: MessageReader<net::ImpactReconstruction>,
+    mut checkpoint: ResMut<DynEntPresentationCheckpoint>,
+    mut instances: Query<
+        (
+            Entity,
+            &mut WorldDynEntInstance,
+            &mut Transform,
+            &mut Visibility,
+        ),
+        With<DynEntModelEntity>,
+    >,
+    mut physics: ResMut<DynEntPhysWorld>,
+    mut impulses: ResMut<Messages<DynEntPhysImpulse>>,
+) {
+    let reset = reset.read().count() != 0;
+    checkpoint
+        .initial
+        .retain(|entity, _| instances.contains(*entity));
+    for (entity, mut instance, mut transform, mut visibility) in &mut instances {
+        let initial = checkpoint
+            .initial
+            .entry(entity)
+            .or_insert_with(|| (instance.clone(), *transform, *visibility));
+        if reset {
+            *instance = initial.0.clone();
+            *transform = initial.1;
+            *visibility = initial.2;
+        }
+    }
+    if reset {
+        physics.reset_presentation();
+        impulses.clear();
+    }
+}
+
 pub fn register_dyn_ent_wake(app: &mut App) {
     app.scoped::<DynEntWakeBroadphase>(frame::MatchScope::Live)
-        .scoped_message::<DynEntPelletHit>(frame::MatchScope::Live)
+        .scoped::<DynEntPresentationCheckpoint>(frame::MatchScope::Live)
+        .add_systems(
+            Update,
+            reconstruct_dyn_ent_presentation
+                .in_set(frame::InMatch)
+                .in_set(net::ClientSet::Present)
+                .before(rebuild_dyn_ent_wake_broadphase),
+        )
         .add_observer(on_entity_explosion)
         .add_observer(on_physics_sphere)
-        .add_observer(on_entity_bullet_hit)
         .add_observer(on_entity_event_sound)
         .add_systems(
             Update,
             rebuild_dyn_ent_wake_broadphase
                 .in_set(frame::InMatch)
-                .in_set(net::ClientSet::Receive),
+                .in_set(net::ClientSet::Present)
+                .before(hit_dyn_ents_from_pellets),
         )
         .add_systems(
             Update,
diff --git a/crates/render_frontend/src/adapters/fx/flame.rs b/crates/render_frontend/src/adapters/fx/flame.rs
new file mode 100644
index 0000000..22890a6
--- /dev/null
+++ b/crates/render_frontend/src/adapters/fx/flame.rs
@@ -0,0 +1,534 @@
+use std::collections::HashMap;
+
+use asset_game::{FlameStreamView, FlameTube};
+use bevy::prelude::*;
+use fx_iw4::{FX_TRAIL_TANGENT_PACKED, FxSpriteAtlasUv, trail_pack_normal, trail_pack_texcoord};
+use render_fx::FxWorldColorImages;
+
+use crate::adapters::fx::system::{FxCodeMeshBind, code_mesh_bind};
+use crate::assemble::drawsurf::MaterialGeneration;
+use crate::assemble::drawsurf::tess::fx::FxCodeMeshPlan;
+
+const HOLD_MS: i32 = 150;
+const FIRE_CAP: usize = 768;
+const TUBE_POINT_CAP: usize = 100;
+const TUBE_MIN_SPACING_SQ: f32 = 1.0;
+const TUBE_MIN_REACH_SQ: [f32; 2] = [144.0, 14400.0];
+const FIRE_GROWTH_CAP: f32 = 70.0;
+const MATERIAL_FIRE: usize = 0;
+const MATERIAL_FUEL: usize = 4;
+const MATERIAL_FLAME: usize = 6;
+
+#[derive(Resource, Default)]
+pub(crate) struct FlameStreams {
+    streams: HashMap<i32, FlameStream>,
+}
+
+struct FlameStream {
+    entity: Entity,
+    player_view: bool,
+    view: FlameStreamView,
+    held_until_ms: i32,
+    next_chunk_ms: i32,
+    stepped_ms: i32,
+    tag: Option<([f32; 3], [f32; 3])>,
+    chunks: Vec<Chunk>,
+    fires: Vec<Fire>,
+    rng: u32,
+}
+
+struct Chunk {
+    pos: Vec3,
+    vel: Vec3,
+    size: f32,
+    growth: f32,
+    birth_ms: i32,
+    death_ms: i32,
+    next_fire_ms: i32,
+}
+
+struct Fire {
+    pos: Vec3,
+    vel: Vec3,
+    size: f32,
+    growth: f32,
+    rot: f32,
+    rot_vel: f32,
+    birth_ms: i32,
+    death_ms: i32,
+}
+
+impl FlameStreams {
+    pub(crate) fn note_fire(
+        &mut self,
+        number: i32,
+        entity: Entity,
+        player_view: bool,
+        view: &FlameStreamView,
+        now_ms: i32,
+    ) {
+        let stream = self.streams.entry(number).or_insert_with(|| FlameStream {
+            entity,
+            player_view,
+            view: view.clone(),
+            held_until_ms: now_ms,
+            next_chunk_ms: now_ms,
+            stepped_ms: now_ms,
+            tag: None,
+            chunks: Vec::new(),
+            fires: Vec::new(),
+            rng: 0x9e37_79b9 ^ number as u32,
+        });
+        if stream.player_view != player_view || stream.entity != entity {
+            stream.player_view = player_view;
+            stream.entity = entity;
+            stream.view = view.clone();
+            stream.tag = None;
+        }
+        if stream.held_until_ms < now_ms {
+            stream.next_chunk_ms = now_ms;
+            stream.tag = None;
+        }
+        stream.held_until_ms = now_ms + HOLD_MS;
+    }
+
+    pub(crate) fn tick(
+        &mut self,
+        now_ms: i32,
+        tag_of: impl Fn(Entity, bool) -> Option<([f32; 3], [f32; 3])>,
+    ) {
+        self.streams.retain(|_, stream| {
+            let tag = tag_of(stream.entity, stream.player_view);
+            stream.tick(now_ms, tag);
+            stream.held_until_ms >= now_ms || !stream.chunks.is_empty() || !stream.fires.is_empty()
+        });
+    }
+
+    pub(crate) fn present(
+        &self,
+        cam: &Transform,
+        color_images: &FxWorldColorImages,
+        runtime: &MaterialGeneration,
+        now_ms: i32,
+        plan: &mut FxCodeMeshPlan,
+    ) {
+        let eye = cam.translation;
+        for stream in self.streams.values() {
+            let materials = &stream.view.materials;
+            if let Some(fire) = materials[MATERIAL_FIRE].as_deref() {
+                present_fires(stream, fire, cam, color_images, runtime, now_ms, plan);
+            }
+            for (tube, slot) in [
+                (&stream.view.fuel, MATERIAL_FUEL),
+                (&stream.view.flame, MATERIAL_FLAME),
+            ] {
+                if let (Some(material), Some(_)) =
+                    (materials[slot].as_deref(), materials[slot + 1].as_deref())
+                {
+                    present_tube(
+                        stream,
+                        tube,
+                        material,
+                        eye,
+                        color_images,
+                        runtime,
+                        now_ms,
+                        plan,
+                    );
+                }
+            }
+        }
+    }
+}
+
+impl FlameStream {
+    fn rand01(&mut self) -> f32 {
+        self.rng ^= self.rng << 13;
+        self.rng ^= self.rng >> 17;
+        self.rng ^= self.rng << 5;
+        (self.rng >> 8) as f32 / (1u32 << 24) as f32
+    }
+
+    fn rand_signed(&mut self) -> f32 {
+        self.rand01() * 2.0 - 1.0
+    }
+
+    fn tick(&mut self, now_ms: i32, tag: Option<([f32; 3], [f32; 3])>) {
+        if self.held_until_ms >= now_ms
+            && let Some(tag) = tag
+        {
+            self.spawn_chunks(now_ms, tag);
+            self.tag = Some(tag);
+        } else {
+            self.tag = tag.filter(|_| self.held_until_ms >= now_ms);
+        }
+        let from = self.stepped_ms;
+        self.stepped_ms = now_ms;
+        let dt = (now_ms - from).max(0) as f32 * 0.001;
+        if dt > 0.0 {
+            self.step_chunks(now_ms, dt);
+            self.step_fires(now_ms, dt);
+        }
+        self.shed_fires(now_ms);
+    }
+
+    fn spawn_chunks(&mut self, now_ms: i32, (origin, forward): ([f32; 3], [f32; 3])) {
+        let v = &self.view;
+        if v.chunk_speed <= 0.0 || v.chunk_life_s <= 0.0 {
+            return;
+        }
+        let interval_ms =
+            ((v.chunk_dist_scalar * v.chunk_size[0] / v.chunk_speed) * 1000.0).max(1.0) as i32;
+        let (prev_origin, prev_forward) = self.tag.unwrap_or((origin, forward));
+        let span = (now_ms - self.next_chunk_ms).max(1) as f32;
+        let mut t = self.next_chunk_ms;
+        while t <= now_ms {
+            let f = 1.0 - (now_ms - t) as f32 / span;
+            let pos = Vec3::from_array(prev_origin).lerp(Vec3::from_array(origin), f);
+            let dir = Vec3::from_array(prev_forward)
+                .lerp(Vec3::from_array(forward), f)
+                .normalize_or(Vec3::from_array(forward));
+            let noise = self.rand01();
+            let v = &self.view;
+            let life_ms = (v.chunk_life_s * 1000.0) as i32;
+            let start = (1.0 - v.chunk_size_rand[0] * noise) * v.chunk_size[0];
+            let end = (1.0 - v.chunk_size_rand[1] * noise) * v.chunk_size[1];
+            let first_fire_ms = (v.fire_first_life_frac * 1000.0) as i32;
+            let interval = (v.fire_interval_s[0] * 1000.0) as i32;
+            let jitter = (self.rand01() * interval as f32) as i32;
+            let mut chunk = Chunk {
+                pos,
+                vel: dir * self.view.chunk_speed,
+                size: start,
+                growth: (end - start) / self.view.chunk_life_s,
+                birth_ms: t,
+                death_ms: t + life_ms,
+                next_fire_ms: t + first_fire_ms - jitter,
+            };
+            let catch_up = (now_ms - t) as f32 * 0.001;
+            if catch_up > 0.0 {
+                step_chunk(&self.view, &mut chunk, now_ms, catch_up);
+            }
+            self.chunks.push(chunk);
+            t += interval_ms;
+        }
+        self.next_chunk_ms = t;
+    }
+
+    fn step_chunks(&mut self, now_ms: i32, dt: f32) {
+        let view = &self.view;
+        self.chunks.retain_mut(|chunk| {
+            if now_ms >= chunk.death_ms {
+                return false;
+            }
+            step_chunk(view, chunk, now_ms, dt);
+            true
+        });
+    }
+
+    fn shed_fires(&mut self, now_ms: i32) {
+        let mut spawns = Vec::new();
+        for (index, chunk) in self.chunks.iter_mut().enumerate() {
+            let life = (chunk.death_ms - chunk.birth_ms).max(1) as f32;
+            while chunk.next_fire_ms <= now_ms {
+                let frac = ((chunk.next_fire_ms - chunk.birth_ms) as f32 / life).clamp(0.0, 1.0);
+                let interval_s = self.view.fire_interval_s[0]
+                    + (self.view.fire_interval_s[1] - self.view.fire_interval_s[0]) * frac;
+                chunk.next_fire_ms += ((interval_s * 1000.0) as i32).max(1);
+                spawns.push(index);
+            }
+        }
+        for index in spawns {
+            self.spawn_fire(index, now_ms);
+        }
+    }
+
+    fn spawn_fire(&mut self, chunk_index: usize, now_ms: i32) {
+        let (r_life, r_speed, r_side, r_z, r_rot) = (
+            self.rand01(),
+            self.rand01(),
+            self.rand_signed(),
+            self.rand01(),
+            self.rand_signed(),
+        );
+        let v = &self.view;
+        let chunk = &self.chunks[chunk_index];
+        let age_ms = now_ms - chunk.birth_ms;
+        let chunk_frac = age_ms as f32 / (chunk.death_ms - chunk.birth_ms).max(1) as f32;
+        let [early_s, late_s] = v.fire_min_life_age_s;
+        let age_s = age_ms as f32 * 0.001;
+        let weight = if age_s < early_s {
+            v.fire_min_life_frac
+        } else if age_s > late_s || late_s <= early_s {
+            0.0
+        } else {
+            v.fire_min_life_frac * (1.0 - (age_s - early_s) / (late_s - early_s))
+        };
+        let start_frac = chunk_frac.max(weight).min(0.99);
+        let life_s = r_life * v.fire_life_rand_s + v.fire_life_s;
+        if life_s <= 0.0 {
+            return;
+        }
+        let birth_ms = now_ms - (life_s * start_frac * 1000.0) as i32;
+        let size = v.fire_start_size_scale * chunk.size;
+        let end_size = v.fire_end_size_scale * chunk.size + v.fire_end_size_add;
+        let growth = ((end_size - size) / ((1.0 - start_frac) * life_s)).min(FIRE_GROWTH_CAP);
+        let mut vel = chunk.vel
+            * (((1.0 - v.fire_speed_scale_rand) + r_speed * v.fire_speed_scale_rand)
+                * v.fire_speed_scale);
+        let flat = Vec2::new(vel.x, vel.y);
+        let flat_len = flat.length();
+        if flat_len > 0.0 {
+            let side = Vec3::new(flat.y, -flat.x, 0.0) / flat_len;
+            vel += side * (r_side * v.fire_vel_add_sideways * flat_len);
+        }
+        vel.z += r_z * v.fire_vel_add_z_rand + v.fire_vel_add_z;
+        let fire = Fire {
+            pos: chunk.pos,
+            vel,
+            size,
+            growth,
+            rot: 0.0,
+            rot_vel: r_rot * v.fire_max_rot_vel,
+            birth_ms,
+            death_ms: birth_ms + (life_s * 1000.0) as i32,
+        };
+        if self.fires.len() >= FIRE_CAP {
+            self.fires.remove(0);
+        }
+        self.fires.push(fire);
+    }
+
+    fn step_fires(&mut self, now_ms: i32, dt: f32) {
+        let v = &self.view;
+        self.fires.retain_mut(|fire| {
+            if now_ms >= fire.death_ms {
+                return false;
+            }
+            let frac =
+                (now_ms - fire.birth_ms) as f32 / (fire.death_ms - fire.birth_ms).max(1) as f32;
+            fire.rot += fire.rot_vel * dt;
+            fire.size += fire.growth * dt;
+            fire.vel *= (1.0 - dt * v.fire_friction).max(0.0);
+            let gravity = v.fire_gravity[0] + (v.fire_gravity[1] - v.fire_gravity[0]) * frac;
+            fire.vel.z -= gravity * dt;
+            fire.pos += fire.vel * dt;
+            true
+        });
+    }
+}
+
+fn step_chunk(view: &FlameStreamView, chunk: &mut Chunk, now_ms: i32, dt: f32) {
+    let frac = ((now_ms - chunk.birth_ms) as f32 / (chunk.death_ms - chunk.birth_ms).max(1) as f32)
+        .clamp(0.0, 1.0);
+    chunk.size = (chunk.size + chunk.growth * dt).min(view.chunk_max_size.max(chunk.size));
+    chunk.vel *= (1.0 - dt * view.chunk_decel).max(0.0);
+    let gravity = view.chunk_gravity[0] + (view.chunk_gravity[1] - view.chunk_gravity[0]) * frac;
+    chunk.vel.z -= gravity * dt;
+    chunk.pos += chunk.vel * dt;
+}
+
+fn material_atlas(runtime: &MaterialGeneration, material: &str) -> [u32; 2] {
+    let [rows, cols] = runtime
+        .catalog
+        .material_for_name(asset_game::material_bind_name(material))
+        .map_or([1, 1], |m| m.texture_atlas);
+    [u32::from(rows.max(1)), u32::from(cols.max(1))]
+}
+
+fn atlas_frame([rows, cols]: [u32; 2], frac: f32) -> FxSpriteAtlasUv {
+    let count = rows * cols;
+    if count <= 1 {
+        return FxSpriteAtlasUv::FULL;
+    }
+    let frame = ((frac.max(0.0) * count as f32) as u32).min(count - 1);
+    FxSpriteAtlasUv {
+        s0: (frame % cols) as f32 / cols as f32,
+        ds: 1.0 / cols as f32,
+        t0: (frame / cols) as f32 / rows as f32,
+        dt: 1.0 / rows as f32,
+        entry_count: count as u16,
+        atlas_index: frame as u16,
+    }
+}
+
+fn present_fires(
+    stream: &FlameStream,
+    material: &str,
+    cam: &Transform,
+    color_images: &FxWorldColorImages,
+    runtime: &MaterialGeneration,
+    now_ms: i32,
+    plan: &mut FxCodeMeshPlan,
+) {
+    if stream.fires.is_empty() {
+        return;
+    }
+    let FxCodeMeshBind::Ready {
+        color,
+        sort_key,
+        ordinal,
+    } = code_mesh_bind(material, color_images, runtime)
+    else {
+        return;
+    };
+    let atlas = material_atlas(runtime, material);
+    let slot = plan.begin_material_draw(color, sort_key, Some(ordinal));
+    for fire in stream.fires.iter().rev() {
+        if fire.size <= 0.0 {
+            continue;
+        }
+        let frac = (now_ms - fire.birth_ms) as f32 / (fire.death_ms - fire.birth_ms).max(1) as f32;
+        let transform = Transform {
+            translation: fire.pos,
+            rotation: cam.rotation * Quat::from_rotation_z(fire.rot.to_radians()),
+            scale: Vec3::new(2.0 * fire.size, 2.0 * fire.size, 1.0),
+        };
+        if !plan.push_quad(transform, [255; 4], atlas_frame(atlas, frac)) {
+            break;
+        }
+    }
+    plan.end_material_draw(slot);
+}
+
+#[allow(clippy::too_many_arguments)]
+fn present_tube(
+    stream: &FlameStream,
+    tube: &FlameTube,
+    material: &str,
+    eye: Vec3,
+    color_images: &FxWorldColorImages,
+    runtime: &MaterialGeneration,
+    now_ms: i32,
+    plan: &mut FxCodeMeshPlan,
+) {
+    let Some((origin, _)) = stream.tag else {
+        return;
+    };
+    if tube.length <= 0.0 || stream.chunks.is_empty() {
+        return;
+    }
+    let origin = Vec3::from_array(origin);
+    let reach_sq = tube.length * tube.length;
+    let min_sq = TUBE_MIN_REACH_SQ[usize::from(!stream.player_view)];
+    let mut points = vec![origin];
+    let oldest = stream.chunks.len() - 1;
+    for (i, chunk) in stream.chunks.iter().rev().enumerate() {
+        if points.len() >= TUBE_POINT_CAP {
+            break;
+        }
+        let from_tag = chunk.pos.distance_squared(origin);
+        let within = from_tag < reach_sq && (from_tag > min_sq || i == oldest);
+        if within && chunk.pos.distance_squared(*points.last().unwrap()) > TUBE_MIN_SPACING_SQ {
+            points.push(chunk.pos);
+        }
+    }
+    if points.len() < 2 {
+        return;
+    }
+    let segments = (tube.segments as usize).clamp(2, TUBE_POINT_CAP);
+    let points = resample(&points, segments);
+    let FxCodeMeshBind::Ready {
+        color,
+        sort_key,
+        ordinal,
+    } = code_mesh_bind(material, color_images, runtime)
+    else {
+        return;
+    };
+    let loop_ms = (tube.anim_loop_s * 1000.0) as i32;
+    let phase = if loop_ms > 0 {
+        now_ms.rem_euclid(loop_ms) as f32 / loop_ms as f32
+    } else {
+        0.0
+    };
+    let uv = atlas_frame(material_atlas(runtime, material), phase);
+    let slot = plan.begin_material_draw(color, sort_key, Some(ordinal));
+    let base = plan.mesh.vert_used;
+    let last = points.len() - 1;
+    let normal = trail_pack_normal([0.0, 0.0, 1.0]);
+    for (i, point) in points.iter().enumerate() {
+        let dir = points[i.min(last - 1) + 1] - points[i.min(last - 1)];
+        // perp = delta x view; the winding needs the first vert on the negative side.
+        let side = dir.cross(*point - eye).normalize_or(Vec3::Z);
+        let f = i as f32 / last as f32;
+        let half = tube.size[0] + (tube.size[1] - tube.size[0]) * f;
+        let v = uv.t0 + (1.0 - f) * uv.dt;
+        for (sign, u) in [(-1.0, uv.s0), (1.0, uv.s0 + uv.ds)] {
+            if !plan.push_trail_vert(
+                (*point + side * (sign * half)).to_array(),
+                [255; 4],
+                trail_pack_texcoord(u, v),
+                normal,
+                FX_TRAIL_TANGENT_PACKED,
+            ) {
+                plan.shrink_verts_to(base);
+                plan.end_material_draw(slot);
+                return;
+            }
+        }
+    }
+    let index_used = plan.mesh.index_used;
+    for i in 0..last as u32 {
+        let q = base + i * 2;
+        if !plan.extend_indices(&[q + 1, q + 3, q, q, q + 3, q + 2]) {
+            plan.shrink_verts_to(base);
+            plan.shrink_indices_to(index_used);
+            break;
+        }
+    }
+    plan.end_material_draw(slot);
+}
+
+fn resample(points: &[Vec3], count: usize) -> Vec<Vec3> {
+    let total: f32 = points.windows(2).map(|w| w[0].distance(w[1])).sum();
+    if total <= 0.0 {
+        return points.to_vec();
+    }
+    let mut out = Vec::with_capacity(count);
+    let mut seg = 0;
+    let mut seg_start = 0.0;
+    for i in 0..count {
+        let target = total * i as f32 / (count - 1) as f32;
+        while seg + 1 < points.len() - 1
+            && seg_start + points[seg].distance(points[seg + 1]) < target
+        {
+            seg_start += points[seg].distance(points[seg + 1]);
+            seg += 1;
+        }
+        let len = points[seg].distance(points[seg + 1]).max(f32::EPSILON);
+        out.push(points[seg].lerp(
+            points[seg + 1],
+            ((target - seg_start) / len).clamp(0.0, 1.0),
+        ));
+    }
+    out
+}
+
+pub(crate) fn tick_flame_streams(
+    mut flames: ResMut<FlameStreams>,
+    host: Res<render_fx::HostFxSystem>,
+    fpv_bolts: Res<crate::adapters::anim::fpv_present::FpvBoltTargets>,
+    world_bolts: Query<(
+        &net::CEntityRuntime,
+        &crate::adapters::anim::remote_body::RemoteFxBolts,
+    )>,
+) {
+    if flames.streams.is_empty() {
+        return;
+    }
+    let tag = |target: Option<fx::FxBoltTarget>| {
+        target.map(|target| (target.orientation.origin, target.orientation.axis[0]))
+    };
+    flames.tick(host.0.msec_now, |entity, player_view| {
+        if player_view {
+            tag(fpv_bolts.flash[0])
+        } else {
+            tag(world_bolts
+                .get(entity)
+                .ok()
+                .filter(|(runtime, _)| runtime.in_next_snap())
+                .and_then(|(_, bolts)| bolts.flash))
+        }
+    });
+}
diff --git a/crates/render_frontend/src/adapters/fx/mod.rs b/crates/render_frontend/src/adapters/fx/mod.rs
index 3399f2e..c91fb2f 100644
--- a/crates/render_frontend/src/adapters/fx/mod.rs
+++ b/crates/render_frontend/src/adapters/fx/mod.rs
@@ -1,5 +1,6 @@
 pub use render_fx::fire_weapon_fx;
 pub use render_fx::present;
+pub(crate) mod flame;
 pub mod system;
 pub mod tracer;
 pub(crate) mod world_mark;
diff --git a/crates/render_frontend/src/adapters/fx/system.rs b/crates/render_frontend/src/adapters/fx/system.rs
index b720e69..4ea6bfc 100644
--- a/crates/render_frontend/src/adapters/fx/system.rs
+++ b/crates/render_frontend/src/adapters/fx/system.rs
@@ -104,6 +104,7 @@ pub(crate) fn register_combat_fx_systems(app: &mut App) {
     app.add_message::<BulletHitFx>()
         .add_message::<WeaponFireFx>()
         .scoped::<PresentedFireFx>(frame::MatchScope::Live)
+        .scoped::<super::flame::FlameStreams>(frame::MatchScope::Live)
         .scoped::<render_fx::FxModelStaging>(frame::MatchScope::Live)
         .scoped::<crate::assemble::drawsurf::GfxGlassMeshPlan>(frame::MatchScope::Live)
         .scoped::<crate::assemble::drawsurf::GlassTable>(frame::MatchScope::Live)
@@ -139,6 +140,7 @@ pub(crate) fn register_combat_fx_systems(app: &mut App) {
             (
                 maintain_fire_fx.in_set(frame::InMatch),
                 drain_weapon_fire_fx.in_set(frame::InMatch),
+                super::flame::tick_flame_streams.in_set(frame::InMatch),
                 drain_bullet_hit_fx.in_set(frame::InMatch),
                 drain_pellet_fx.in_set(frame::InMatch),
                 present_tracker_light.in_set(frame::InMatch),
@@ -626,7 +628,7 @@ fn commit_fx_transaction(
     mut mark_plan: ResMut<GfxMarkMeshPlan>,
     mut model_plan: ResMut<FxModelDrawPlan>,
     mut dump_req: ResMut<FxDumpRequest>,
-    mut tracer_world: ResMut<TracerWorld>,
+    (mut tracer_world, flames): (ResMut<TracerWorld>, Res<super::flame::FlameStreams>),
     mut combat: ResMut<CombatFxDump>,
     mut env: FxPresentEnv,
     lighting_cache: Option<Res<WorldModelLightingCache>>,
@@ -927,6 +929,7 @@ fn commit_fx_transaction(
         code_mesh_bind_asset,
     );
     *tracer_world = tracers;
+    flames.present(&cam_tf, &color_images, &runtime, host.0.msec_now, &mut plan);
 
     let mut spark_drawn = 0usize;
     for spark in &out.spark_clouds {
@@ -2071,7 +2074,10 @@ fn publish_weapon_fire(
     (view, settings): (Res<ViewSubject>, Res<frame::GameSettings>),
     (weapons, sound_bank): (Option<Res<PreparedWeapons>>, Option<Res<audio::SoundBank>>),
     prediction: Res<ClientPredictionState>,
-    mut sounds: Option<ResMut<Messages<audio::WeaponSound>>>,
+    (mut sounds, mut flames): (
+        Option<ResMut<Messages<audio::WeaponSound>>>,
+        Option<ResMut<Messages<audio::FlameFire>>>,
+    ),
     mut cursor: ResMut<FxJournalCursor>,
     mut combat: ResMut<CombatFxDump>,
 ) {
@@ -2107,6 +2113,27 @@ fn publish_weapon_fire(
         .get(fire.entity)
         .ok()
         .is_some_and(|identity| gate.skip_self_fpv(identity.number()));
+    if let (Some(flames), Some(weapons), Some(bank), Ok(number)) = (
+        flames.as_deref_mut(),
+        weapons.as_ref(),
+        sound_bank.as_deref(),
+        u32::try_from(fire.event.payload.number),
+    ) && weapons
+        .registry()
+        .weapon_sound_alias(
+            fire.event.payload.weapon,
+            asset_game::WeaponSoundSlot::FireStart,
+            &bank.0,
+        )
+        .is_some()
+    {
+        flames.write(audio::FlameFire {
+            number,
+            weapon: fire.event.payload.weapon,
+            player_view,
+            origin_inches: fire.event.payload.origin,
+        });
+    }
     let last_shot = is_weapon_fire_last_shot_event(fire.event.event);
     let alias = identities.get(fire.entity).ok().and_then(|_| {
         let weapons = weapons.as_ref()?;
@@ -2204,7 +2231,10 @@ fn drain_weapon_fire_fx(
     mut host: ResMut<HostFxSystem>,
     mut cursor: ResMut<FxJournalCursor>,
     mut combat: ResMut<CombatFxDump>,
-    mut ping_bus: ResMut<WeaponFirePingBus>,
+    (mut ping_bus, mut flames): (
+        ResMut<WeaponFirePingBus>,
+        ResMut<super::flame::FlameStreams>,
+    ),
     fx_world: FxSceneAccess,
 ) {
     let (view, settings) = view_settings;
@@ -2241,6 +2271,19 @@ fn drain_weapon_fire_fx(
             .ok()
             .is_some_and(|identity| gate.skip_self_fpv(identity.number()));
         combat.last_fire_player_view = Some(i64::from(player_view));
+        if let Some(stream) = weapons.as_ref().and_then(|weapons| {
+            weapons
+                .registry()
+                .flame_stream_of(fire.event.payload.weapon)
+        }) {
+            flames.note_fire(
+                fire.event.payload.number,
+                fire.entity,
+                player_view,
+                stream.view(player_view),
+                msec,
+            );
+        }
         let last_shot = is_weapon_fire_last_shot_event(fire.event.event);
         combat.last_fire_lastshot = Some(i64::from(last_shot));
         combat.last_tracer_name = combat_fx.and_then(|fx| fx.tracer_hint.clone());
@@ -2666,10 +2709,15 @@ fn explosion(
         .and_then(|weapons| weapons.registry().combat_fx_of(payload.weapon));
     combat.last_weapon_explosion_edge = combat_fx.map(|fx| fx.explosion.edge_kind().to_owned());
     let slot = combat_fx.and_then(|fx| fx.explosion_present());
+    let weapon_namespace = weapons
+        .as_ref()
+        .and_then(|weapons| weapons.registry().identity_namespace_of(payload.weapon));
     let names = explosion_fx_names(
         impact_type,
         payload.surf_type,
-        impact_fx.as_ref().and_then(|fx| fx.0.as_ref()),
+        impact_fx
+            .as_ref()
+            .and_then(|fx| fx.explosion_table(weapon_namespace)),
         slot,
     );
     combat.last_explosion_table = names.table.map(|n| n.name.to_owned());
@@ -2729,7 +2777,10 @@ fn explosion(
                         payload.weapon,
                         asset_game::WeaponComponent::Sound,
                     )?;
-                    if namespace != asset_core::AssetNamespace::Iw4 {
+                    if !matches!(
+                        namespace,
+                        asset_core::AssetNamespace::Iw4 | asset_core::AssetNamespace::Iw5
+                    ) {
                         return None;
                     }
                     let (alias, fallback) =
@@ -3261,13 +3312,12 @@ fn drain_pellet_fx(
     tracers: Option<Res<PreparedTracers>>,
     mut tracer_world: ResMut<TracerWorld>,
     mut gate: ResMut<TracerDrawGate>,
-    (local, generation, timeline, mut occurrences, verdicts, mut dyn_ent_hits): (
+    (local, generation, timeline, mut occurrences, verdicts): (
         Res<LocalPresentClient>,
         Res<frame::WorldGeneration>,
         Res<net::EntityEventCursor>,
         ResMut<PresentedFireFx>,
         Res<net::FireVerdictState>,
-        MessageWriter<crate::adapters::anim::dyn_ent_wake::DynEntPelletHit>,
     ),
     mut host: ResMut<HostFxSystem>,
     mut cursor: ResMut<FxJournalCursor>,
@@ -3281,14 +3331,6 @@ fn drain_pellet_fx(
         if world != generation.stamp() {
             continue;
         }
-        if domain != net::EntityEventDomain::Predicted && record.normal != [0.0; 3] {
-            dyn_ent_hits.write(crate::adapters::anim::dyn_ent_wake::DynEntPelletHit {
-                world,
-                weapon: record.weapon,
-                start: Vec3::from_array(record.start),
-                end: Vec3::from_array(record.end),
-            });
-        }
         let now = host.0.msec_now;
         let request = FireFxRequest {
             world,
diff --git a/crates/render_frontend/src/assemble/drawsurf/command_context.rs b/crates/render_frontend/src/assemble/drawsurf/command_context.rs
index c63f141..ef88023 100644
--- a/crates/render_frontend/src/assemble/drawsurf/command_context.rs
+++ b/crates/render_frontend/src/assemble/drawsurf/command_context.rs
@@ -101,6 +101,8 @@ pub const CODE_TEXTURE_OUTDOOR_SAMPLER: u8 = 0x62;
 
 pub const CODE_DEPTH_FROM_CLIP: u16 = 0x49;
 
+pub const CODE_ZNEAR: u16 = 0x21;
+
 pub const R_ZNEAR_DEPTHHACK: f32 = hud_iw4::R_ZNEAR_DEPTHHACK_DEFAULT;
 
 pub const CODE_TEXTURE_MODEL_LIGHTING: u32 = lighting_iw4::TEXTURE_SRC_CODE_MODEL_LIGHTING as u32;
@@ -544,6 +546,9 @@ pub(crate) fn update_command_context_code_sources(
             height: vp.height,
         },
     );
+    mat_frame
+        .code_sources
+        .set_constant_rows(CODE_ZNEAR, &[float4_bits([prepared.near, 0.0, 0.0, 0.0])]);
     if let Some(light) = dir_light.as_deref() {
         let _ = produce_dir_primary_light(&mut mat_frame.code_sources, light);
     }
diff --git a/crates/render_frontend/src/assemble/drawsurf/dof.rs b/crates/render_frontend/src/assemble/drawsurf/dof.rs
index 5bd4119..2ba45d4 100644
--- a/crates/render_frontend/src/assemble/drawsurf/dof.rs
+++ b/crates/render_frontend/src/assemble/drawsurf/dof.rs
@@ -137,15 +137,19 @@ fn update_dof(
     mut frame: ResMut<DofFrame>,
     mut scene: Local<DepthOfField>,
     clip: Res<crate::adapters::anim::dyn_ent::DynEntPhysClip>,
-    world: Res<frame::WorldGeneration>,
+    context: (Res<frame::InstalledMatch>, Res<net::EntityEventCursor>),
     view_settings: (Res<frame::ViewSubject>, Res<frame::GameSettings>),
     camera: Option<Res<render_anim::occupancy::view_kick::SessionViewKick>>,
-    mut generation: Local<Option<u64>>,
+    mut generation: Local<Option<frame::PresentationContext>>,
 ) {
     let (subject, settings) = view_settings;
     *frame = DofFrame::default();
-    if *generation != world.0 {
-        *generation = world.0;
+    let current = Some(frame::PresentationContext::new(
+        context.0.load_key,
+        context.1.timeline(),
+    ));
+    if *generation != current {
+        *generation = current;
         *scene = DepthOfField::default();
     }
     let Some(ps) = presented.player(local.0).filter(|_| view.ready) else {
diff --git a/crates/render_frontend/src/assemble/drawsurf/sun_effects.rs b/crates/render_frontend/src/assemble/drawsurf/sun_effects.rs
index 683ac3c..2ae8b29 100644
--- a/crates/render_frontend/src/assemble/drawsurf/sun_effects.rs
+++ b/crates/render_frontend/src/assemble/drawsurf/sun_effects.rs
@@ -13,7 +13,7 @@ pub struct SunEffectsFrameInput {
 
 #[derive(Default)]
 pub(crate) struct SunEffectsCameraTrack {
-    world_generation: Option<u64>,
+    context: Option<frame::PresentationContext>,
     camera_key: u64,
     origin: Vec3,
     armed: bool,
@@ -29,7 +29,23 @@ pub(crate) fn publish_sun_effects_frame(
     clock: Option<Res<FrameClock>>,
     world_generation: Option<Res<frame::WorldGeneration>>,
     cameras: Query<(Entity, &GlobalTransform), (With<Camera3d>, Without<FpvLens>)>,
+    context: (
+        Option<Res<frame::InstalledMatch>>,
+        Option<Res<net::EntityEventCursor>>,
+    ),
 ) {
+    let current = context
+        .0
+        .as_ref()
+        .zip(context.1.as_ref())
+        .map(|(installed, timeline)| {
+            frame::PresentationContext::new(installed.load_key, timeline.timeline())
+        });
+    let context_changed = track.context != current;
+    if context_changed {
+        *track = SunEffectsCameraTrack::default();
+        track.context = current;
+    }
     let Some(def) = sun.and_then(|sun| sun.def) else {
         *published = SunEffectsFrameInput::default();
         *track = SunEffectsCameraTrack::default();
@@ -51,10 +67,9 @@ pub(crate) fn publish_sun_effects_frame(
         0.0
     };
     let camera_cut = !track.armed
-        || track.world_generation != generation
+        || context_changed
         || track.camera_key != camera_key
         || origin_delta > CAMERA_CUT_ORIGIN;
-    track.world_generation = generation;
     track.camera_key = camera_key;
     track.origin = origin;
     track.armed = true;
diff --git a/crates/render_frontend/src/prepare/scene/spawn.rs b/crates/render_frontend/src/prepare/scene/spawn.rs
index 8fd6dd9..e5c3d21 100644
--- a/crates/render_frontend/src/prepare/scene/spawn.rs
+++ b/crates/render_frontend/src/prepare/scene/spawn.rs
@@ -949,7 +949,149 @@ pub(crate) fn arm_world_spawn_on_install(
     };
 }
 
+fn check_skin_support(
+    support: Option<Res<render_scene::SkinSupport>>,
+    generation: Option<Res<WorldGeneration>>,
+    scene: Option<ResMut<WorldScene>>,
+    products: (
+        Option<Res<assets::PreparedBodies>>,
+        Option<Res<assets::PreparedFpvMeshes>>,
+        Option<Res<assets::PreparedWorldWeapons>>,
+        Option<Res<assets::PreparedWeapons>>,
+    ),
+    mut checked: Local<Option<(WorldStamp, u64)>>,
+) {
+    let Some(support) = support else {
+        return;
+    };
+    let world = generation.map_or(WorldStamp(None), |generation| generation.stamp());
+    support.set_world(world);
+    let Some(mut scene) = scene else {
+        return;
+    };
+    if world.0.is_none() {
+        return;
+    }
+    let installation = (world, support.device_generation());
+    if *checked != Some(installation) {
+        let Some(limits) = support.limits() else {
+            scene.readiness.state = frame::ReadinessState::Pending;
+            return;
+        };
+        let (Some(bodies), Some(fpv), Some(weapons), Some(registry)) = products else {
+            scene.readiness.state = frame::ReadinessState::Pending;
+            return;
+        };
+        let actors = u64::from(master_protocol::MAX_SESSION_MEMBERS)
+            + playerstate_iw4::MAX_CLIENT_CORPSES as u64;
+        let body_sizes: Vec<u64> = bodies
+            .0
+            .names()
+            .filter_map(|name| bodies.0.get(name))
+            .map(|entry| entry.skel.packed_vertices.len() as u64)
+            .collect();
+        let weapon_sizes: Vec<u64> = (0..weapons.0.len())
+            .filter_map(|index| weapons.0.get_at(index))
+            .map(|entry| entry.skel.packed_vertices.len() as u64)
+            .collect();
+        let body = body_sizes.iter().copied().max().unwrap_or(0);
+        let weapon = weapon_sizes.iter().copied().max().unwrap_or(0);
+        let mut fpv_vertices = 0_u64;
+        let mut fpv_parts = 0_u64;
+        for id in 1..=registry.registry().len() as u32 {
+            for axis in [false, true] {
+                let Some(side) = registry.registry().fpv_assemblies_of(id, axis) else {
+                    continue;
+                };
+                for assembly in std::iter::once(&side.bare)
+                    .chain(side.rocket.iter())
+                    .chain(side.melee.iter())
+                    .chain(side.ads.iter())
+                    .chain(side.jammed.iter())
+                {
+                    let vertices = assembly
+                        .parts()
+                        .iter()
+                        .filter_map(|part| fpv.0.get_at(part.model.order()))
+                        .map(|part| part.skel.packed_vertices.len() as u64)
+                        .sum();
+                    fpv_vertices = fpv_vertices.max(vertices);
+                    fpv_parts = fpv_parts.max(assembly.parts().len() as u64);
+                }
+            }
+        }
+        let output = ((body * 2 + weapon * 7) * actors + fpv_vertices) * 32;
+        let input = ((body * 2 + weapon * 7) * actors + fpv_vertices) * 64;
+        let max_bones = bodies
+            .0
+            .names()
+            .filter_map(|name| bodies.0.get(name))
+            .map(|entry| entry.skel.bones.len() as u64)
+            .chain(
+                (0..weapons.0.len())
+                    .filter_map(|index| weapons.0.get_at(index))
+                    .map(|entry| entry.skel.bones.len() as u64),
+            )
+            .chain(
+                (0..fpv.0.len())
+                    .filter_map(|index| fpv.0.get_at(index))
+                    .map(|entry| entry.skel.bones.len() as u64),
+            )
+            .max()
+            .unwrap_or(0);
+        let palettes = (actors * 9 + fpv_parts) * max_bones * 64;
+        let largest_shape = body.max(weapon).max(
+            (0..fpv.0.len())
+                .filter_map(|index| fpv.0.get_at(index))
+                .map(|entry| entry.skel.packed_vertices.len() as u64)
+                .max()
+                .unwrap_or(0),
+        );
+        diag::info!(
+            World,
+            "skinning support envelope: actors={actors} output={output} input={input} palettes={palettes} largest_shape={largest_shape} max_bones={max_bones} budget={} buffer_limit={} binding_limit={}",
+            support.resident_budget,
+            limits.buffer_bytes,
+            limits.storage_bytes
+        );
+        if largest_shape * 64 > limits.storage_bytes
+            || max_bones * 64 > limits.storage_bytes
+            || output > limits.buffer_bytes
+        {
+            support.refuse(
+                world,
+                render_frame::skinning::SkinRefusal::UnsupportedProduct,
+            );
+        } else if (input + palettes)
+            .saturating_mul(2)
+            .saturating_add(output.saturating_mul(3))
+            > support.resident_budget
+        {
+            support.refuse(
+                world,
+                render_frame::skinning::SkinRefusal::ResidencyPressure,
+            );
+        }
+        if let Some(refusal) = support.failure(world) {
+            diag::warn!(World, "skinning support refused: {refusal:?}");
+        }
+        *checked = Some(installation);
+        if scene.spawned && support.failure(world).is_none() {
+            scene.readiness.state = frame::ReadinessState::Ready;
+        }
+    }
+    if support.failure(world).is_some() {
+        scene.readiness.state = frame::ReadinessState::Failed;
+    }
+}
+
 pub(crate) fn register_world_gpu_ready(app: &mut App) {
+    app.add_systems(
+        Update,
+        check_skin_support
+            .after(spawn_world)
+            .in_set(frame::ClientSet::Present),
+    );
     super::world_gpu::register_resources(app);
     app.scoped::<super::world_images::ResidentGpuImages>(frame::MatchScope::Live);
     app.add_systems(
diff --git a/crates/render_fx/src/combat.rs b/crates/render_fx/src/combat.rs
index d908db7..c6c5203 100644
--- a/crates/render_fx/src/combat.rs
+++ b/crates/render_fx/src/combat.rs
@@ -410,7 +410,7 @@ pub fn play_impact_table_cell(
             .get(surf_type as usize)
             .map(|name| (*name).to_owned());
         let exit = surface_flags & FX_IMPACT_EXIT_SURFACE_FLAG != 0;
-        let table = impact_fx.and_then(|fx| fx.0.as_ref());
+        let table = impact_fx.and_then(|fx| fx.map.as_ref());
         let Some(row) = table.map_or_else(
             || impact_table_row(impact_type, exit),
             |table| table.impact_row(impact_type, exit),
diff --git a/crates/render_fx/src/host.rs b/crates/render_fx/src/host.rs
index 082daa3..9ec5c98 100644
--- a/crates/render_fx/src/host.rs
+++ b/crates/render_fx/src/host.rs
@@ -17,7 +17,22 @@ pub struct PreparedFxModels(pub asset_game::FxModelCatalog);
 pub struct PreparedFxElemInfos(pub FxElemInfoCache);
 
 #[derive(Resource, Default)]
-pub struct PreparedImpactFx(pub Option<asset_game::OwnedFxImpactTable>);
+pub struct PreparedImpactFx {
+    pub map: Option<asset_game::OwnedFxImpactTable>,
+    pub families: Vec<asset_game::OwnedFxImpactTable>,
+}
+
+impl PreparedImpactFx {
+    pub fn explosion_table(
+        &self,
+        weapon_namespace: Option<asset_core::AssetNamespace>,
+    ) -> Option<&asset_game::OwnedFxImpactTable> {
+        self.families
+            .iter()
+            .find(|table| Some(table.namespace) == weapon_namespace)
+            .or(self.map.as_ref())
+    }
+}
 
 #[derive(Resource, Default)]
 pub struct FxWorldColorImages {
diff --git a/crates/render_fx/src/present.rs b/crates/render_fx/src/present.rs
index bedb2a2..9371a96 100644
--- a/crates/render_fx/src/present.rs
+++ b/crates/render_fx/src/present.rs
@@ -689,6 +689,7 @@ fn eval_pending_collide(
             |start, end, mins, maxs, mask| {
                 let t = world.trace_world(start, end, mins, maxs, mask);
                 FxElemTraceHit {
+                    complete: world.collision_complete(),
                     fraction: t.fraction,
                     normal: t.normal,
                     startsolid: t.startsolid != 0,
@@ -723,6 +724,7 @@ fn evaluate_physics_piece(
         |start, end, mins, maxs, mask| {
             let t = world.trace_world(start, end, mins, maxs, mask);
             FxElemTraceHit {
+                complete: world.collision_complete(),
                 fraction: t.fraction,
                 normal: t.normal,
                 startsolid: t.startsolid != 0,
@@ -892,6 +894,7 @@ fn tick_fx_pass(
                         |start, end, mins, maxs, mask| {
                             let t = world.trace_world(start, end, mins, maxs, mask);
                             FxElemTraceHit {
+                                complete: world.collision_complete(),
                                 fraction: t.fraction,
                                 normal: t.normal,
                                 startsolid: t.startsolid != 0,
diff --git a/crates/render_gpu/Cargo.toml b/crates/render_gpu/Cargo.toml
index 5b1834d..8888037 100644
--- a/crates/render_gpu/Cargo.toml
+++ b/crates/render_gpu/Cargo.toml
@@ -24,6 +24,7 @@ lighting_iw4.workspace = true
 perf.workspace = true
 render_backend.workspace = true
 render_frame.workspace = true
+render_scene.workspace = true
 render_material.workspace = true
 bevy.workspace = true
 
diff --git a/crates/render_gpu/src/drawsurf/colour_submit/mod.rs b/crates/render_gpu/src/drawsurf/colour_submit/mod.rs
index 79ef2a7..4b447f4 100644
--- a/crates/render_gpu/src/drawsurf/colour_submit/mod.rs
+++ b/crates/render_gpu/src/drawsurf/colour_submit/mod.rs
@@ -130,6 +130,7 @@ fn upload_exact_geometry(
     mut pending: ResMut<bevy::render::renderer::PendingCommandBuffers>,
     device: Res<RenderDevice>,
     queue: Res<RenderQueue>,
+    support: Res<crate::SkinSupport>,
 ) {
     let result = geometry::upload_exact_geometry(
         &frame,
@@ -145,7 +146,22 @@ fn upload_exact_geometry(
         &device,
         &queue,
         &mut pending,
+        support.resident_budget,
     );
+    let limits = device.limits();
+    support.report(
+        frame.world_generation,
+        render_frame::skinning::SkinBatchLimits {
+            storage_bytes: limits.max_storage_buffer_binding_size,
+            buffer_bytes: limits.max_buffer_size,
+            storage_alignment: u64::from(limits.min_storage_buffer_offset_alignment),
+            uniform_alignment: u64::from(limits.min_uniform_buffer_offset_alignment),
+            dispatch_groups: limits.max_compute_workgroups_per_dimension,
+        },
+        skin.device_generation(),
+        skinned.as_ref().err().copied(),
+    );
+    let skinned = skinned.unwrap_or_default();
     perf::Counter::CounterSkinJobs.emit(skinned.jobs as f64);
     perf::Counter::CounterSkinVertices.emit(skinned.vertices as f64);
     perf::Counter::CounterSkinResidentBytes.emit(skin.resident_bytes() as f64);
@@ -2945,6 +2961,9 @@ pub(super) fn register(app: &mut App) {
             (
                 pipeline::init_or_update_pipeline.in_set(RenderSystems::PrepareAssets),
                 upload_exact_geometry.in_set(RenderSystems::PrepareResources),
+                skinning::retire_submitted_buffers
+                    .after(RenderSystems::Render)
+                    .before(RenderSystems::Cleanup),
                 pipeline::kick_extracted_colour_pipelines.in_set(RenderSystems::Prepare),
                 prepare_camera::install_shared_colour_pass
                     .in_set(RenderSystems::Prepare)
diff --git a/crates/render_gpu/src/drawsurf/colour_submit/record.rs b/crates/render_gpu/src/drawsurf/colour_submit/record.rs
index bde2571..d85e13c 100644
--- a/crates/render_gpu/src/drawsurf/colour_submit/record.rs
+++ b/crates/render_gpu/src/drawsurf/colour_submit/record.rs
@@ -9,6 +9,7 @@ pub(super) fn draw_exact_colour(
         Option<&Msaa>,
     )>,
     frame: Res<PublishedRenderFrame>,
+    support: Res<crate::SkinSupport>,
     geometry: Res<ExactColourGeometry>,
     smodel_cache_gpu: Res<SmodelCacheGpu>,
     pipeline: Res<ExactColourPipeline>,
@@ -60,6 +61,9 @@ pub(super) fn draw_exact_colour(
     ),
     mut context: RenderContext,
 ) {
+    if support.failure(frame.world_generation).is_some() {
+        return;
+    }
     let extracted = ExtractedColourRefs::new(&frame);
     let products = &extracted.frame.frame_products;
     let _colour_submit = perf::Span::RenderColourSubmitMs.enter();
diff --git a/crates/render_gpu/src/drawsurf/colour_submit/residency.rs b/crates/render_gpu/src/drawsurf/colour_submit/residency.rs
index 2954ad0..942aacb 100644
--- a/crates/render_gpu/src/drawsurf/colour_submit/residency.rs
+++ b/crates/render_gpu/src/drawsurf/colour_submit/residency.rs
@@ -24,6 +24,7 @@ pub(super) struct GpuStream {
     stride: usize,
 
     allocation: u64,
+    device: Option<RenderDevice>,
 }
 
 impl GpuStream {
@@ -58,20 +59,41 @@ impl GpuStream {
         usage: BufferUsages,
         elements: usize,
         stride: usize,
-    ) {
+    ) -> bool {
+        if self
+            .device
+            .as_ref()
+            .is_none_or(|previous| previous.wgpu_device() != device.wgpu_device())
+        {
+            self.buffer = None;
+            self.capacity = 0;
+            self.device = Some(device.clone());
+        }
         self.stride = stride;
         let bytes = u64::try_from(elements.saturating_mul(stride)).unwrap_or(u64::MAX);
         if self.fits(bytes) {
-            return;
+            return true;
         }
-        self.capacity = stream_capacity(bytes);
+        let limits = device.limits();
+        let limit = limits.max_buffer_size;
+        if bytes.next_multiple_of(RANGE_GRANULE as u64) > limit {
+            self.buffer = None;
+            self.capacity = 0;
+            return false;
+        }
+        self.capacity =
+            stream_capacity(bytes).min(limit / RANGE_GRANULE as u64 * RANGE_GRANULE as u64);
         self.buffer = Some(device.create_buffer(&BufferDescriptor {
             label: Some(label),
             size: self.capacity,
             usage: usage | BufferUsages::COPY_DST,
             mapped_at_creation: false,
         }));
-        self.allocation = self.allocation.wrapping_add(1);
+        self.allocation = self
+            .allocation
+            .checked_add(1)
+            .expect("GPU allocation generation exhausted");
+        true
     }
 
     pub(super) fn set_len(&mut self, elements: usize) {
diff --git a/crates/render_gpu/src/drawsurf/colour_submit/skinning.rs b/crates/render_gpu/src/drawsurf/colour_submit/skinning.rs
index b0e74f8..281d410 100644
--- a/crates/render_gpu/src/drawsurf/colour_submit/skinning.rs
+++ b/crates/render_gpu/src/drawsurf/colour_submit/skinning.rs
@@ -1,13 +1,13 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::num::NonZeroU64;
 use std::sync::{Arc, Weak};
 
 use bevy::prelude::Resource;
 use bevy::render::render_resource::*;
 use bevy::render::renderer::{PendingCommandBuffers, RenderDevice, RenderQueue};
-use render_frame::skinning::{PackedSkinJob, PackedSkinShape};
-
-use super::residency::GpuStream;
+use render_frame::skinning::{
+    PackedSkinJob, PackedSkinShape, SkinBatchLimits, SkinRefusal, plan_skin_batches,
+};
 
 const VERTEX_BYTES: u64 = 32;
 const PARAMS_BYTES: u64 = 48;
@@ -17,12 +17,10 @@ struct Pipeline {
     pipeline: ComputePipeline,
 }
 
-/// Lives as long as the main world holds the shape, not as long as the shape
-/// keeps showing up in frames: a body culled for one frame keeps its upload.
 struct ResidentShape {
     owner: Weak<PackedSkinShape>,
     buffer: Buffer,
-    binding: Option<([BufferId; 3], BindGroup)>,
+    last_used: u64,
 }
 
 #[derive(Default, Clone, Copy, PartialEq, Eq, Debug)]
@@ -34,28 +32,36 @@ pub(super) struct Skinned {
 #[derive(Resource, Default)]
 pub(super) struct SkinGpu {
     pipeline: Option<Pipeline>,
+    device: Option<RenderDevice>,
+    device_generation: u64,
     shapes: HashMap<u64, ResidentShape>,
-    reported: HashMap<u64, Weak<PackedSkinShape>>,
-    bones: GpuStream,
-    params: GpuStream,
-    bone_rows: Vec<[[f32; 4]; 4]>,
-    param_rows: Vec<u8>,
-    accepted: Vec<usize>,
-    refused: Vec<(usize, &'static str)>,
+    frame: u64,
+    output_bytes: u64,
+    frame_buffers: Vec<Buffer>,
+    retired: Vec<Buffer>,
+    retired_bytes: Arc<std::sync::atomic::AtomicU64>,
 }
 
 impl SkinGpu {
+    pub(super) fn device_generation(&self) -> u64 {
+        self.device_generation
+    }
+
     pub(super) fn resident_bytes(&self) -> u64 {
         self.shapes
             .values()
             .map(|shape| shape.buffer.size())
-            .chain(
-                [self.bones.buffer(), self.params.buffer()]
-                    .into_iter()
-                    .flatten()
-                    .map(|buffer| buffer.size()),
-            )
-            .sum()
+            .sum::<u64>()
+            + self
+                .frame_buffers
+                .iter()
+                .map(|buffer| buffer.size())
+                .sum::<u64>()
+            + self.output_bytes.saturating_mul(2)
+            + self.retired.iter().map(|buffer| buffer.size()).sum::<u64>()
+            + self
+                .retired_bytes
+                .load(std::sync::atomic::Ordering::Acquire)
     }
 
     pub(super) fn dispatch(
@@ -64,228 +70,235 @@ impl SkinGpu {
         output: Option<&Buffer>,
         vertex_count: usize,
         device: &RenderDevice,
-        queue: &RenderQueue,
+        _queue: &RenderQueue,
         pending: &mut PendingCommandBuffers,
-    ) -> Skinned {
+        budget: u64,
+    ) -> Result<Skinned, SkinRefusal> {
         let _prepare = perf::Span::RenderSkinPrepareMs.enter();
-        self.shapes
-            .retain(|_, shape| shape.owner.strong_count() != 0);
-        self.reported.retain(|_, shape| shape.strong_count() != 0);
-        self.accepted.clear();
-        self.refused.clear();
+        if self
+            .device
+            .as_ref()
+            .is_none_or(|previous| previous.wgpu_device() != device.wgpu_device())
+        {
+            let generation = self
+                .device_generation
+                .checked_add(1)
+                .expect("skin device generation exhausted");
+            *self = Self::default();
+            self.device = Some(device.clone());
+            self.device_generation = generation;
+        }
+        self.frame = self.frame.wrapping_add(1);
+        self.retired.append(&mut self.frame_buffers);
+        let expired: Vec<u64> = self
+            .shapes
+            .iter()
+            .filter(|(_, shape)| shape.owner.strong_count() == 0)
+            .map(|(id, _)| *id)
+            .collect();
+        for id in expired {
+            if let Some(shape) = self.shapes.remove(&id) {
+                self.retired.push(shape.buffer);
+            }
+        }
         if jobs.is_empty() {
-            return Skinned::default();
+            return Ok(Skinned::default());
         }
-        let Some(output) = output else {
-            self.refused
-                .extend((0..jobs.len()).map(|index| (index, "no xmodel vertex buffer")));
-            self.report(jobs);
-            return Skinned::default();
-        };
+        let output = output.ok_or(SkinRefusal::UnsupportedProduct)?;
+        self.output_bytes = output.size();
         let limits = device.limits();
-        let max_binding = limits.max_storage_buffer_binding_size;
-        let bank = (vertex_count as u64).min(output.size() / VERTEX_BYTES) as usize;
-        let bank_refusal = (vertex_count as u64 * VERTEX_BYTES > output.size()
-            || output.size() > max_binding)
-            .then_some("xmodel vertex bank exceeds its buffer or the storage binding limit");
-        for (index, job) in jobs.iter().enumerate() {
-            if job.ranges.iter().all(|range| range.count == 0) {
-                continue;
-            }
-            let count = job.shape.vertices().len();
-            let end = (job.destination as usize).checked_add(count);
-            let refusal = bank_refusal.or(if count == 0 {
-                Some("empty shape")
-            } else if end.is_none_or(|end| end > vertex_count) {
-                Some("destination outside the xmodel vertex bank")
-            } else if count.div_ceil(64) > limits.max_compute_workgroups_per_dimension as usize
-                || count as u64 * 64 > max_binding
-            {
-                Some("shape exceeds the dispatch or binding limit")
-            } else if job.ranges.iter().any(|range| {
-                range
-                    .start
-                    .checked_add(range.count)
-                    .is_none_or(|end| end as usize > count)
-            }) {
-                Some("surface range outside the shape")
-            } else if job.bones.is_empty() || job.shape.required_bones() > job.bones.len() {
-                Some("bone palette shorter than the shape")
-            } else {
-                None
-            });
-            match refusal {
-                Some(reason) => self.refused.push((index, reason)),
-                None => self.accepted.push(index),
+        let batches = plan_skin_batches(
+            jobs,
+            output.size().min(vertex_count as u64 * VERTEX_BYTES),
+            SkinBatchLimits {
+                storage_bytes: limits.max_storage_buffer_binding_size,
+                buffer_bytes: limits.max_buffer_size,
+                storage_alignment: u64::from(limits.min_storage_buffer_offset_alignment),
+                uniform_alignment: u64::from(limits.min_uniform_buffer_offset_alignment),
+                dispatch_groups: limits.max_compute_workgroups_per_dimension,
+            },
+        )?;
+        let needed: HashSet<u64> = batches
+            .iter()
+            .flat_map(|batch| batch.jobs.iter().map(|index| jobs[*index].shape.id()))
+            .collect();
+        let unique: HashMap<u64, &PackedSkinShape> = batches
+            .iter()
+            .flat_map(|batch| {
+                batch
+                    .jobs
+                    .iter()
+                    .map(|index| (jobs[*index].shape.id(), jobs[*index].shape.as_ref()))
+            })
+            .collect();
+        let inputs = unique
+            .values()
+            .map(|shape| shape.vertices().len() as u64 * 64)
+            .sum::<u64>();
+        let transient = batches
+            .iter()
+            .map(|batch| batch.palette_bytes + batch.parameter_bytes)
+            .sum::<u64>();
+        if inputs
+            .saturating_add(transient.saturating_mul(2))
+            .saturating_add(output.size().saturating_mul(2))
+            > budget
+        {
+            return Err(SkinRefusal::ResidencyPressure);
+        }
+        while self
+            .resident_bytes()
+            .saturating_add(inputs)
+            .saturating_add(transient.saturating_mul(2))
+            > budget
+        {
+            let cold = self
+                .shapes
+                .iter()
+                .filter(|(id, _)| !needed.contains(id))
+                .min_by_key(|(_, shape)| shape.last_used)
+                .map(|(id, _)| *id);
+            let Some(cold) = cold else {
+                break;
+            };
+            if let Some(shape) = self.shapes.remove(&cold) {
+                self.retired.push(shape.buffer);
             }
         }
-        self.accepted
-            .sort_unstable_by_key(|&index| jobs[index].destination);
-        let mut covered = 0usize;
-        let refused = &mut self.refused;
-        self.accepted.retain(|&index| {
-            let start = jobs[index].destination as usize;
-            if start < covered {
-                refused.push((index, "overlaps another job's destination"));
-                return false;
-            }
-            covered = start + jobs[index].shape.vertices().len();
-            true
-        });
+        let additional = unique
+            .iter()
+            .filter(|(id, _)| !self.shapes.contains_key(id))
+            .map(|(_, shape)| shape.vertices().len() as u64 * 64)
+            .sum::<u64>();
+        if self
+            .resident_bytes()
+            .saturating_add(additional)
+            .saturating_add(transient)
+            > budget
+        {
+            return Err(SkinRefusal::ResidencyPressure);
+        }
+        for (id, shape) in unique {
+            let resident = self.shapes.entry(id).or_insert_with(|| ResidentShape {
+                owner: Arc::downgrade(
+                    &jobs
+                        .iter()
+                        .find(|job| job.shape.id() == id)
+                        .expect("shape owner")
+                        .shape,
+                ),
+                buffer: device.create_buffer_with_data(&BufferInitDescriptor {
+                    label: Some("packed_skin_shape"),
+                    contents: bytemuck::cast_slice(shape.vertices()),
+                    usage: BufferUsages::STORAGE,
+                }),
+                last_used: self.frame,
+            });
+            resident.last_used = self.frame;
+        }
         let stride =
             PARAMS_BYTES.next_multiple_of(u64::from(limits.min_uniform_buffer_offset_alignment));
-        self.bone_rows.clear();
-        self.param_rows.clear();
-        let mut kept = Vec::with_capacity(self.accepted.len());
-        for &index in &self.accepted {
-            let job = &jobs[index];
-            let bone_base = self.bone_rows.len();
-            if (bone_base + job.bones.len()) as u64 * 64 > max_binding {
-                self.refused
-                    .push((index, "frame bone palette exceeds the binding limit"));
-                continue;
-            }
-            self.bone_rows.extend_from_slice(&job.bones);
-            for range in job.ranges.iter().filter(|range| range.count != 0) {
-                let params = [
-                    job.destination,
-                    range.count,
-                    bone_base as u32,
-                    range.start,
-                    job.offset[0].to_bits(),
-                    job.offset[1].to_bits(),
-                    job.offset[2].to_bits(),
-                    0,
-                    u32::from(range.rigid),
-                    0,
-                    0,
-                    0,
-                ];
-                let slot = self.param_rows.len().div_ceil(stride as usize);
-                self.param_rows.resize(slot * stride as usize, 0);
-                self.param_rows
-                    .extend_from_slice(bytemuck::cast_slice(&params));
-            }
-            kept.push(index);
-        }
-        self.accepted = kept;
-        if !self.accepted.is_empty() {
-            self.bones.reserve(
-                device,
-                "packed_skin_bones",
-                BufferUsages::STORAGE,
-                self.bone_rows.len(),
-                64,
-            );
-            self.params.reserve(
-                device,
-                "packed_skin_params",
-                BufferUsages::UNIFORM,
-                self.param_rows.len().div_ceil(stride as usize),
-                stride as usize,
-            );
-            if !(self
-                .bones
-                .write_at(queue, 0, bytemuck::cast_slice(&self.bone_rows))
-                && self.params.write_at(queue, 0, &self.param_rows))
-            {
-                self.refused.extend(
-                    self.accepted
-                        .drain(..)
-                        .map(|index| (index, "bone or parameter upload refused")),
-                );
-            }
-        }
-        self.report(jobs);
+        let pipeline = self.pipeline.get_or_insert_with(|| make_pipeline(device));
         let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor {
             label: Some("packed_skin"),
         });
-        for &(index, _) in &self.refused {
-            let job = &jobs[index];
-            let start = (job.destination as usize).min(bank);
-            let end = start.saturating_add(job.shape.vertices().len()).min(bank);
-            if end > start {
-                encoder.clear_buffer(
-                    output,
-                    start as u64 * VERTEX_BYTES,
-                    Some((end - start) as u64 * VERTEX_BYTES),
-                );
-            }
-        }
         let mut skinned = Skinned::default();
-        if !self.accepted.is_empty() {
-            let pipeline = self.pipeline.get_or_insert_with(|| make_pipeline(device));
-            let bones = self.bones.buffer().expect("bones reserved");
-            let params = self.params.buffer().expect("params reserved");
-            let key = [bones.id(), params.id(), output.id()];
+        for batch in batches {
+            let mut bone_rows = Vec::new();
+            let mut param_rows = Vec::new();
+            for &index in &batch.jobs {
+                let job = &jobs[index];
+                let base = bone_rows.len() as u32;
+                bone_rows.extend_from_slice(&job.bones);
+                for range in job.ranges.iter().filter(|range| range.count != 0) {
+                    let params = [
+                        job.destination - (batch.output_offset / VERTEX_BYTES) as u32,
+                        range.count,
+                        base,
+                        range.start,
+                        job.offset[0].to_bits(),
+                        job.offset[1].to_bits(),
+                        job.offset[2].to_bits(),
+                        0,
+                        u32::from(range.rigid),
+                        0,
+                        0,
+                        0,
+                    ];
+                    let slot = param_rows.len().div_ceil(stride as usize);
+                    param_rows.resize(slot * stride as usize, 0);
+                    param_rows.extend_from_slice(bytemuck::cast_slice(&params));
+                }
+            }
+            let bones = device.create_buffer_with_data(&BufferInitDescriptor {
+                label: Some("packed_skin_bones"),
+                contents: bytemuck::cast_slice(&bone_rows),
+                usage: BufferUsages::STORAGE,
+            });
+            let params = device.create_buffer_with_data(&BufferInitDescriptor {
+                label: Some("packed_skin_params"),
+                contents: &param_rows,
+                usage: BufferUsages::UNIFORM,
+            });
             let mut pass = encoder.begin_compute_pass(&ComputePassDescriptor {
                 label: Some("packed_skin"),
                 timestamp_writes: None,
             });
             pass.set_pipeline(&pipeline.pipeline);
-            let mut slot = 0u64;
-            for &index in &self.accepted {
+            let mut slot = 0_u64;
+            for index in batch.jobs {
                 let job = &jobs[index];
-                let shape = self
-                    .shapes
-                    .entry(job.shape.id())
-                    .or_insert_with(|| ResidentShape {
-                        owner: Arc::downgrade(&job.shape),
-                        buffer: device.create_buffer_with_data(&BufferInitDescriptor {
-                            label: Some("packed_skin_shape"),
-                            contents: bytemuck::cast_slice(job.shape.vertices()),
-                            usage: BufferUsages::STORAGE,
+                let shape = &self.shapes[&job.shape.id()];
+                let binding = device.create_bind_group(
+                    "packed_skin",
+                    &pipeline.layout,
+                    &BindGroupEntries::sequential((
+                        shape.buffer.as_entire_binding(),
+                        bones.as_entire_binding(),
+                        BindingResource::Buffer(BufferBinding {
+                            buffer: &params,
+                            offset: 0,
+                            size: NonZeroU64::new(PARAMS_BYTES),
                         }),
-                        binding: None,
-                    });
-                if shape.binding.as_ref().is_none_or(|(at, _)| *at != key) {
-                    let binding = device.create_bind_group(
-                        "packed_skin",
-                        &pipeline.layout,
-                        &BindGroupEntries::sequential((
-                            shape.buffer.as_entire_binding(),
-                            bones.as_entire_binding(),
-                            BindingResource::Buffer(BufferBinding {
-                                buffer: params,
-                                offset: 0,
-                                size: NonZeroU64::new(PARAMS_BYTES),
-                            }),
-                            output.as_entire_binding(),
-                        )),
-                    );
-                    shape.binding = Some((key, binding));
-                }
-                let (_, binding) = shape.binding.as_ref().expect("binding installed");
+                        BindingResource::Buffer(BufferBinding {
+                            buffer: output,
+                            offset: batch.output_offset,
+                            size: NonZeroU64::new(batch.output_bytes),
+                        }),
+                    )),
+                );
                 for range in job.ranges.iter().filter(|range| range.count != 0) {
-                    pass.set_bind_group(0, &**binding, &[(slot * stride) as u32]);
+                    pass.set_bind_group(0, &*binding, &[(slot * stride) as u32]);
                     pass.dispatch_workgroups(range.count.div_ceil(64), 1, 1);
                     slot += 1;
                     skinned.vertices += range.count as usize;
                 }
                 skinned.jobs += 1;
             }
+            drop(pass);
+            self.frame_buffers.extend([bones.clone(), params.clone()]);
         }
-        // Pending buffers precede the render graph's colour and shadow consumers.
+        // Command buffers own the referenced pages through GPU execution.
         pending.push([encoder.finish()]);
-        skinned
+        Ok(skinned)
     }
+}
 
-    fn report(&mut self, jobs: &[PackedSkinJob]) {
-        for &(index, reason) in &self.refused {
-            let shape = &jobs[index].shape;
-            if self.reported.contains_key(&shape.id()) {
-                continue;
-            }
-            self.reported.insert(shape.id(), Arc::downgrade(shape));
-            diag::error!(
-                World,
-                "packed skinning hid job {index} (shape {}, {} vertices at {}): {reason}",
-                shape.id(),
-                shape.vertices().len(),
-                jobs[index].destination,
-            );
-        }
+pub(super) fn retire_submitted_buffers(
+    mut skin: bevy::prelude::ResMut<SkinGpu>,
+    queue: bevy::prelude::Res<RenderQueue>,
+) {
+    let retired = std::mem::take(&mut skin.retired);
+    if retired.is_empty() {
+        return;
     }
+    let bytes = retired.iter().map(|buffer| buffer.size()).sum::<u64>();
+    let pending = Arc::clone(&skin.retired_bytes);
+    pending.fetch_add(bytes, std::sync::atomic::Ordering::AcqRel);
+    queue.on_submitted_work_done(move || {
+        drop(retired);
+        pending.fetch_sub(bytes, std::sync::atomic::Ordering::AcqRel);
+    });
 }
 
 fn make_pipeline(device: &RenderDevice) -> Pipeline {
diff --git a/crates/render_gpu/src/drawsurf/gpu_resources.rs b/crates/render_gpu/src/drawsurf/gpu_resources.rs
index d276895..0f6ca31 100644
--- a/crates/render_gpu/src/drawsurf/gpu_resources.rs
+++ b/crates/render_gpu/src/drawsurf/gpu_resources.rs
@@ -6,7 +6,7 @@ use bevy::render::render_resource::{
     AddressMode, Buffer, FilterMode, MipmapFilterMode, SamplerDescriptor, TextureView,
     TextureViewDimension, TextureViewId,
 };
-use bevy::render::renderer::RenderQueue;
+use bevy::render::renderer::{RenderDevice, RenderQueue};
 use bevy::render::texture::GpuImage;
 use d3d9_state::{
     AddressMode as D3dAddressMode, DecodedSamplerState, SamplerDecodeError, TextureFilter,
@@ -130,9 +130,11 @@ pub struct UploadedTextureView {
     pub dimension: TextureViewDimension,
 }
 
-#[derive(Resource, Clone, Debug, Default)]
+#[derive(Resource, Clone, Default)]
 pub struct RuntimeUploadedImageRegistry {
     source_handles: Option<RuntimeImageHandles>,
+    device: Option<RenderDevice>,
+    pub device_generation: u64,
     slot_index: UploadedSlotIndex,
     pending: UploadedPending,
     pub generation_id: MaterialGenerationId,
@@ -269,17 +271,44 @@ struct UploadedRefreshSlots {
 }
 
 pub(crate) fn prepare_uploaded_image_registry(
+    device: Res<RenderDevice>,
     handles: Option<Res<ExtractedRuntimeImageHandles>>,
     gpu_images: Res<RenderAssets<GpuImage>>,
     extracted: Option<Res<ExtractedAssets<GpuImage>>>,
     mut registry: ResMut<RuntimeUploadedImageRegistry>,
 ) {
+    if registry
+        .device
+        .as_ref()
+        .is_none_or(|previous| previous.wgpu_device() != device.wgpu_device())
+    {
+        let generation = registry
+            .device_generation
+            .checked_add(1)
+            .expect("image device generation exhausted");
+        let views = registry
+            .views_revision
+            .checked_add(1)
+            .expect("image view revision exhausted");
+        let replaced = registry
+            .replaced_revision
+            .checked_add(1)
+            .expect("image allocation revision exhausted");
+        *registry = RuntimeUploadedImageRegistry::default();
+        registry.device = Some(device.clone());
+        registry.device_generation = generation;
+        registry.views_revision = views;
+        registry.replaced_revision = replaced;
+    }
     let Some(handles) = handles else {
         if registry.source_handles.is_none() {
             return;
         }
         let (views, replaced) = (registry.views_revision, registry.replaced_revision);
+        let generation = registry.device_generation;
         *registry = RuntimeUploadedImageRegistry::default();
+        registry.device = Some(device.clone());
+        registry.device_generation = generation;
         registry.views_revision = views.wrapping_add(1);
         registry.replaced_revision = replaced.wrapping_add(1);
         return;
diff --git a/crates/render_gpu/src/lib.rs b/crates/render_gpu/src/lib.rs
index dde88e4..45efa66 100644
--- a/crates/render_gpu/src/lib.rs
+++ b/crates/render_gpu/src/lib.rs
@@ -1,3 +1,4 @@
+pub use render_scene::SkinSupport;
 pub mod diag;
 pub mod drawsurf;
 mod plugin;
diff --git a/crates/render_gpu/src/plugin.rs b/crates/render_gpu/src/plugin.rs
index bff3f0b..b112cae 100644
--- a/crates/render_gpu/src/plugin.rs
+++ b/crates/render_gpu/src/plugin.rs
@@ -4,6 +4,8 @@ pub struct RenderGpuPlugin;
 
 impl Plugin for RenderGpuPlugin {
     fn build(&self, app: &mut App) {
+        let skin = crate::SkinSupport::default();
+        app.insert_resource(skin.clone());
         app.add_plugins(bevy::render::extract_component::ExtractComponentPlugin::<
             frame::DisplayEncodedCamera,
         >::default());
@@ -28,6 +30,7 @@ impl Plugin for RenderGpuPlugin {
             return;
         };
         render_app
+            .insert_resource(skin)
             .init_resource::<crate::GpuSubmitReady>()
             .init_resource::<crate::ColourWorkingSet>()
             .init_resource::<crate::WorldPipelineWarmup>()
diff --git a/crates/render_material/src/catalog.rs b/crates/render_material/src/catalog.rs
index 333262f..fe6ed32 100644
--- a/crates/render_material/src/catalog.rs
+++ b/crates/render_material/src/catalog.rs
@@ -400,6 +400,8 @@ pub struct RuntimeMaterial {
     pub sort_key: u8,
 
     pub info_game_flags: u8,
+    /// `textureAtlasRowCount`, `textureAtlasColumnCount`; zero means one.
+    pub texture_atlas: [u8; 2],
 
     pub state_flags: u8,
 
diff --git a/crates/render_scene/src/lib.rs b/crates/render_scene/src/lib.rs
index 72061f2..58bbc84 100644
--- a/crates/render_scene/src/lib.rs
+++ b/crates/render_scene/src/lib.rs
@@ -1,3 +1,5 @@
+mod skin_support;
+pub use skin_support::SkinSupport;
 pub mod camera;
 pub mod dpvs_cells;
 pub mod dyn_atpoint;
diff --git a/crates/render_scene/src/skin_support.rs b/crates/render_scene/src/skin_support.rs
new file mode 100644
index 0000000..75ceac2
--- /dev/null
+++ b/crates/render_scene/src/skin_support.rs
@@ -0,0 +1,82 @@
+use bevy::prelude::Resource;
+use render_frame::skinning::{SkinBatchLimits, SkinRefusal};
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone, Copy, Debug, Default)]
+struct SupportState {
+    world: frame::WorldStamp,
+    device_generation: u64,
+    limits: Option<SkinBatchLimits>,
+    failure: Option<SkinRefusal>,
+}
+
+#[derive(Resource, Clone)]
+pub struct SkinSupport {
+    state: Arc<Mutex<SupportState>>,
+    pub resident_budget: u64,
+}
+
+impl Default for SkinSupport {
+    fn default() -> Self {
+        let resident_budget = std::env::var("IW4L_SKIN_RESIDENT_BYTES")
+            .map_or(Ok(1024 * 1024 * 1024), |text| text.parse::<u64>())
+            .ok()
+            .filter(|bytes| (1024 * 1024..=4 * 1024 * 1024 * 1024).contains(bytes))
+            .unwrap_or(0);
+        Self {
+            state: Arc::new(Mutex::new(SupportState::default())),
+            resident_budget,
+        }
+    }
+}
+
+impl SkinSupport {
+    pub fn set_world(&self, world: frame::WorldStamp) {
+        let mut state = self.state.lock().expect("skin support poisoned");
+        if state.world != world {
+            state.world = world;
+            state.failure = None;
+        }
+    }
+
+    pub fn report(
+        &self,
+        world: frame::WorldStamp,
+        limits: SkinBatchLimits,
+        device_generation: u64,
+        failure: Option<SkinRefusal>,
+    ) {
+        let mut state = self.state.lock().expect("skin support poisoned");
+        state.limits = Some(limits);
+        state.device_generation = device_generation;
+        if state.world == world && state.failure.is_none() {
+            state.failure = failure;
+        }
+    }
+
+    pub fn failure(&self, world: frame::WorldStamp) -> Option<SkinRefusal> {
+        let state = self.state.lock().expect("skin support poisoned");
+        if self.resident_budget == 0 {
+            return Some(SkinRefusal::UnsupportedProduct);
+        }
+        (state.world == world).then_some(state.failure).flatten()
+    }
+
+    pub fn refuse(&self, world: frame::WorldStamp, failure: SkinRefusal) {
+        let mut state = self.state.lock().expect("skin support poisoned");
+        if state.world == world {
+            state.failure = Some(failure);
+        }
+    }
+
+    pub fn device_generation(&self) -> u64 {
+        self.state
+            .lock()
+            .expect("skin support poisoned")
+            .device_generation
+    }
+
+    pub fn limits(&self) -> Option<SkinBatchLimits> {
+        self.state.lock().expect("skin support poisoned").limits
+    }
+}
diff --git a/crates/session/src/match_apply.rs b/crates/session/src/match_apply.rs
index 16cd2c5..90c904b 100644
--- a/crates/session/src/match_apply.rs
+++ b/crates/session/src/match_apply.rs
@@ -38,6 +38,10 @@ fn log_world_report(report: &[String]) {
 pub struct PreparedMatchSource<'w, 's> {
     ready: ResMut<'w, PreparedMatchReady>,
     audio_status: Option<Res<'w, audio::LoadingAudioStatus>>,
+    audio_owner: Option<Res<'w, audio::LoadingAudioOwner>>,
+    audio_candidate: Option<Res<'w, audio::PreparedMatchAudio>>,
+    audio_silent: Option<Res<'w, audio::AudioSilent>>,
+    current: Res<'w, assets::CurrentMatchLoad>,
     swap: Res<'w, crate::SessionSwapRequest>,
     bridge: Option<Res<'w, net::MasterBridge>>,
     intent: Option<Res<'w, net::MasterLaunchIntent>>,
@@ -80,6 +84,17 @@ pub struct MatchInstallPresentation<'w> {
     player_data: Res<'w, sim::LocalPlayerData>,
 }
 
+fn discard_ready(commands: &mut Commands, key: frame::LocalLoadKey) {
+    commands.queue(move |world: &mut World| {
+        if world
+            .get_resource::<PreparedMatchReady>()
+            .is_some_and(|ready| ready.load_key == key)
+        {
+            world.remove_resource::<PreparedMatchReady>();
+        }
+    });
+}
+
 pub fn apply_prepared_match(
     mut commands: Commands,
     source: PreparedMatchSource,
@@ -93,6 +108,10 @@ pub fn apply_prepared_match(
     let PreparedMatchSource {
         mut ready,
         audio_status,
+        audio_owner,
+        audio_candidate,
+        audio_silent,
+        current,
         swap,
         bridge,
         intent,
@@ -126,7 +145,8 @@ pub fn apply_prepared_match(
                 || state.identity().match_key() != ready.load_key.match_key
                 || ready.load_key.incarnation != bridge.incarnation()
         });
-    if !swap.accepts_install(ready.request_id)
+    if current.0 != Some(ready.load_key)
+        || !swap.accepts_install(ready.request_id)
         || stale_key
         || ready.load_key.local_load_request_id != ready.request_id
     {
@@ -139,7 +159,7 @@ pub fn apply_prepared_match(
         if let Some(stage) = install_stage.take() {
             stage.cancel();
         }
-        commands.remove_resource::<PreparedMatchReady>();
+        discard_ready(&mut commands, ready.load_key);
         return;
     }
     if ready.load_key.match_key.is_none() && intent.as_ref().is_some_and(|intent| intent.is_join())
@@ -152,16 +172,40 @@ pub fn apply_prepared_match(
         if let Some(stage) = install_stage.take() {
             stage.cancel();
         }
-        commands.remove_resource::<PreparedMatchReady>();
-        commands.remove_resource::<MatchLoadAbort>();
+        discard_ready(&mut commands, ready.load_key);
+        let request_id = ready.request_id;
+        commands.queue(move |world: &mut World| {
+            if world
+                .get_resource::<MatchLoadAbort>()
+                .is_some_and(|abort| abort.0 == request_id)
+            {
+                world.remove_resource::<MatchLoadAbort>();
+            }
+        });
         diag::info!(
             World,
             "match install: aborted request #{dropped} (`{zone}`) — not occupying the menu"
         );
         return;
     }
+    if role.runs_client()
+        && audio_owner
+            .as_ref()
+            .is_none_or(|owner| owner.0 != Some(ready.load_key))
+    {
+        return;
+    }
     match audio_status.as_deref() {
-        Some(audio::LoadingAudioStatus::Ready) => {}
+        Some(audio::LoadingAudioStatus::Ready) => {
+            if role.runs_client()
+                && audio_silent.is_none()
+                && audio_candidate
+                    .as_ref()
+                    .is_none_or(|candidate| candidate.load_key != ready.load_key)
+            {
+                return;
+            }
+        }
         Some(audio::LoadingAudioStatus::Failed(error)) => {
             failed.write(frame::MapLoadFailed {
                 request_id: ready.request_id,
@@ -169,7 +213,7 @@ pub fn apply_prepared_match(
                 zone: ready.zone.clone(),
                 error: error.clone(),
             });
-            commands.remove_resource::<PreparedMatchReady>();
+            discard_ready(&mut commands, ready.load_key);
             return;
         }
         _ => return,
@@ -199,7 +243,7 @@ pub fn apply_prepared_match(
     let Some(mut prepared) = ready.prepared.take() else {
         return;
     };
-    commands.remove_resource::<PreparedMatchReady>();
+    discard_ready(&mut commands, ready.load_key);
 
     let world_report = std::mem::take(&mut prepared.report);
     log_world_report(&world_report);
@@ -217,6 +261,7 @@ pub fn apply_prepared_match(
         rules.as_deref(),
         catalog.as_deref(),
         identity.as_deref(),
+        *role,
     ) {
         Ok(plan) => plan,
         Err(refusal) => {
@@ -248,6 +293,7 @@ pub fn apply_prepared_match(
         install.push(audio::stage_prepared_match_audio);
         let MatchInstallPlan {
             ui_images,
+            capabilities,
             scripts,
             script_level,
             script_entries,
@@ -392,6 +438,8 @@ pub fn apply_prepared_match(
             .set_map(Arc::clone(&prepared_map.content))
             .map_err(|error| InstallRefusal::new(format!("Invalid map content: {error}")))?;
         content.set_script_sound_aliases(script_sound_aliases);
+        content.set_script_fx(capabilities.script_fx.clone());
+        stage_resource(&mut install, capabilities);
         let mut sim = sim::SimWorld::new();
         if role.runs_authority()
             && let Some(previous) = previous.as_ref()
@@ -733,7 +781,9 @@ pub fn apply_prepared_match(
                                 && bridge.incarnation() == load_key.incarnation
                         });
                 if accepts && same_match {
-                    world.resource_mut::<crate::ScopeControl>().install(install);
+                    world
+                        .resource_mut::<crate::ScopeControl>()
+                        .install(load_key, install);
                 }
             });
             if let Some(stage) = install_stage {
@@ -765,6 +815,7 @@ pub fn apply_prepared_match(
 /// commit half of `apply_prepared_match` has nothing to install until preflight
 /// hands one over.
 struct MatchInstallPlan {
+    capabilities: assets::prepared::PreparedCapabilities,
     ui_images: asset_material::UiImagePublication,
     scripts: sim::script::Program,
     script_level: sim::script::LevelData,
@@ -890,7 +941,19 @@ fn preflight_match_install(
     rules: Option<&frame::HostMatchRules>,
     catalog: Option<&asset_game::MenuCatalog>,
     identity: Option<&LaunchIdentity>,
+    role: frame::RuntimeRole,
 ) -> Result<MatchInstallPlan, InstallRefusal> {
+    if prepared
+        .clip
+        .as_ref()
+        .is_none_or(|clip| clip.coverage != asset_world::CollisionCoverage::Complete)
+    {
+        return Err(InstallRefusal::new(
+            "Required collision geometry has incomplete query coverage",
+        ));
+    }
+    let capabilities = assets::prepared::PreparedCapabilities::prepare(&prepared);
+    capabilities.validate(role).map_err(InstallRefusal::new)?;
     let killstreaks = assets::prepared::PreparedKillstreaks(
         prepared
             .scripts
@@ -1208,7 +1271,10 @@ fn preflight_match_install(
             .collect(),
     );
     let fx_models = PreparedFxModels(std::mem::take(&mut prepared.world.fx_models));
-    let impact_fx = PreparedImpactFx(std::mem::take(&mut prepared.world.impact_fx));
+    let impact_fx = PreparedImpactFx {
+        map: std::mem::take(&mut prepared.world.impact_fx),
+        families: std::mem::take(&mut prepared.world.family_impact_fx),
+    };
     let tracers = PreparedTracers(std::mem::take(&mut prepared.tracers));
     let scene = match world_scene_from_draw(
         prepared.world,
@@ -1232,6 +1298,7 @@ fn preflight_match_install(
         ));
     }
     Ok(MatchInstallPlan {
+        capabilities,
         ui_images: prepared.ui_images,
         script_sound_aliases: prepared.script_sound_aliases,
         scripts,
@@ -1739,6 +1806,7 @@ fn install_clip_and_player(
             .collect(),
     };
     content.set_clip_map(brushes, bsp, mesh, cmodels);
+    content.set_collision_complete(clip.coverage == asset_world::CollisionCoverage::Complete);
     sim.install_content(content.finish());
     sim.install_model_library(authority_models.models);
     let owner_count = authority_models.capabilities.len();
diff --git a/crates/session/src/scope_control.rs b/crates/session/src/scope_control.rs
index 0bad4f8..8d8eac1 100644
--- a/crates/session/src/scope_control.rs
+++ b/crates/session/src/scope_control.rs
@@ -6,7 +6,7 @@ use frame::{MatchScope, RoundPhase, ScopeSet, TeardownReason};
 #[derive(Resource, Default)]
 pub struct ScopeControl {
     pending: Option<(u8, MatchScope)>,
-    install: Option<CommandQueue>,
+    install: Option<(frame::LocalLoadKey, CommandQueue)>,
     pub(crate) teardown: Option<TeardownReason>,
     round: Option<RoundPhase>,
     last_reason: Option<TeardownReason>,
@@ -30,9 +30,9 @@ impl ScopeControl {
         self.request(1, MatchScope::Loading);
     }
 
-    pub(crate) fn install(&mut self, install: CommandQueue) {
+    pub(crate) fn install(&mut self, key: frame::LocalLoadKey, install: CommandQueue) {
         assert!(self.install.is_none(), "two prepared installs in one frame");
-        self.install = Some(install);
+        self.install = Some((key, install));
         self.request(2, MatchScope::Live);
     }
 
@@ -65,6 +65,27 @@ impl ScopeControl {
     }
 }
 
+pub(crate) fn accepts_install(world: &World, key: frame::LocalLoadKey) -> bool {
+    world
+        .get_resource::<assets::CurrentMatchLoad>()
+        .is_some_and(|current| current.0 == Some(key))
+        && world
+            .resource::<crate::SessionSwapRequest>()
+            .accepts_install(key.local_load_request_id)
+        && world
+            .get_resource::<assets::MatchLoadAbort>()
+            .is_none_or(|abort| abort.0 != key.local_load_request_id)
+        && (key.match_key.is_none()
+            || world
+                .get_resource::<net::MasterBridge>()
+                .is_some_and(|bridge| {
+                    let state = bridge.state();
+                    state.in_match()
+                        && state.identity().match_key() == key.match_key
+                        && bridge.incarnation() == key.incarnation
+                }))
+}
+
 fn resolve_scope(world: &mut World) {
     let (pending, round) = {
         let mut control = world.resource_mut::<ScopeControl>();
@@ -75,6 +96,7 @@ fn resolve_scope(world: &mut World) {
             if let Some(install) = world.resource_mut::<ScopeControl>().install.take() {
                 world.resource_mut::<frame::Retiring>().hand_over(install);
             }
+            world.resource_mut::<InstallAnnouncement>().1 = None;
             frame::scope::discard_staging(world);
             let announcement = std::mem::take(&mut world.resource_mut::<InstallAnnouncement>().0);
             world
@@ -82,8 +104,30 @@ fn resolve_scope(world: &mut World) {
                 .hand_over(announcement);
         }
         if target == MatchScope::Live {
-            if let Some(mut install) = world.resource_mut::<ScopeControl>().install.take() {
+            if let Some((key, mut install)) = world.resource_mut::<ScopeControl>().install.take() {
+                if !accepts_install(world, key) {
+                    world.resource_mut::<frame::Retiring>().hand_over(install);
+                    return;
+                }
+                if world.resource::<frame::RuntimeRole>().runs_client()
+                    && !world.contains_resource::<audio::AudioSilent>()
+                    && audio::prepared_match_audio_key(world) != Some(key)
+                {
+                    world
+                        .resource_mut::<Messages<frame::MapLoadFailed>>()
+                        .write(frame::MapLoadFailed {
+                            request_id: key.local_load_request_id,
+                            load_key: key,
+                            zone: String::new(),
+                            error: "Prepared audio does not belong to the current load".into(),
+                        });
+                    world.resource_mut::<frame::Retiring>().hand_over(install);
+                    return;
+                }
+                world.resource_mut::<InstallAnnouncement>().1 = Some(key);
                 install.apply(world);
+            } else {
+                return;
             }
         }
         world.resource_mut::<NextState<MatchScope>>().set(target);
@@ -96,10 +140,20 @@ fn resolve_scope(world: &mut World) {
 }
 
 #[derive(Resource, Default)]
-pub(crate) struct InstallAnnouncement(pub CommandQueue);
+pub(crate) struct InstallAnnouncement(pub CommandQueue, pub Option<frame::LocalLoadKey>);
 
 fn announce_install(world: &mut World) {
-    let mut queue = std::mem::take(&mut world.resource_mut::<InstallAnnouncement>().0);
+    let (mut queue, key) = {
+        let mut announcement = world.resource_mut::<InstallAnnouncement>();
+        (std::mem::take(&mut announcement.0), announcement.1.take())
+    };
+    if key.is_none_or(|key| !accepts_install(world, key)) {
+        world.resource_mut::<frame::Retiring>().hand_over(queue);
+        world
+            .resource_mut::<NextState<MatchScope>>()
+            .set(MatchScope::Loading);
+        return;
+    }
     queue.apply(world);
 }
 
@@ -107,7 +161,8 @@ pub(crate) fn register(app: &mut App) {
     if !app.is_plugin_added::<frame::ScopePlugin>() {
         app.add_plugins(frame::ScopePlugin);
     }
-    app.staged::<frame::WorldGeneration>(MatchScope::Live)
+    app.staged::<assets::prepared::PreparedCapabilities>(MatchScope::Live)
+        .staged::<frame::WorldGeneration>(MatchScope::Live)
         .staged::<frame::WorldProducts>(MatchScope::Live)
         .staged::<crate::LiveWorldIdentity>(MatchScope::Live)
         .staged::<render_frontend::prepare::scene::world::WorldScene>(MatchScope::Live)
diff --git a/crates/sim/src/combat.rs b/crates/sim/src/combat.rs
index 091c235..f65f415 100644
--- a/crates/sim/src/combat.rs
+++ b/crates/sim/src/combat.rs
@@ -1149,7 +1149,16 @@ pub fn spread_direction_on_plane(
     }
 }
 
-pub(crate) fn phase_emit(world: &FrameWorld, shots: &[AcceptedShot]) -> Vec<Emission> {
+fn flame_burns_this_tick(facts: &weapon_iw4::WeaponCombatFacts, now_ms: i32) -> bool {
+    let interval = facts
+        .flame_damage_interval_ms
+        .max(facts.fire_time_ms)
+        .max(1);
+    let window = facts.fire_time_ms.max(1);
+    now_ms.div_euclid(interval) != (now_ms - window).div_euclid(interval)
+}
+
+pub(crate) fn phase_emit(world: &FrameWorld, tick: Tick, shots: &[AcceptedShot]) -> Vec<Emission> {
     let mut out = Vec::new();
     for shot in shots {
         let Some(facts) = world.combat_facts_for(shot.weapon) else {
@@ -1162,6 +1171,14 @@ pub(crate) fn phase_emit(world: &FrameWorld, shots: &[AcceptedShot]) -> Vec<Emis
                     continue;
                 }
             }
+            Some(FireWeaponKind::Flame) => {
+                if facts.damage <= 0
+                    || facts.bullet_range() <= 0.0
+                    || !flame_burns_this_tick(&facts, crate::level_time_ms(tick))
+                {
+                    continue;
+                }
+            }
             _ => continue,
         }
         let mut rng = MatchRng::new(shot.combat_seed as u64);
diff --git a/crates/sim/src/corpse.rs b/crates/sim/src/corpse.rs
index 292e930..7729ae5 100644
--- a/crates/sim/src/corpse.rs
+++ b/crates/sim/src/corpse.rs
@@ -15,6 +15,10 @@ pub const G_CLONE_PLAYER_MAX_VELOCITY: f32 = 80.0;
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct PlayerCorpseSlot {
     pub occupied: bool,
+    pub spawn_sequence: u64,
+    pub weapon_model: u8,
+    pub client_state_team: i32,
+    pub ffa_team: Option<u8>,
 
     pub entnum: i32,
     pub victim: ClientId,
@@ -46,6 +50,10 @@ impl Default for PlayerCorpseSlot {
     fn default() -> Self {
         Self {
             occupied: false,
+            spawn_sequence: 0,
+            weapon_model: 0,
+            client_state_team: 0,
+            ffa_team: None,
             entnum: -1,
             victim: ClientId(0),
             origin: [0.0; 3],
@@ -84,6 +92,7 @@ pub struct PlayerCorpsePool {
     pub slots: [PlayerCorpseSlot; MAX_CLIENT_CORPSES as usize],
 
     pub spawn_ring: u8,
+    pub next_spawn_sequence: u64,
 }
 
 impl Default for PlayerCorpsePool {
@@ -91,6 +100,7 @@ impl Default for PlayerCorpsePool {
         Self {
             slots: [PlayerCorpseSlot::default(); MAX_CLIENT_CORPSES as usize],
             spawn_ring: 0,
+            next_spawn_sequence: 0,
         }
     }
 }
@@ -144,6 +154,11 @@ impl PlayerCorpsePool {
 
     pub fn occupy(&mut self, slot: u8, entnum: i32, mut body: PlayerCorpseSlot) -> u8 {
         let i = (slot as usize) % MAX_CLIENT_CORPSES as usize;
+        self.next_spawn_sequence = self
+            .next_spawn_sequence
+            .checked_add(1)
+            .expect("corpse spawn sequence exhausted");
+        body.spawn_sequence = self.next_spawn_sequence;
         body.occupied = true;
         body.entnum = entnum;
         self.slots[i] = body;
@@ -167,6 +182,10 @@ pub(crate) fn occupy_player_clone(
         .client_meta(victim)
         .and_then(|meta| meta.shield)
         .filter(|shield| shield.on_back);
+    let (client_state_team, ffa_team) = world
+        .client_meta(victim)
+        .map_or((0, None), |meta| (meta.client_state_team, meta.ffa_team));
+    let weapon_model = weapon_iw4::weapon_model_for_held(&ps.weapons, &ps.weapon_data, ps.weapon);
     let pool = world.corpses_mut();
     let entnum = pool.alloc_clone_entity();
     let slot = pool.get_free(ps.origin);
@@ -175,6 +194,9 @@ pub(crate) fn occupy_player_clone(
         entnum,
         PlayerCorpseSlot {
             victim,
+            weapon_model,
+            client_state_team,
+            ffa_team,
             origin: ps.origin,
 
             viewangles: [0.0, client_think_entity_yaw(ps), 0.0],
diff --git a/crates/sim/src/equipment.rs b/crates/sim/src/equipment.rs
index 14431a0..f851b80 100644
--- a/crates/sim/src/equipment.rs
+++ b/crates/sim/src/equipment.rs
@@ -194,7 +194,7 @@ fn grenade_deadlines(
     }
     let cleanup_at_ms = cap_at;
     match kind {
-        GrenadeLaunchKind::Launcher if facts.fuse_time_ms <= 0 => {
+        GrenadeLaunchKind::Launcher if facts.fuse_time_ms <= 0 || !facts.timed_detonation => {
             if facts.projectile_activate_dist != 0 {
                 (None, cleanup_at_ms)
             } else {
@@ -218,14 +218,10 @@ fn grenade_deadlines(
             };
             (Some(now_ms.saturating_add(fuse)), cleanup_at_ms)
         }
-        GrenadeLaunchKind::Launcher => {
-            let fuse = if facts.fuse_time_ms <= 0 {
-                GRENADE_DEFAULT_FUSE_MS
-            } else {
-                facts.fuse_time_ms.min(GRENADE_FUSE_CAP_MS)
-            };
-            (Some(now_ms.saturating_add(fuse)), cleanup_at_ms)
-        }
+        GrenadeLaunchKind::Launcher => (
+            Some(now_ms.saturating_add(facts.fuse_time_ms.min(GRENADE_FUSE_CAP_MS))),
+            cleanup_at_ms,
+        ),
     }
 }
 
diff --git a/crates/sim/src/missile.rs b/crates/sim/src/missile.rs
index 5048ff2..819dd44 100644
--- a/crates/sim/src/missile.rs
+++ b/crates/sim/src/missile.rs
@@ -13,7 +13,7 @@ pub(crate) fn fire_accepted_shot(world: &mut FrameWorld, tick: crate::Tick, shot
         return;
     };
     match fire_weapon_kind(combat.weap_type, combat.weap_class) {
-        Some(FireWeaponKind::Bullet) => {}
+        Some(FireWeaponKind::Bullet | FireWeaponKind::Flame) => {}
         Some(FireWeaponKind::GrenadeLauncher) => {
             spawn_grenade_projectile(
                 world,
@@ -109,7 +109,7 @@ pub(crate) fn magic_bullet(
             })
             .flatten()
         }
-        Some(FireWeaponKind::Bullet) | None => {
+        Some(FireWeaponKind::Bullet | FireWeaponKind::Flame) | None => {
             return Err("MagicBullet bullets are not simulated".into());
         }
     };
diff --git a/crates/sim/src/script/host/natives/iw4.rs b/crates/sim/src/script/host/natives/iw4.rs
index 25d944c..7612979 100644
--- a/crates/sim/src/script/host/natives/iw4.rs
+++ b/crates/sim/src/script/host/natives/iw4.rs
@@ -101,6 +101,9 @@ pub(crate) fn register(registry: &mut NativeRegistry) {
         if name.get(..3).is_some_and(|p| p.eq_ignore_ascii_case("fx/")) {
             return Err("effect name should start after the 'fx' folder.".into());
         }
+        if !crate::frame::FrameWorld::from_world(world).script_fx_available(&name) {
+            return Err(format!("effect capability unavailable: {name}"));
+        }
         precache(world, "fx", name).map(Value::Int)
     });
     registry.register(Function, "makedvarserverinfo", |world, _, args| {
diff --git a/crates/sim/src/script/host/weapons.rs b/crates/sim/src/script/host/weapons.rs
index 426befe..c1ff689 100644
--- a/crates/sim/src/script/host/weapons.rs
+++ b/crates/sim/src/script/host/weapons.rs
@@ -58,13 +58,31 @@ fn adopt(
     let model =
         Value::string(FrameWorld::from_world(world).weapon_projectile_model(projectile.weapon));
     let facts = FrameWorld::from_world(world).equipment_facts_for(projectile.weapon);
+    if let Some(object) = world
+        .resource::<RoundScript>()
+        .missiles
+        .get(&projectile.id)
+        .copied()
+    {
+        return Ok(object);
+    }
+    let object = world
+        .resource_mut::<RoundScript>()
+        .create_entity(EntityKind::Missile(projectile.id), classname)?;
     let presence = if facts.is_some_and(|facts| !facts.timed_detonation && facts.stickiness != 0) {
-        Some(super::presence::spawn_presence(world, projectile.origin)?)
+        match super::presence::spawn_presence(world, projectile.origin) {
+            Ok(presence) => Some(presence),
+            Err(error) => {
+                let mut runtime = world.resource_mut::<RoundScript>();
+                runtime.entities.remove(&object);
+                runtime.objects.remove(&object);
+                return Err(error);
+            }
+        }
     } else {
         None
     };
     let mut runtime = world.resource_mut::<RoundScript>();
-    let object = runtime.create_entity(EntityKind::Missile(projectile.id), classname)?;
     let owner = runtime
         .players
         .get(&projectile.owner.0)
diff --git a/crates/sim/src/step.rs b/crates/sim/src/step.rs
index 8ca418d..0df0593 100644
--- a/crates/sim/src/step.rs
+++ b/crates/sim/src/step.rs
@@ -572,7 +572,7 @@ fn run_players_system(ecs: &mut World) {
                 if world.publishes_snapshot() {
                     world.record_entity_collision_history(tick);
                 }
-                let emissions = phase_emit(&world, core::slice::from_ref(&shot));
+                let emissions = phase_emit(&world, tick, core::slice::from_ref(&shot));
                 phase_trace(&mut world, tick, &emissions);
             }
             crate::equipment::phase_offhand(&mut world, tick, &[(*id, cmd)]);
diff --git a/crates/sim/src/world.rs b/crates/sim/src/world.rs
index 9de7c6e..816c08a 100644
--- a/crates/sim/src/world.rs
+++ b/crates/sim/src/world.rs
@@ -38,7 +38,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use weapon_iw4::WeaponCombatFacts;
 
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Tick(pub u32);
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -424,6 +424,16 @@ impl SimState {
         self.hud_elem_sound_ids = ids;
     }
 
+    pub fn collision_complete(&self) -> bool {
+        self.content.collision_complete()
+    }
+
+    pub fn script_fx_available(&self, name: &str) -> bool {
+        self.content
+            .script_fx()
+            .contains(&name.to_ascii_lowercase())
+    }
+
     pub fn script_sound_exists(&self, name: &str) -> Option<bool> {
         self.content
             .script_sound_aliases()
diff --git a/crates/sim/src/world/content.rs b/crates/sim/src/world/content.rs
index c27feef..00d6f46 100644
--- a/crates/sim/src/world/content.rs
+++ b/crates/sim/src/world/content.rs
@@ -101,6 +101,9 @@ impl SimContent {
         &self.data.map
     }
 
+    pub fn collision_complete(&self) -> bool {
+        self.data.collision_complete
+    }
     pub fn clip_brushes(&self) -> &[SimBrush] {
         &self.data.clip_brushes
     }
@@ -120,6 +123,8 @@ struct ContentData {
     map: Arc<asset_core::MapContentDefinition>,
     weapons: Arc<crate::SimWeaponContent>,
     script_sound_aliases: Option<std::collections::BTreeMap<String, Option<bool>>>,
+    script_fx: std::collections::BTreeSet<String>,
+    collision_complete: bool,
     clip_brushes: Vec<SimBrush>,
     clip_bsp: SimClipBsp,
     clip_mesh: SimClipMesh,
@@ -166,6 +171,8 @@ impl SimContentBuilder {
                 map: Default::default(),
                 weapons,
                 script_sound_aliases: Default::default(),
+                script_fx: Default::default(),
+                collision_complete: false,
                 clip_brushes: Default::default(),
                 clip_bsp: Default::default(),
                 clip_mesh: Default::default(),
@@ -194,6 +201,10 @@ impl SimContentBuilder {
         Arc::ptr_eq(&self.data.weapons, weapons)
     }
 
+    pub fn set_script_fx(&mut self, names: std::collections::BTreeSet<String>) {
+        self.data.script_fx = names;
+    }
+
     pub fn set_script_sound_aliases(
         &mut self,
         aliases: Option<std::collections::BTreeMap<String, Option<bool>>>,
@@ -303,6 +314,10 @@ impl SimContentBuilder {
         self.data.clip_cmodels = SimClipCmodels::default();
     }
 
+    pub fn set_collision_complete(&mut self, complete: bool) {
+        self.data.collision_complete = complete;
+    }
+
     pub fn set_clip_map(
         &mut self,
         brushes: Vec<SimBrush>,
@@ -321,6 +336,10 @@ impl SimContent {
     pub(super) fn weapons(&self) -> &Arc<crate::SimWeaponContent> {
         &self.data.weapons
     }
+    pub(super) fn script_fx(&self) -> &std::collections::BTreeSet<String> {
+        &self.data.script_fx
+    }
+
     pub(super) fn script_sound_aliases(
         &self,
     ) -> &Option<std::collections::BTreeMap<String, Option<bool>>> {
diff --git a/crates/ui/src/classes/equip_txn.rs b/crates/ui/src/classes/equip_txn.rs
index 7ca2c2f..1ba0983 100644
--- a/crates/ui/src/classes/equip_txn.rs
+++ b/crates/ui/src/classes/equip_txn.rs
@@ -12,6 +12,20 @@ use crate::classes::store::SessionClassStore;
 #[derive(Resource, Debug, Default)]
 pub struct EquipTxnWatch {
     request_id: Option<u32>,
+    next_revision: u32,
+    correlation: Option<EquipCorrelation>,
+}
+
+#[derive(Clone, Debug)]
+struct EquipCorrelation {
+    class_id: ClassId,
+    revision: u32,
+    load_key: frame::LocalLoadKey,
+    class: frame::HostClassSlot,
+    catalog_revision: u64,
+    families: Option<frame::AssetFamilies>,
+    capability_version: Option<(u32, frame::WorldProducts)>,
+    policy: Vec<(String, String)>,
 }
 
 pub fn apply_pending_class_equip(
@@ -26,6 +40,11 @@ pub fn apply_pending_class_equip(
     mut status: ResMut<ClassSelectStatus>,
     local: Res<LocalPresentClient>,
     signon: Option<Res<net::SignonState>>,
+    context: (
+        Res<frame::InstalledMatch>,
+        Option<Res<frame::HostMatchRules>>,
+        Option<Res<assets::prepared::PreparedCapabilities>>,
+    ),
 ) {
     let Some(req) = pending.0.take() else {
         return;
@@ -87,12 +106,38 @@ pub fn apply_pending_class_equip(
         }
     };
 
+    let Some(revision) = watch.next_revision.checked_add(1) else {
+        reject_class_equip(
+            &mut phase,
+            &mut status,
+            req.request_id,
+            "Class revision capacity exhausted",
+        );
+        return;
+    };
+    watch.next_revision = revision;
+    let correlation = EquipCorrelation {
+        class_id: ClassId(index as u32),
+        revision,
+        load_key: context.0.load_key,
+        class: frame::HostClassSlot::from(slot),
+        catalog_revision: catalog.revision,
+        families: store.server_families(),
+        capability_version: context
+            .2
+            .as_ref()
+            .map(|facts| (facts.version, facts.products)),
+        policy: context
+            .1
+            .as_ref()
+            .map_or_else(Vec::new, |policy| policy.0.clone()),
+    };
     if let Err(error) = actions.push(
         local.0,
         ClientAction::SelectClass {
             request_id: req.request_id,
             class_id: ClassId(index as u32),
-            revision: 1,
+            revision,
             loadout,
         },
     ) {
@@ -110,9 +155,10 @@ pub fn apply_pending_class_equip(
         return;
     }
     watch.request_id = Some(req.request_id);
+    watch.correlation = Some(correlation);
     diag::info!(
         Ui,
-        "class select: queued SelectClass request_id={} id={} rev=1 (queued→gather→step→codec→present)",
+        "class select: queued SelectClass request_id={} id={} rev={revision} (queued→gather→step→codec→present)",
         req.request_id,
         index
     );
@@ -177,19 +223,62 @@ pub fn resolve_class_equip_transaction(
     mut status: ResMut<ClassSelectStatus>,
     mut watch: ResMut<EquipTxnWatch>,
     mut reliable: MessageReader<net::ReliableControlEvent>,
+    context: (
+        Res<SessionClassStore>,
+        Res<crate::ClassLoadoutCatalog>,
+        Res<frame::InstalledMatch>,
+        Option<Res<frame::HostMatchRules>>,
+        Option<Res<assets::prepared::PreparedCapabilities>>,
+    ),
 ) {
-    let Some(request_id) = watch.request_id.or_else(|| phase.pending_request_id()) else {
+    let Some(request_id) = watch.request_id else {
         reliable.clear();
         return;
     };
 
+    let (store, catalog, installed, policy, capabilities) = context;
+    let current_policy = policy
+        .as_ref()
+        .map_or_else(Vec::new, |policy| policy.0.clone());
+    let Some(correlation) = watch.correlation.clone() else {
+        reliable.clear();
+        return;
+    };
+    let unchanged = correlation.load_key == installed.load_key
+        && correlation.catalog_revision == catalog.revision
+        && correlation.policy == current_policy
+        && correlation.families == store.server_families()
+        && correlation.capability_version
+            == capabilities
+                .as_ref()
+                .map(|facts| (facts.version, facts.products))
+        && store
+            .slots
+            .get(correlation.class_id.0 as usize)
+            .is_some_and(|slot| frame::HostClassSlot::from(slot) == correlation.class);
+    if !unchanged {
+        reject_class_equip(
+            &mut phase,
+            &mut status,
+            request_id,
+            "Class or session policy changed while awaiting admission",
+        );
+        watch.request_id = None;
+        watch.correlation = None;
+        reliable.clear();
+        return;
+    }
     for event in reliable.read() {
         match event.0 {
             SimEvent::ClassRejected {
                 request_id: rid,
                 reason,
-                ..
-            } if rid == request_id => {
+                class_id,
+                revision,
+            } if rid == request_id
+                && class_id == correlation.class_id
+                && revision == correlation.revision =>
+            {
                 let reason = reason.as_str();
                 if reject_class_equip(&mut phase, &mut status, request_id, reason) {
                     diag::info!(
@@ -198,11 +287,17 @@ pub fn resolve_class_equip_transaction(
                     );
                 }
                 watch.request_id = None;
+                watch.correlation = None;
                 return;
             }
             SimEvent::ClassAccepted {
-                request_id: rid, ..
-            } if rid == request_id => {
+                request_id: rid,
+                class_id,
+                revision,
+            } if rid == request_id
+                && class_id == correlation.class_id
+                && revision == correlation.revision =>
+            {
                 if accept_class_equip(&mut equipped, &mut phase, &mut overlay, request_id) {
                     diag::info!(
                         Ui,
@@ -210,6 +305,7 @@ pub fn resolve_class_equip_transaction(
                     );
                 }
                 watch.request_id = None;
+                watch.correlation = None;
                 return;
             }
             _ => {}
diff --git a/crates/ui/src/menu.rs b/crates/ui/src/menu.rs
index f597785..e92e510 100644
--- a/crates/ui/src/menu.rs
+++ b/crates/ui/src/menu.rs
@@ -254,7 +254,6 @@ pub fn install_frontend_menus(catalog: &mut asset_game::MenuCatalog) -> Result<(
             }
         }
     }
-    catalog.inherit_shared_vis();
     Ok(())
 }
 
diff --git a/crates/weapon_iw4/src/fire_weapon.rs b/crates/weapon_iw4/src/fire_weapon.rs
index 3d1d899..502fa5f 100644
--- a/crates/weapon_iw4/src/fire_weapon.rs
+++ b/crates/weapon_iw4/src/fire_weapon.rs
@@ -2,6 +2,7 @@ pub const WEAPTYPE_BULLET: i32 = 0;
 pub const WEAPTYPE_GRENADE: i32 = 1;
 pub const WEAPTYPE_PROJECTILE: i32 = 2;
 pub const WEAPTYPE_SHIELD: i32 = 3;
+pub const WEAPTYPE_GAS: i32 = 4;
 
 pub const WEAPCLASS_GRENADE: i32 = 6;
 pub const WEAPCLASS_SPREAD: i32 = 4;
@@ -73,6 +74,7 @@ pub enum FireWeaponKind {
     ThrownGrenade,
     GrenadeLauncher,
     Missile,
+    Flame,
 }
 
 pub const fn fire_weapon_kind(weap_type: i32, weap_class: i32) -> Option<FireWeaponKind> {
@@ -86,6 +88,7 @@ pub const fn fire_weapon_kind(weap_type: i32, weap_class: i32) -> Option<FireWea
                 Some(FireWeaponKind::Missile)
             }
         }
+        WEAPTYPE_GAS => Some(FireWeaponKind::Flame),
         _ => None,
     }
 }
diff --git a/crates/weapon_iw4/src/lib.rs b/crates/weapon_iw4/src/lib.rs
index a05cbf0..d2ed7d6 100644
--- a/crates/weapon_iw4/src/lib.rs
+++ b/crates/weapon_iw4/src/lib.rs
@@ -56,8 +56,8 @@ pub use fire_sound::{select_cg_fire_sound_ptr, select_fire_last_sound_ptr, selec
 pub use fire_weapon::{
     BULLET_MAX_RANGE, FireWeaponKind, HITLOC_COUNT, HITLOC_NAMES, LOCATION_DAMAGE_IDENTITY,
     ROCKET_SPREAD_PLANE, WEAPCLASS_GRENADE, WEAPCLASS_PISTOL, WEAPCLASS_SPREAD, WEAPCLASS_TURRET,
-    WEAPTYPE_BULLET, WEAPTYPE_GRENADE, WEAPTYPE_PROJECTILE, WEAPTYPE_SHIELD, bake_location_damage,
-    fire_weapon_kind, location_damage_is_valid, location_damage_scale,
+    WEAPTYPE_BULLET, WEAPTYPE_GAS, WEAPTYPE_GRENADE, WEAPTYPE_PROJECTILE, WEAPTYPE_SHIELD,
+    bake_location_damage, fire_weapon_kind, location_damage_is_valid, location_damage_scale,
 };
 pub use kick::{
     CAMERA_LIMIT_DEGREES, CAMERA_PEAK_SECONDS, FireRecoilImpulse, FireRecoilPsScales, GunKickRange,
diff --git a/crates/weapon_iw4/src/tick.rs b/crates/weapon_iw4/src/tick.rs
index 1bceab8..b2a3fcf 100644
--- a/crates/weapon_iw4/src/tick.rs
+++ b/crates/weapon_iw4/src/tick.rs
@@ -93,6 +93,7 @@ pub struct CapturedCombatInput {
     pub stunned_start_time_ms: i32,
     pub stunned_end_time_ms: i32,
     pub damage: i32,
+    pub flame_damage_interval_ms: i32,
     pub min_damage: i32,
     pub max_damage_range: f32,
     pub min_damage_range: f32,
@@ -246,6 +247,7 @@ pub struct WeaponCombatFacts {
     pub stunned_start_time_ms: i32,
     pub stunned_end_time_ms: i32,
     pub damage: i32,
+    pub flame_damage_interval_ms: i32,
     pub min_damage: i32,
     pub max_damage_range: f32,
     pub min_damage_range: f32,
@@ -365,6 +367,7 @@ impl WeaponCombatFacts {
             stunned_start_time_ms: 0,
             stunned_end_time_ms: 0,
             damage: 0,
+            flame_damage_interval_ms: 0,
             min_damage: 0,
             max_damage_range: 0.0,
             min_damage_range: 0.0,
@@ -483,6 +486,7 @@ impl WeaponCombatFacts {
             stunned_start_time_ms: input.stunned_start_time_ms,
             stunned_end_time_ms: input.stunned_end_time_ms,
             damage: input.damage,
+            flame_damage_interval_ms: input.flame_damage_interval_ms,
             min_damage: input.min_damage,
             max_damage_range: input.max_damage_range,
             min_damage_range: input.min_damage_range,
@@ -578,7 +582,7 @@ impl WeaponCombatFacts {
     }
 
     pub fn bullet_range(self) -> f32 {
-        if self.weap_class == crate::WEAPCLASS_SPREAD {
+        if self.weap_class == crate::WEAPCLASS_SPREAD || self.weap_type == crate::WEAPTYPE_GAS {
             self.min_damage_range
         } else {
             crate::BULLET_MAX_RANGE
diff --git a/docs/INDEX.md b/docs/INDEX.md
index 3ad3a89..38d9f20 100644
--- a/docs/INDEX.md
+++ b/docs/INDEX.md
@@ -10,6 +10,7 @@ game. Keep them this short: nobody opens a long file twice.
 | [`WINDOWS.md`](WINDOWS.md) | portable `iw4l.exe`: community updates, shortcuts into CoD, writable `iw4l-artifacts/` | building and running on Windows |
 | [`DEPLOY.md`](DEPLOY.md) | `make release` / `publish` / `deploy`: every root `.iw4l-server` is a server, hashed `.zst`, master by SHA, GitHub pre-release | shipping a release, "why is the player on an old version" |
 | [Approved scenarios](../crates/approved_tests/README.md) | gameplay lifecycle and two clients through the dev master | repeatable end-to-end checks |
+| [`TRANSPORT.md`](TRANSPORT.md) | client/relay monotonic operation and queue budgets | configuring deadlines or diagnosing stalled transport |
 | [`MASTER.md`](MASTER.md) | your own master over ssh from the machine with the clone: `cargo xtask master install`, a self-signed certificate with no domain, what to hand players | standing up a relay for yourself or your friends |
 | [`PERF.md`](PERF.md) | native `.pftrace` — the only runtime truth; picking a UUID, the manifest, `IW4L_PERF`, SQL | traces, scenario SQL, why a frame took 80 ms |
 | [`FFI.md`](FFI.md) | native data ownership, lifetimes, nullability and Perfetto adapters | changing a native boundary or diagnosing trace failures |
diff --git a/docs/PRESENTATION.md b/docs/PRESENTATION.md
index 53c0e11..36ffb40 100644
--- a/docs/PRESENTATION.md
+++ b/docs/PRESENTATION.md
@@ -1,23 +1,19 @@
 # Presentation publications
-
 `render_fx::PresentedFireFx` owns receipts for one world and replay timeline.
 A receipt identifies a fire cause and product, with pellet/segment identity for
 tracer, impact, glass and marks. Positions, normals, surface and target are
 result data. Authority replaces that data; conflicting authority is refused.
-
 | product | prediction | authority |
 |---|---|---|
 | muzzle/brass | create when available | retain success or retry refusal |
 | tracer/transient impact | create when available | retain success or retry using authoritative result |
 | marks | defer | schedule mark emission once |
 | glass | defer | evaluate authoritative segment once, including zero hits |
-
 `execute` admits scope/verdict/budget before invoking creation. It records
 success after creation returns. Dependency and allocation refusals remain
 retryable; intentional tracer interval skips are terminal. Marks report
 Scheduled, separately from Created: a scheduled effect can later encounter a
 receiver/material refusal in the mark subsystem.
-
 Impact effects carry Transient or Marks emission policy through runners,
 emitted children, impacts, deaths and trails. Transient effects cannot emit
 decals; Marks effects simulate child motion without drawing particles,
@@ -28,14 +24,12 @@ products. Saturation refuses admission rather than evicting recent successes.
 World/timeline replacement or clock rewind resets the scope; i32 wrap remains
 legal. Late delivery after expiry may create a fresh product. `fx_dump` reports
 scope/time, product budget refusals, receipt size/capacity and sweep costs.
-
 `asset_material::UiImagePublication` owns material mappings, preview policy,
 zone payloads and archive indices. Shell/match installation selects privately
 prepared products. A late shell completion cannot replace an installed match.
 HUD caches and class/loading previews adopt publication identity. Shell previews
 use this publication; gameplay archive image plans begin with the first match
 and remain shared. Menu overlays replace maps and caches when menus change.
-
 Installation revisions cover relevant file metadata, following game symlinks.
 Unix revisions also include inode/change time. A new load checks the revision;
 there is no automatic file watcher. Archive indices retain opened readers, so
@@ -48,3 +42,9 @@ checks prepared FPV assemblies and map-selected hands. Appearance selection
 keeps NativeReady, BaseByPolicy and DeclaredUnavailable separately for view and
 world models. Render consumers retain refusal reasons and do not replace a
 declared unavailable model with the base weapon.
+
+Accepted pellet impacts publish independently of FX, keyed by installation, timeline and shot/pellet/segment.
+Replay reuses retained snapshot metadata; a retention gap restores the cosmetic checkpoint before applying retained occurrences.
+Corpse identity includes an authority spawn sequence, and corpse equipment/team appearance is captured at death.
+Cosmetic physics keeps its canonical hull and mask during recovery; incomplete collision refuses activation.
+FX pieces freeze analytic spin only after supported low motion; angular torque is not simulated.
diff --git a/docs/RENDER.md b/docs/RENDER.md
index 4fac9f8..b052516 100644
--- a/docs/RENDER.md
+++ b/docs/RENDER.md
@@ -1,8 +1,6 @@
 # Render: what lives where
-
 `render_frontend` reads the presented snapshot; `render_gpu` writes pixels and
 owns `wgpu`. Rendering decides no gameplay and never writes `AuthorityWorld`.
-
 | crate | role |
 |---|---|
 | `render_frontend` | scene preparation, culling, occupancy adapters, frame products and tessellation |
@@ -12,22 +10,18 @@ owns `wgpu`. Rendering decides no gameplay and never writes `AuthorityWorld`.
 | `render_material`, `render_backend` | material tables and draw-list views |
 | `render_gpu` | GPU preparation and recording |
 | `render` | composition, extraction and diagnostics |
-
 ```text
 zone → asset IR → prepare/scene/ → assemble/drawsurf/
      → sorted draw list → tessellation → material execution
      → SM3/WGSL → GPU contract → wgpu
 ```
-
 One drawsurf machine accepts world, static-model and viewmodel emitters.
 Lighting uses `lighting_iw4`, `smodel_lighting.rs` and `model_lighting_atlas.rs`;
 shadows use `sun_shadow.rs`. `StaticSunAndFx` overlaps static sun preparation
 with FX, joins before frame products consume results, then merges dynamic
 casters. Sun model draws reuse colour geometry's index buffers.
-
 Retained lanes in `retained_list/` key static reuse on world, material,
 visibility and eye/LOD. FX also keys on distortion; glass re-sorts for each eye.
-
 GPU skinning computes FPV and remote body packed vertices before native colour/shadows.
 Shapes use stable IDs and retire with live jobs; invalid jobs refuse geometry.
 
@@ -48,3 +42,9 @@ variables (`IW4L_SINGLE_CELL`, `IW4L_SUN_SHADOW_*`); observation uses
 
 Film vision presets come from map/common fastfiles. Console `visionSetNaked`
 and `visionReset` transition `FilmVisionView` between presets.
+
+Packed skinning uses bounded output pages and per-batch palettes under actual device limits.
+`IW4L_SKIN_RESIDENT_BYTES` defaults to 1073741824 (range 1048576–4294967296); invalid settings refuse support.
+Readiness preflights the worst admitted player/corpse loadouts and FPV assembly, including replacement/retirement costs.
+Cold shapes can leave GPU residency while their immutable CPU products remain valid; retired bytes stay counted until queue completion.
+Capacity refusal is explicit and stops required presentation; there is no CPU skinning fallback.
diff --git a/docs/TRANSPORT.md b/docs/TRANSPORT.md
new file mode 100644
index 0000000..7d6fbe8
--- /dev/null
+++ b/docs/TRANSPORT.md
@@ -0,0 +1,31 @@
+# Transport budgets
+
+Both client and relay validate these environment settings before connecting or accepting work.
+Durations are monotonic milliseconds, limited to 1–600000.
+
+| Setting | Default | Owner/outcome |
+| --- | ---: | --- |
+| `IW4L_NET_RESPONSE_MS` | 20000 | Correlated request; timeout has unknown remote outcome |
+| `IW4L_NET_PROGRESS_MS` | 5000 | Useful dedicated-stream progress/acknowledgement |
+| `IW4L_NET_TRANSFER_MS` | 90000 | Total dedicated transfer occupation |
+| `IW4L_NET_QUEUE_AGE_MS` | 20000 | Queued command/control/bootstrap/reliable data |
+| `IW4L_NET_CONNECT_MS` | 60000 | Connection attempt including retries |
+| `IW4L_NET_SHUTDOWN_MS` | 500 | Shutdown drain |
+| `IW4L_NET_LOADING_MS` | 120000 | Authority loading milestone |
+| `IW4L_NET_SILENCE_MS` | 60000 | Authority progress silence |
+| `IW4L_NET_ADMISSION_MS` | 60000 | Peer admission milestone |
+| `IW4L_NET_QUEUE_ITEMS` | 32 | Control/pending requests; range 1–1024 |
+| `IW4L_NET_QUEUE_BYTES` | 8388608 | Purpose queue byte budget; range 262144–67108864 |
+
+Progress must not exceed the total transfer budget. Invalid settings refuse transport startup.
+Keepalive and unrelated traffic never renew a request deadline.
+Shared reliable framing belongs to the connection reader; dedicated streams stop/reset on failure.
+Replaceable gameplay slots retain their oldest unsent age across replacement.
+Reliable queues refuse overload and fail the connection visibly on expiry.
+Bootstrap streams also retain the protocol payload and concurrency limits.
+Both endpoints use Quinn’s default congestion controller (CUBIC).
+The application never disables its congestion window after a stall.
+
+Accepted control requests reserve bounded storage for a correlated terminal receipt until the bridge consumes it.
+Connection closure resolves every remaining waiter with an explicit unknown remote outcome.
+Local commands can expire before connection establishment; those commands have not been sent.