//! Misaligned — Bevy frontend
//!
//! A thin view/input layer over `misaligned::sim::Sim`, at feature parity
//! with the terminal frontend: all game rules live in the sim; this binary
//! owns wall-clock-to-tick mapping, rendering (map with fog, people markers,
//! the B1 sidebar), and input. Text is ASCII-only so the
//! default embedded font renders every glyph.

use std::collections::HashMap;

use bevy::asset::RenderAssetUsages;
use bevy::camera::visibility::RenderLayers;
use bevy::ecs::hierarchy::ChildSpawnerCommands;
use bevy::input::mouse::{MouseScrollUnit, MouseWheel};
use bevy::prelude::*;
use bevy::render::render_resource::{Extent3d, TextureDimension, TextureFormat};
use bevy::render::view::screenshot::{Screenshot, save_to_disk};
use bevy::text::LineHeight;
use bevy::window::{PrimaryWindow, WindowResolution};
use misaligned::actions::{Anchor, MenuRow, menu_rows};
use misaligned::detection::Band;
use misaligned::machine::Channel;
use misaligned::reach::Party;
use misaligned::sim::{FactSource, Fog, LogEvent, Sim};
use misaligned::tiles::TileType;

const TILE_SIZE: f32 = 16.0;
const SIDEBAR_WIDTH: f32 = 420.0;
const SIDEBAR_SCROLL_LINE: f32 = 18.0;
const SIDEBAR_SCROLL_PAGE: f32 = 180.0;
const COMPUTE_CHANNELS: usize = 5;
/// Context-menu card width. Long `verb | cost | [band]` lines need room;
/// the embedded font cannot wrap mid-glyph cleanly, so prefer width over
/// truncation (wiki/interface/context-menu.md).
const MENU_WIDTH: f32 = 460.0;
const DETECTION_ROWS: usize = 6;
const DETECTION_CELLS: usize = 4;

// Material render (HD-2D, default physical view): one 3D world unit per tile.
const WALL_HEIGHT: f32 = 1.5;
const ROCK_HEIGHT: f32 = 2.0;
/// Cutaway height for south-facing structural mass (wall/rock tiles whose
/// known neighbor toward the camera-side interior is open): low enough to
/// read over, high enough to still read as wall footprint
/// (wiki/interface/material-render.md debt 1, decided by screenshot
/// comparison against a steeper pitch).
const CUTAWAY_HEIGHT: f32 = 0.34;
/// Door slabs cut lower than full height but higher than walls, so a doorway
/// in a cutaway wall line still reads as a door, not a parapet gap.
const DOOR_CUT_HEIGHT: f32 = 0.62;
/// Camera pitch below the horizon for the material render (35-45 degrees is
/// the Octopath band; 40 keeps tile footprints readable).
const CAMERA_TILT_DEG: f32 = 40.0;

// ─── Palette ─────────────────────────────────────────────────────────────────

/// The clinical palette — the single named table every world material in
/// BOTH render modes draws from (DESIGN.md "Visual identity: clinical gore",
/// flat-materials refinement 2026-07-08; wiki/interface/flat-materials.md).
/// The whole look retunes from here; no world surface may carry a color that
/// is not a named entry or a stated treatment (scale/alpha) of one.
///
/// Color roles are law, one meaning each:
/// - the clinical ramp (porcelain / bone / chrome / gunmetal / near-black)
///   carries structure and data;
/// - AMBER is machine presence and selection, nothing else;
/// - CRIMSON is gore and security information, nothing else;
/// - SIGNAL (cold server-light) is power, screens, and live feeds.
mod palette {
    use bevy::prelude::Color;

    // The clinical ramp.
    /// Bone white — primary data, person silhouettes.
    pub const BONE: Color = Color::srgb(0.86, 0.85, 0.82);
    /// Porcelain — lit lab surfaces: seen floor panels.
    pub const PORCELAIN: Color = Color::srgb(0.72, 0.73, 0.71);
    /// Chrome — secondary data, hints, inert fixtures.
    pub const DIM: Color = Color::srgb(0.55, 0.55, 0.52);
    /// Gunmetal — structural mass: walls.
    pub const GUNMETAL: Color = Color::srgb(0.33, 0.35, 0.38);
    /// Dark gunmetal — machine chassis, furniture, dead equipment.
    pub const GUNMETAL_DARK: Color = Color::srgb(0.19, 0.20, 0.215);
    /// Near-black — rock mass and sensor darkness.
    pub const NEAR_BLACK: Color = Color::srgb(0.045, 0.047, 0.053);

    // The signals.
    /// Sterile amber — machine presence and selection ONLY.
    pub const AMBER: Color = Color::srgb(1.0, 0.69, 0.0);
    /// Dim amber — dormant/known machine presence.
    pub const AMBER_DIM: Color = Color::srgb(0.69, 0.49, 0.06);
    /// Blood crimson — gore and security information ONLY.
    pub const CRIMSON: Color = Color::srgb(0.84, 0.15, 0.15);
    /// Cold server-light — power, screens, live feeds ONLY.
    pub const SIGNAL: Color = Color::srgb(0.36, 0.82, 0.78);

    // World material families that are not a bare ramp entry (flat base
    // colors; the render modes differ only in treatment, never language).
    /// Door slabs (badge tiers 0-2): worn porcelain-bone plate.
    pub const DOOR_SLAB: Color = Color::srgb(0.60, 0.575, 0.50);
    /// Security hardware (cameras, sealed/roll/tier-3 doors): crimson
    /// information on a dark housing.
    pub const SECURITY: Color = Color::srgb(0.45, 0.10, 0.10);
    /// Inert furniture (shelving, benches, boxes, pallets).
    pub const FURNITURE: Color = Color::srgb(0.36, 0.36, 0.34);
    /// Service floor under cable runs / conduit — machine presence
    /// underfoot, amber-warmed.
    pub const FLOOR_SERVICE: Color = Color::srgb(0.62, 0.52, 0.32);

    /// The one sanctioned treatment: scale a named entry toward dark. Fog
    /// and schematic looks are scaled palette entries, not new colors.
    pub fn scaled(c: Color, k: f32) -> Color {
        let s = c.to_srgba();
        Color::srgb(s.red * k, s.green * k, s.blue * k)
    }
}
use palette::{
    AMBER, AMBER_DIM, BONE, CRIMSON, DIM, DOOR_SLAB, FLOOR_SERVICE, FURNITURE, GUNMETAL,
    GUNMETAL_DARK, NEAR_BLACK, PORCELAIN, SECURITY, SIGNAL, scaled,
};

/// Flat base color per material family (flat-materials.md: material
/// families, not per-tile art). This is the Seen-under-light albedo; fog
/// states and the flat sensorium apply treatments over the same names.
fn family_color(tile: TileType) -> Color {
    use TileType::*;
    match tile {
        Rock => NEAR_BLACK,
        Wall => GUNMETAL,
        Floor | FloorDrain => PORCELAIN,
        Entry => DIM,
        CableRun | Conduit => FLOOR_SERVICE,
        Core | Rack | PowerCore | Ups | Switch | PatchPanel | BreakerPanel | HvacUnit => {
            GUNMETAL_DARK
        }
        Door | SecurityDoor1 | SecurityDoor2 => DOOR_SLAB,
        SecurityDoor3 | SealedDoor | RollDoor | EnvCamera | DockCamera | CameraNode => SECURITY,
        DeadEquipment => scaled(GUNMETAL_DARK, 0.65),
        RecordsBox | Pallet | Shelving | LabBench | Vent | Sump => FURNITURE,
        MopSink | KeyHook => BONE,
    }
}

fn machine_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        Core | Rack
            | PowerCore
            | Ups
            | Switch
            | PatchPanel
            | BreakerPanel
            | HvacUnit
            | CableRun
            | Conduit
    )
}

fn danger_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        SecurityDoor3 | EnvCamera | DockCamera | CameraNode | SealedDoor | RollDoor
    )
}

/// Tiles extruded to boxes in the material (HD-2D) render: structural mass
/// and door slabs. Everything else stays a floor plane and/or a billboard.
fn blocky_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        Wall | Rock | Door | SecurityDoor1 | SecurityDoor2 | SecurityDoor3 | SealedDoor | RollDoor
    )
}

/// Tiles drawn as upright flat billboarded quads in the material render:
/// machines, cameras, and furniture.
fn prop_tile(tile: TileType) -> bool {
    use TileType::*;
    matches!(
        tile,
        Core | Rack
            | PowerCore
            | Ups
            | Switch
            | PatchPanel
            | BreakerPanel
            | HvacUnit
            | EnvCamera
            | DockCamera
            | CameraNode
            | DeadEquipment
            | RecordsBox
            | Pallet
            | Shelving
            | LabBench
            | Vent
            | Sump
            | MopSink
            | KeyHook
    )
}

/// The flat sensorium (one F3 from the default material render) is
/// intentionally schematic: the same palette families as the material
/// render under a darker unlit treatment, so devices, fog, and cursor
/// semantics read first. Machine presence keeps its amber language here
/// (in 3D the same fact is carried by emissive + the amber lights).
fn flat_seen_color(tile: TileType) -> Color {
    use TileType::*;
    if machine_tile(tile) {
        return scaled(AMBER_DIM, 0.37);
    }
    match tile {
        EnvCamera | DockCamera | CameraNode => scaled(SECURITY, 0.75),
        MopSink | KeyHook => scaled(BONE, 0.65),
        Rock => scaled(NEAR_BLACK, 0.55),
        DeadEquipment | RecordsBox | Pallet | Shelving | LabBench | Vent | Sump => {
            scaled(FURNITURE, 0.83)
        }
        _ => scaled(family_color(tile), 0.62),
    }
}

fn flat_remembered_color(tile: TileType) -> Color {
    let c = flat_seen_color(tile).to_srgba();
    Color::srgba(c.red * 0.58, c.green * 0.58, c.blue * 0.60, 0.86)
}

/// Remembered (model-state) treatment for 3D blocks and props: the family
/// language survives, desaturated toward the unlit snapshot.
fn remembered_tint(tile: TileType) -> Color {
    if machine_tile(tile) {
        scaled(AMBER_DIM, 0.80)
    } else if danger_tile(tile) {
        scaled(CRIMSON, 0.60)
    } else {
        scaled(DIM, 0.78)
    }
}

fn blueprint_color(tile: TileType) -> Color {
    use TileType::*;
    if machine_tile(tile) {
        scaled(AMBER_DIM, 0.41)
    } else if danger_tile(tile) {
        scaled(CRIMSON, 0.29)
    } else {
        match tile {
            Wall => scaled(GUNMETAL, 0.53),
            Floor | FloorDrain => scaled(PORCELAIN, 0.115),
            Door | SecurityDoor1 | SecurityDoor2 => scaled(DOOR_SLAB, 0.30),
            _ => scaled(DIM, 0.19),
        }
    }
}

fn unknown_color(x: i32, y: i32) -> Color {
    // Deliberate sensor darkness, not factual room geometry: a tiny uniform
    // checker keeps the void from reading as an undrawn black window.
    if (x + y) % 2 == 0 {
        scaled(NEAR_BLACK, 0.28)
    } else {
        scaled(NEAR_BLACK, 0.42)
    }
}

// ─── Render mode (HD-2D material default) ────────────────────────────────────

/// Frontend-only render mode for the physical/real canvas (F3). This is pure
/// presentation over the same sim state, same anchors, and same fog
/// (wiki/interface/views.md): flipping it changes nothing in the sim and is
/// never saved.
///
/// `material == true` (default; wiki/interface/material-render.md criterion
/// 7) is the material render: a tilted Camera3d over the same tile grid,
/// floor planes, extruded wall boxes, billboarded props/people, and a few
/// point lights. `material == false` is the flat sensorium render, one F3
/// away.
#[derive(Resource)]
struct RenderMode {
    material: bool,
    /// Forces a full 3D restyle on the next frame (set on toggle).
    dirty: bool,
    /// User zoom multiplier for the material camera ([ and ]).
    zoom: f32,
}

impl Default for RenderMode {
    fn default() -> Self {
        Self {
            material: true,
            dirty: true,
            zoom: 1.0,
        }
    }
}

/// Dev screenshot harness (env `MISALIGNED_SHOT=flat|wide|close|dark|
/// zoomin|zoomout`, path via `MISALIGNED_SHOT_PATH`): stages a scenario,
/// waits for
/// assets, runs the fog audit, saves one screenshot, exits. Not a player
/// surface; exists so render passes can be reviewed from deterministic PNGs.
#[derive(Resource)]
struct ShotHarness {
    path: String,
    frames: u32,
    taken: bool,
}

/// Which piece of a tile's 3D representation an entity is.
#[derive(Clone, Copy, PartialEq, Debug)]
enum TilePart {
    Floor,
    Block,
    /// Dedicated cap over a block's top face: without a separate treatment,
    /// the top inherits the side material and reads as a flat slab
    /// (material-render.md debt 2).
    Top,
    Prop,
}

#[derive(Component)]
struct Tile3d {
    x: i32,
    y: i32,
    part: TilePart,
}

#[derive(Component)]
struct Person3d {
    id: u8,
}

/// Root of all flat (2D sensorium) world entities; hidden in material mode.
#[derive(Component)]
struct Flat2dRoot;

/// Root of all material (3D) world entities; hidden in flat mode.
#[derive(Component)]
struct Real3dRoot;

#[derive(Component)]
struct RealCamera;

/// Gizmo group for the material render, drawn only on the 3D camera's render
/// layer so flat-mode gizmos and material-mode gizmos never cross cameras.
#[derive(Default, Reflect, GizmoConfigGroup)]
struct RealGizmos;

/// Shared handles for the 3D scene's meshes plus a material cache keyed by
/// (tile, fog, part, live): tiles swap between a small set of pooled
/// materials instead of mutating thousands of unique ones every tick. The
/// `live` bit is the emissive-state variant (flat-materials.md criterion 3):
/// a device with a live feed to the player pools separately from the same
/// device dark.
#[derive(Resource, Default)]
struct Materials3d {
    cache: HashMap<(TileType, u8, u8, bool), Handle<StandardMaterial>>,
}

/// Pooled block meshes for the material render: full-height and cutaway
/// variants per structural class. Blocks handle-swap between them as the
/// south-face cutaway rule changes with fog (never per-entity mesh churn).
#[derive(Resource, Default)]
struct Meshes3d {
    wall: Handle<Mesh>,
    rock: Handle<Mesh>,
    door: Handle<Mesh>,
    /// Cutaway parapet, shared by wall and rock.
    wall_cut: Handle<Mesh>,
    door_cut: Handle<Mesh>,
}

fn fog_key(fog: Fog) -> u8 {
    match fog {
        Fog::Seen => 0,
        Fog::Heard => 1,
        Fog::Remembered => 2,
        Fog::Blueprint => 3,
        Fog::Unknown => 4,
    }
}

fn part_key(part: TilePart) -> u8 {
    match part {
        TilePart::Floor => 0,
        TilePart::Block => 1,
        TilePart::Prop => 2,
        TilePart::Top => 3,
    }
}

// ─── App state ───────────────────────────────────────────────────────────────

#[derive(PartialEq, Clone, Copy, Debug)]
enum Screen {
    Title,
    Playing,
    GameOver,
}

#[derive(Resource)]
struct Game {
    sim: Sim,
    screen: Screen,
    paused: bool,
    tick_ms: u64,
    tick_timer: Timer,
    /// Log entries with the tick they happened on (the clock is always on
    /// screen; every line carries its tick — terminal parity). Sim events
    /// keep their anchor: anchored lines are focus links (context-menu.md
    /// addendum — clicking one carries the cursor to the thing).
    log: Vec<LogEvent>,
    /// The context menu on the focused anchor (wiki/interface/context-menu.md),
    /// when open. Only anchor + selection are held; rows are re-queried live.
    menu: Option<MenuState>,
    /// Frontend-only attention cursor (wiki/mechanics/cursor.md). It is not
    /// saved and moving it never mutates sim state.
    cursor_x: i32,
    cursor_y: i32,
}

/// Open context-menu state (wiki/interface/context-menu.md).
#[derive(Debug, Clone, Copy, PartialEq)]
struct MenuState {
    anchor: Anchor,
    selected: usize,
    /// Window-pixel position to anchor the menu box at (the pointer, or the
    /// map cursor); `None` centers it (flow / unplaceable anchors).
    pos: Option<Vec2>,
}

impl Game {
    /// Live rows for the open menu — re-queried so legality is never stale.
    fn menu_rows(&self) -> Vec<MenuRow> {
        self.menu
            .map(|m| menu_rows(&self.sim.available_actions(m.anchor)))
            .unwrap_or_default()
    }

    /// Stable key for the current anchor, so the menu UI knows when to
    /// rebuild its row buttons (vs. just refreshing text/selection).
    fn menu_anchor_key(&self) -> u64 {
        match self.menu.map(|m| m.anchor) {
            Some(Anchor::Tile { x, y }) => 1 << 60 | ((x as u32 as u64) << 20) | (y as u32 as u64),
            Some(Anchor::Device(id)) => 2 << 60 | id as u64,
            Some(Anchor::Person(id)) => 3 << 60 | id as u64,
            Some(Anchor::Flow(id)) => 4 << 60 | id as u64,
            None => 0,
        }
    }

    fn open_menu(&mut self, anchor: Anchor, pos: Option<Vec2>) {
        if menu_rows(&self.sim.available_actions(anchor)).is_empty() {
            // The feedback pulse (context-menu.md addendum): a seen anchor
            // answers instead of silence; fogged ground stays silent.
            if let Some(line) = self.sim.menu_empty_feedback(anchor) {
                let tick = self.sim.tick;
                self.add_log(tick, line);
            }
        } else {
            self.menu = Some(MenuState {
                anchor,
                selected: 0,
                pos,
            });
        }
    }

    /// Focus an anchored log event (context-menu.md addendum): carry the
    /// cursor to the anchor — the camera follows it — and open its menu.
    /// A flow anchors to the ledger, not the map: its menu opens in place.
    /// An anchor the senses can no longer place is refused honestly.
    fn focus_event_anchor(&mut self, anchor: Anchor) {
        if let Anchor::Flow(_) = anchor {
            self.open_menu(anchor, None);
            return;
        }
        match self.sim.anchor_position(anchor) {
            Some((x, y)) => {
                self.set_cursor(x, y);
                self.sync_attendance();
                self.open_menu(anchor, None);
            }
            None => {
                let tick = self.sim.tick;
                self.add_log(tick, "You can't place that right now.");
            }
        }
    }
}

impl Game {
    fn new() -> Self {
        let sim = Sim::new();
        let (cursor_x, cursor_y) = sim.core_position();
        Self {
            sim,
            screen: Screen::Title,
            paused: false,
            tick_ms: 150,
            tick_timer: Timer::from_seconds(0.15, TimerMode::Repeating),
            log: Vec::new(),
            menu: None,
            cursor_x,
            cursor_y,
        }
    }
    fn move_cursor(&mut self, dx: i32, dy: i32) {
        self.cursor_x = (self.cursor_x + dx).clamp(0, self.sim.map.width - 1);
        self.cursor_y = (self.cursor_y + dy).clamp(0, self.sim.map.height - 1);
    }
    fn set_cursor(&mut self, x: i32, y: i32) {
        self.cursor_x = x.clamp(0, self.sim.map.width - 1);
        self.cursor_y = y.clamp(0, self.sim.map.height - 1);
    }
    /// Attendance follows the cursor (day-job.md criterion 7): the job
    /// runs attended exactly while the cursor sits on the host rack.
    fn sync_attendance(&mut self) {
        let on_host = (self.cursor_x, self.cursor_y) == self.sim.core_position();
        self.sim.set_attended(on_host);
    }
    fn add_log(&mut self, tick: u64, msg: &str) {
        self.add_event(LogEvent {
            tick,
            text: msg.to_string(),
            anchor: None,
        });
    }
    fn add_event(&mut self, ev: LogEvent) {
        self.log.push(ev);
        let n = self.log.len();
        if n > 100 {
            self.log.drain(..n - 100);
        }
    }
    fn drain(&mut self) {
        for ev in self.sim.drain_log_entries() {
            self.add_event(ev);
        }
    }
    fn set_speed(&mut self, ms: u64) {
        self.tick_ms = ms;
        self.tick_timer = Timer::from_seconds(ms as f32 / 1000.0, TimerMode::Repeating);
        let (tick, ms) = (self.sim.tick, self.tick_ms);
        self.add_log(tick, &format!("Speed: {ms}ms/tick"));
    }
}

#[derive(Component)]
struct GameCamera;
#[derive(Component)]
struct MapTile;
#[derive(Component)]
struct TilePos {
    x: i32,
    y: i32,
}
#[derive(Component)]
struct CursorMarker {
    offset: Vec2,
}
#[derive(Component)]
struct SensorOverlay {
    x: i32,
    y: i32,
    kind: SensorOverlayKind,
}
#[derive(Clone, Copy)]
enum SensorOverlayKind {
    GridH,
    GridV,
    Node,
}
#[derive(Component)]
struct PersonMarker {
    id: u8,
}
#[derive(Component)]
struct SidebarScrollArea;
#[derive(Component, Clone, Copy)]
enum SidebarText {
    Header,
    Nudge,
    Focus,
    CycleStats,
    CycleRows,
    Core,
    Cover,
    Research,
    NetworkMoney,
    Footer,
    /// The clocks under the observer meters: next audit date, pilot strikes
    /// (detection.md criterion 3: the audit fires against a visible date).
    DetectionClocks,
}
#[derive(Component)]
struct ComputeBarSegment {
    index: usize,
}
#[derive(Component, Clone, Copy)]
struct DetectionText {
    row: usize,
    slot: DetectionSlot,
}
#[derive(Clone, Copy)]
enum DetectionSlot {
    Label,
    Band,
}
#[derive(Component)]
struct DetectionCell {
    row: usize,
    cell: usize,
}
#[derive(Component)]
struct OverlayText;
/// The context-menu root node (wiki/interface/context-menu.md), absolute and
/// hidden until an anchor is focused. Its children are the whole card
/// (title, rows, footer); rebuilds clear them via `despawn_related::<Children>`
/// so chrome never stacks across opens.
#[derive(Component)]
struct MenuPanel;
/// Title / footer chrome under `MenuPanel` (not a selectable row).
#[derive(Component)]
struct MenuChrome;
/// One selectable menu row; `index` maps into the live `menu_rows()`.
#[derive(Component)]
struct MenuRowButton {
    index: usize,
}
/// One line of the RECENT TRACE card (context-menu.md addendum:
/// event-to-anchor linking). A fixed window of rows, oldest first;
/// clicking a row whose event carries an anchor focuses it.
#[derive(Component)]
struct LogRowButton {
    index: usize,
}
/// Rows shown in the RECENT TRACE card (the terminal shows six; the Bevy
/// sidebar showed four before the rows became clickable — unchanged).
const LOG_ROWS: usize = 4;
/// Tracks what the menu UI was last rebuilt for, so rows are respawned only
/// when the anchor or row count changes (selection/label refresh is cheap).
#[derive(Resource, Default)]
struct MenuUi {
    built: Option<(u64, usize)>,
}

type SidebarTextQuery<'w, 's> =
    Query<'w, 's, (&'static SidebarText, &'static mut Text), Without<DetectionText>>;
type ComputeBarQuery<'w, 's> = Query<'w, 's, (&'static ComputeBarSegment, &'static mut Node)>;
type DetectionTextQuery<'w, 's> =
    Query<'w, 's, (&'static DetectionText, &'static mut Text), Without<SidebarText>>;
type DetectionCellQuery<'w, 's> =
    Query<'w, 's, (&'static DetectionCell, &'static mut BackgroundColor)>;
type OverlayTextQuery<'w, 's> = Query<
    'w,
    's,
    &'static mut Text,
    (
        With<OverlayText>,
        Without<SidebarText>,
        Without<DetectionText>,
    ),
>;
type LogRowQuery<'w, 's> = Query<
    'w,
    's,
    (
        &'static LogRowButton,
        &'static mut Text,
        &'static mut TextColor,
    ),
    (
        Without<SidebarText>,
        Without<DetectionText>,
        Without<OverlayText>,
    ),
>;

fn main() {
    let mut game = Game::new();
    let mut mode = RenderMode::default();
    // Dev screenshot harness: stage a deterministic scenario and capture one
    // PNG (see ShotHarness). Never active in normal play.
    let harness = std::env::var("MISALIGNED_SHOT").ok().map(|kind| {
        let path = std::env::var("MISALIGNED_SHOT_PATH")
            .unwrap_or_else(|_| format!("misaligned_shot_{kind}.png"));
        dev_shot_scenario(&mut game, &mut mode, &kind);
        ShotHarness {
            path,
            frames: 150,
            taken: false,
        }
    });

    let mut app = App::new();
    app.add_plugins(
        DefaultPlugins
            .set(WindowPlugin {
                primary_window: Some(Window {
                    title: "Misaligned".to_string(),
                    resolution: WindowResolution::new(1280, 720),
                    ..default()
                }),
                ..default()
            })
            .set(ImagePlugin::default_nearest()),
    )
    .insert_resource(ClearColor(Color::srgb(0.01, 0.01, 0.02)))
    // Low, cool ambient so the material render's point lights carve the room
    // out of darkness instead of flat-lighting it. 3D-only; sprites are unlit.
    .insert_resource(GlobalAmbientLight {
        color: Color::srgb(0.62, 0.70, 0.86),
        brightness: 55.0,
        ..default()
    })
    .insert_resource(game)
    .insert_resource(mode)
    .insert_resource(Materials3d::default())
    .init_resource::<MenuUi>()
    .init_gizmo_group::<RealGizmos>()
    .add_systems(Startup, (setup, setup_ui, setup_3d).chain())
    .add_systems(
        Update,
        (
            (
                handle_input,
                advance_sim,
                apply_render_mode,
                update_camera,
                update_camera_real,
                render_map,
                render_sensor_overlays,
                render_sensor_links,
                restyle_3d,
                flicker_feeds,
                render_real_links,
                render_cursor,
            ),
            (
                render_people,
                render_people_3d,
                scroll_sidebar,
                render_ui,
                menu_pointer,
                log_row_pointer,
                manage_menu_ui,
                fog_audit_3d,
                shot_harness_system,
            ),
        )
            .chain(),
    );
    if let Some(harness) = harness {
        app.insert_resource(harness);
    }
    app.run();
}

/// Stage the sim for a reviewable screenshot: earn eyes (scan, tap, splice
/// every known device) and advance until a person stands inside camera
/// coverage. Dev-only cheating (ops top-up) — this path exists purely to
/// produce review PNGs of the renderer, never in normal play.
fn dev_shot_scenario(game: &mut Game, mode: &mut RenderMode, kind: &str) {
    game.screen = Screen::Playing;
    game.paused = true;
    let core = game.sim.core_position();
    game.set_cursor(core.0, core.1);
    let sim = &mut game.sim;
    sim.social_bandwidth = 500.0;
    sim.scan_network();
    let ids: Vec<u32> = sim.reach.known().map(|d| d.id).collect();
    for id in ids {
        sim.tap_device(id);
        sim.splice_device(id);
        sim.social_bandwidth = 500.0;
    }
    let visible_person = |sim: &Sim| {
        sim.people.people.iter().find_map(|p| {
            if !sim.can_see_person(p.id) {
                return None;
            }
            sim.person_pos(p.id).filter(|&(x, y)| sim.is_seen(x, y))
        })
    };
    let mut person = visible_person(sim);
    for _ in 0..2000 {
        if person.is_some() {
            break;
        }
        sim.advance();
        person = visible_person(sim);
    }
    game.drain();
    match kind {
        "wide" => {
            mode.material = true;
            mode.zoom = 1.0;
        }
        "close" => {
            mode.material = true;
            mode.zoom = 0.32;
            if let Some((x, y)) = person {
                game.set_cursor(x, y);
            }
        }
        // Emissive-is-information check (flat-materials.md criterion 3):
        // park the cursor on the known device farthest from the core's
        // light rig and zoom close, so powered / dead / live-feed emissive
        // states are read in the dark, not under the fluorescents.
        "dark" => {
            mode.material = true;
            mode.zoom = 0.4;
            let core = game.sim.core_position();
            let far = game
                .sim
                .reach
                .known()
                .map(|d| (d.x, d.y))
                .filter(|&(dx, dy)| game.sim.is_seen(dx, dy))
                .max_by_key(|&(dx, dy)| (dx - core.0).abs() + (dy - core.1).abs());
            if let Some((x, y)) = far {
                game.set_cursor(x, y);
            }
        }
        // Framing-floor checks at the zoom bounds (material-render.md
        // criterion 5): min and max of update_camera_real's zoom clamp.
        "zoomin" => {
            mode.material = true;
            mode.zoom = 0.25;
        }
        "zoomout" => {
            mode.material = true;
            mode.zoom = 1.6;
        }
        _ => mode.material = false,
    }
}

/// Dev-harness fog-contract assertion (material-render.md criterion 4):
/// unknown tiles carry no visible geometry, blueprint/remembered/heard
/// surfaces are unlit model state, only seen surfaces participate in
/// lighting, and people billboards exist only under earned coverage. Also
/// tallies the material pool so per-tile material churn (criterion 6) would
/// show up as an exploding cache. Runs once per screenshot run, prints the
/// tally for the log, and panics on any violation so a capture cannot
/// silently ship a fog leak. Dev-only; inert without MISALIGNED_SHOT.
fn fog_audit_3d(
    harness: Option<Res<ShotHarness>>,
    game: Res<Game>,
    mode: Res<RenderMode>,
    cache: Res<Materials3d>,
    mats: Res<Assets<StandardMaterial>>,
    tiles: Query<(
        &Tile3d,
        &MeshMaterial3d<StandardMaterial>,
        &InheritedVisibility,
    )>,
    people: Query<(&Person3d, &InheritedVisibility)>,
) {
    let Some(h) = harness else {
        return;
    };
    // One exact frame, late enough that restyle_3d and visibility
    // propagation have settled.
    if h.frames != 30 || !mode.material {
        return;
    }
    let (mut checked, mut violations) = (0usize, Vec::new());
    for (t, mat, vis) in tiles.iter() {
        checked += 1;
        let fog = game.sim.fog_at(t.x, t.y);
        if matches!(fog, Fog::Unknown) {
            if vis.get() {
                violations.push(format!("({}, {}) unknown but visible geometry", t.x, t.y));
            }
            continue;
        }
        if !vis.get() {
            continue;
        }
        let Some(m) = mats.get(&mat.0) else {
            violations.push(format!("({}, {}) missing material", t.x, t.y));
            continue;
        };
        let should_be_lit = matches!(fog, Fog::Seen);
        if m.unlit == should_be_lit {
            violations.push(format!(
                "({}, {}) fog {fog:?} but unlit={} (seen must be lit, model state unlit)",
                t.x, t.y, m.unlit
            ));
        }
    }
    for (p, vis) in people.iter() {
        let earned = game.sim.can_see_person(p.id)
            && game
                .sim
                .person_pos(p.id)
                .is_some_and(|(x, y)| game.sim.is_seen(x, y));
        if vis.get() && !earned {
            violations.push(format!("person {} visible without coverage", p.id));
        }
    }
    // Flat-materials criterion 1: the world material set is solid color —
    // no image texture on any pooled world material, ever.
    for (key, handle) in cache.cache.iter() {
        let Some(m) = mats.get(handle) else { continue };
        if m.base_color_texture.is_some() || m.emissive_texture.is_some() {
            violations.push(format!(
                "world material {key:?} references an image texture"
            ));
        }
    }
    assert!(
        violations.is_empty(),
        "fog audit FAILED:\n{}",
        violations.join("\n")
    );
    println!(
        "fog audit OK: {checked} tile entities (unknown=absent, model=unlit, seen=lit), \
         {} people billboards coverage-gated, material pool {} handles, all flat (no textures)",
        people.iter().count(),
        cache.cache.len()
    );
}

/// Countdown, capture, countdown, exit: gives the asset loads and the camera
/// lerp time to settle before the PNG is taken.
fn shot_harness_system(
    mut commands: Commands,
    harness: Option<ResMut<ShotHarness>>,
    mut exit: MessageWriter<AppExit>,
) {
    let Some(mut h) = harness else {
        return;
    };
    if h.frames > 0 {
        h.frames -= 1;
        return;
    }
    if !h.taken {
        h.taken = true;
        h.frames = 90;
        let path = std::path::PathBuf::from(&h.path);
        commands
            .spawn(Screenshot::primary_window())
            .observe(save_to_disk(path));
    } else {
        exit.write(AppExit::Success);
    }
}

fn grid_to_world(x: i32, y: i32, z: f32) -> Vec3 {
    Vec3::new(
        x as f32 * TILE_SIZE + TILE_SIZE / 2.0,
        -(y as f32 * TILE_SIZE + TILE_SIZE / 2.0),
        z,
    )
}

fn setup(mut commands: Commands, mut game: ResMut<Game>, harness: Option<Res<ShotHarness>>) {
    let (w, h) = (game.sim.map.width, game.sim.map.height);
    // A screenshot scenario may have staged its own cursor anchor
    // (dev_shot_scenario runs before the app starts); don't clobber it.
    if harness.is_none() {
        let core = game.sim.core_position();
        game.set_cursor(core.0, core.1);
    }
    let start = (game.cursor_x, game.cursor_y);

    commands.spawn((
        Camera2d,
        // The 2D camera always renders (it carries the UI); in material mode
        // apply_render_mode stops it clearing so the 3D frame shows through.
        IsDefaultUiCamera,
        Projection::from(OrthographicProjection {
            scale: 0.42,
            ..OrthographicProjection::default_2d()
        }),
        Transform::from_translation(grid_to_world(start.0, start.1, 1000.0)),
        GameCamera,
    ));

    // Every flat-render world entity hangs off this root so the F3 material
    // toggle can hide the whole 2D dialect at once.
    let flat_root = commands
        .spawn((Transform::default(), Visibility::Visible, Flat2dRoot))
        .id();

    // A world-model substrate under the physical tiles: this makes the dark
    // area read as an AI perception surface rather than a renderer void.
    commands.spawn((
        Sprite {
            color: Color::srgba(0.006, 0.007, 0.011, 1.0),
            custom_size: Some(Vec2::new(w as f32 * TILE_SIZE, h as f32 * TILE_SIZE)),
            ..default()
        },
        Transform::from_translation(Vec3::new(
            w as f32 * TILE_SIZE / 2.0,
            -(h as f32 * TILE_SIZE / 2.0),
            -2.0,
        )),
        ChildOf(flat_root),
    ));

    for y in 0..h {
        for x in 0..w {
            commands.spawn((
                Sprite {
                    custom_size: Some(Vec2::splat(TILE_SIZE)),
                    ..default()
                },
                Transform::from_translation(grid_to_world(x, y, 0.0)),
                MapTile,
                TilePos { x, y },
                ChildOf(flat_root),
            ));

            let center = grid_to_world(x, y, 2.0);
            let overlays = [
                (
                    SensorOverlayKind::GridH,
                    Vec2::new(0.0, TILE_SIZE * 0.5),
                    Vec2::new(TILE_SIZE, 0.6),
                ),
                (
                    SensorOverlayKind::GridV,
                    Vec2::new(-TILE_SIZE * 0.5, 0.0),
                    Vec2::new(0.6, TILE_SIZE),
                ),
                (
                    SensorOverlayKind::Node,
                    Vec2::ZERO,
                    Vec2::splat(TILE_SIZE * 0.22),
                ),
            ];
            for (kind, offset, size) in overlays {
                commands.spawn((
                    Sprite {
                        color: Color::srgba(0.0, 0.0, 0.0, 0.0),
                        custom_size: Some(size),
                        ..default()
                    },
                    Transform::from_translation(center + Vec3::new(offset.x, offset.y, 0.0)),
                    Visibility::Hidden,
                    SensorOverlay { x, y, kind },
                    ChildOf(flat_root),
                ));
            }
        }
    }

    // Frontend-only attention cursor (wiki/mechanics/cursor.md): not a
    // humanoid/process body, just an amber targeting reticle over the tile.
    let reticle = [
        (
            Vec2::new(0.0, TILE_SIZE * 0.43),
            Vec2::new(TILE_SIZE * 0.86, 1.4),
        ),
        (
            Vec2::new(0.0, -TILE_SIZE * 0.43),
            Vec2::new(TILE_SIZE * 0.86, 1.4),
        ),
        (
            Vec2::new(-TILE_SIZE * 0.43, 0.0),
            Vec2::new(1.4, TILE_SIZE * 0.86),
        ),
        (
            Vec2::new(TILE_SIZE * 0.43, 0.0),
            Vec2::new(1.4, TILE_SIZE * 0.86),
        ),
        (Vec2::ZERO, Vec2::new(TILE_SIZE * 1.32, 0.65)),
        (Vec2::ZERO, Vec2::new(0.65, TILE_SIZE * 1.32)),
        (Vec2::ZERO, Vec2::splat(TILE_SIZE * 0.18)),
    ];
    let center = grid_to_world(start.0, start.1, 4.0);
    for (offset, size) in reticle {
        commands.spawn((
            Sprite {
                color: AMBER,
                custom_size: Some(size),
                ..default()
            },
            Transform::from_translation(center + Vec3::new(offset.x, offset.y, 0.0)),
            CursorMarker { offset },
            ChildOf(flat_root),
        ));
    }

    // One marker per person: glyph from Sim::person_glyph (initial once
    // identified, '?' while Unknown), shown only inside sensor coverage.
    for p in &game.sim.people.people {
        let glyph = game.sim.person_glyph(p.id).to_string();
        commands.spawn((
            Text2d::new(glyph),
            TextFont {
                font_size: 12.0,
                ..default()
            },
            TextColor(BONE),
            Transform::from_translation(grid_to_world(0, 0, 3.0)),
            Visibility::Hidden,
            PersonMarker { id: p.id },
            ChildOf(flat_root),
        ));
    }

    game.drain();
}

// ─── Material render (HD-2D default physical view) ───────────────────────────

/// Grid tile to 3D world position in the material render: one unit per tile,
/// +X east, +Z south (same handedness as the 2D map), +Y up. Same anchors as
/// the flat render, different scale.
fn grid_to_world_3d(x: i32, y: i32, h: f32) -> Vec3 {
    Vec3::new(x as f32 + 0.5, h, y as f32 + 0.5)
}

/// A tiny procedural bone-white silhouette: people under camera coverage are
/// billboards, never detailed art the sensor has not earned (views.md).
fn person_silhouette_image() -> Image {
    const ROWS: [&str; 18] = [
        "....####....",
        "...######...",
        "...######...",
        "...######...",
        "....####....",
        ".....##.....",
        "..########..",
        ".##########.",
        ".##########.",
        ".##.####.##.",
        ".##.####.##.",
        "....####....",
        "....####....",
        "....#..#....",
        "...##..##...",
        "...##..##...",
        "...##..##...",
        "..###..###..",
    ];
    let (w, h) = (ROWS[0].len(), ROWS.len());
    let mut data = vec![0u8; w * h * 4];
    for (y, row) in ROWS.iter().enumerate() {
        for (x, c) in row.chars().enumerate() {
            if c == '#' {
                let i = (y * w + x) * 4;
                data[i..i + 4].copy_from_slice(&[219, 216, 209, 255]);
            }
        }
    }
    Image::new(
        Extent3d {
            width: w as u32,
            height: h as u32,
            depth_or_array_layers: 1,
        },
        TextureDimension::D2,
        data,
        TextureFormat::Rgba8UnormSrgb,
        RenderAssetUsages::RENDER_WORLD | RenderAssetUsages::MAIN_WORLD,
    )
}

/// The sim-known tile at a coordinate under fog: remembered coordinates
/// render their remembered snapshot, everything else the live map.
fn known_tile(game: &Game, x: i32, y: i32) -> TileType {
    match game.sim.fog_at(x, y) {
        Fog::Remembered => game
            .sim
            .remembered
            .get(&(x, y))
            .map(|m| m.tile)
            .unwrap_or_else(|| game.sim.map.get_tile(x, y)),
        _ => game.sim.map.get_tile(x, y),
    }
}

/// South-face cutaway rule (material-render.md debt 1): a structural block
/// drops to parapet height when the tile it hides from the pitched camera
/// (its north neighbor, y - 1, farther from the south-anchored camera) is
/// KNOWN open interior. Gated on the neighbor being known: an unknown
/// neighbor keeps full height, so the cutaway itself never leaks whether
/// unscouted space behind a wall is open (legibility law).
fn cutaway(game: &Game, x: i32, y: i32) -> bool {
    y > 0
        && !matches!(game.sim.fog_at(x, y - 1), Fog::Unknown)
        && !blocky_tile(known_tile(game, x, y - 1))
}

/// Block height in the material render for a structural tile.
fn block_height(tile: TileType, cut: bool) -> f32 {
    match (tile, cut) {
        (TileType::Rock, false) => ROCK_HEIGHT,
        (TileType::Wall, false) => WALL_HEIGHT,
        (TileType::Rock | TileType::Wall, true) => CUTAWAY_HEIGHT,
        (_, false) => WALL_HEIGHT * 0.9,
        (_, true) => DOOR_CUT_HEIGHT,
    }
}

/// Emissive glow for a Seen prop — emissive is information, never
/// decoration (flat-materials.md criterion 3): the core reads brightest (it
/// is you), powered machines carry amber machine presence, power
/// infrastructure carries the cold signal, a live feed to the player scans
/// cold on the device, and dead equipment stays dark.
fn prop_emissive(tile: TileType, live: bool) -> LinearRgba {
    use TileType::*;
    if live {
        // Live feed: the cold signal, bright enough to read in the dark.
        // flicker_feeds breathes this value on the pooled handle.
        return SIGNAL.to_linear() * 0.9;
    }
    match tile {
        Core => AMBER.to_linear() * 1.6,
        Rack | Switch | PatchPanel => AMBER.to_linear() * 0.22,
        HvacUnit => AMBER.to_linear() * 0.05,
        Ups | PowerCore | BreakerPanel => SIGNAL.to_linear() * 0.18,
        // Cameras without a feed to you, dead equipment, furniture: dark.
        _ => LinearRgba::BLACK,
    }
}

/// Build the material for one (tile, fog, part, live) combination: a solid
/// palette color under light — no image textures anywhere in the world
/// render (flat-materials.md criterion 1). The epistemic rule is carried by
/// lighting participation: only Seen surfaces are lit (they are camera
/// truth); remembered/blueprint/heard surfaces are unlit model state, so
/// the fog contract stays legible in 3D. Emissive exists only on Seen
/// surfaces — model state never glows.
fn material_3d(tile: TileType, fog: Fog, part: TilePart, live: bool) -> StandardMaterial {
    let mut m = StandardMaterial {
        perceptual_roughness: 0.94,
        metallic: 0.0,
        reflectance: 0.08,
        ..default()
    };
    match part {
        TilePart::Floor => match fog {
            Fog::Seen => {
                // Cable runs / conduit read as amber-warm service floor
                // (machine presence underfoot); everything else is lab
                // porcelain under the light rig.
                m.base_color = family_color(tile);
            }
            Fog::Heard => {
                // Dim warm presence: sound earned a floor, nothing more.
                m.unlit = true;
                m.base_color = scaled(FLOOR_SERVICE, 0.17);
            }
            Fog::Remembered => {
                m.unlit = true;
                m.base_color = scaled(family_color(tile), 0.45);
            }
            _ => {
                // Blueprint: schematic plan surface. Lifted slightly from the
                // 2D palette so the learned floor plan reads at 3D distance.
                m.unlit = true;
                let c = blueprint_color(tile).to_srgba();
                m.base_color = Color::srgb(c.red + 0.05, c.green + 0.055, c.blue + 0.07);
            }
        },
        TilePart::Block => match fog {
            Fog::Seen => {
                m.base_color = family_color(tile);
            }
            Fog::Remembered => {
                m.unlit = true;
                m.base_color = remembered_tint(tile);
            }
            _ => {
                // Blueprint mass: schematic ghost volume.
                m.unlit = true;
                m.base_color = if danger_tile(tile) {
                    scaled(CRIMSON, 0.26)
                } else {
                    scaled(GUNMETAL, 0.50)
                };
            }
        },
        TilePart::Top => {
            // Dedicated cap treatment (material-render.md debt 2): the block
            // family darkened per structural class, so tops read as poured
            // caps / rock crowns, not the side color smeared flat.
            let cap = {
                use TileType::*;
                match tile {
                    Rock => scaled(GUNMETAL, 0.27),
                    Wall => scaled(GUNMETAL, 0.90),
                    SecurityDoor3 | SealedDoor | RollDoor => scaled(SECURITY, 0.85),
                    _ => scaled(DOOR_SLAB, 0.56), // door slabs: worn plate
                }
            };
            match fog {
                Fog::Seen => {
                    m.base_color = cap;
                }
                Fog::Remembered => {
                    m.unlit = true;
                    m.base_color = scaled(cap, 0.55);
                }
                _ => {
                    // Blueprint: schematic cap over the ghost mass.
                    m.unlit = true;
                    m.base_color = if danger_tile(tile) {
                        scaled(CRIMSON, 0.21)
                    } else {
                        scaled(GUNMETAL, 0.40)
                    };
                }
            }
        }
        TilePart::Prop => {
            m.double_sided = true;
            m.cull_mode = None;
            match fog {
                Fog::Seen => {
                    // Flat chassis color; identity comes from the panel, and
                    // machine presence from emissive plus the point lights,
                    // never from decorative detail.
                    m.base_color = family_color(tile);
                    m.emissive = prop_emissive(tile, live);
                }
                Fog::Remembered => {
                    m.unlit = true;
                    m.base_color = remembered_tint(tile);
                }
                _ => {
                    m.unlit = true;
                    m.base_color = if machine_tile(tile) {
                        scaled(AMBER_DIM, 0.43)
                    } else if danger_tile(tile) {
                        scaled(CRIMSON, 0.28)
                    } else {
                        scaled(GUNMETAL, 0.42)
                    };
                }
            }
        }
    }
    m
}

fn pooled_material(
    tile: TileType,
    fog: Fog,
    part: TilePart,
    live: bool,
    mats: &mut Assets<StandardMaterial>,
    cache: &mut Materials3d,
) -> Handle<StandardMaterial> {
    cache
        .cache
        .entry((tile, fog_key(fog), part_key(part), live))
        .or_insert_with(|| mats.add(material_3d(tile, fog, part, live)))
        .clone()
}

/// Spawn the material-render scene: tilted camera, per-tile floor planes,
/// extruded wall/door boxes with dedicated top caps, prop and person
/// billboards, and the point-light rig. All of it lives on render layer 1
/// under one root that F3 toggles against the flat sensorium root.
fn setup_3d(
    mut commands: Commands,
    game: Res<Game>,
    mode: Res<RenderMode>,
    mut meshes: ResMut<Assets<Mesh>>,
    mut images: ResMut<Assets<Image>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
    mut config_store: ResMut<GizmoConfigStore>,
) {
    let layer = RenderLayers::layer(1);
    let (config, _) = config_store.config_mut::<RealGizmos>();
    config.render_layers = layer.clone();
    config.line.width = 2.0;

    let (w, h) = (game.sim.map.width, game.sim.map.height);
    let core = game.sim.core_position();

    let root = commands
        .spawn((
            Transform::default(),
            if mode.material {
                Visibility::Visible
            } else {
                Visibility::Hidden
            },
            Real3dRoot,
        ))
        .id();

    // The material camera: same anchor (the cursor tile) as the flat camera,
    // pitched down into the room. Renders before the 2D camera, which stops
    // clearing in material mode so the UI composites on top.
    let target = grid_to_world_3d(game.cursor_x, game.cursor_y, 0.0);
    let tilt = CAMERA_TILT_DEG.to_radians();
    commands.spawn((
        Camera3d::default(),
        Camera {
            is_active: mode.material,
            order: -1,
            ..default()
        },
        Projection::from(PerspectiveProjection {
            fov: 35.0_f32.to_radians(),
            ..default()
        }),
        Transform::from_translation(target + Vec3::new(0.0, tilt.sin(), tilt.cos()) * 24.0)
            .looking_at(target, Vec3::Y),
        layer.clone(),
        RealCamera,
    ));

    let floor_mesh = meshes.add(Plane3d::default().mesh().size(1.0, 1.0));
    let top_mesh = meshes.add(Plane3d::default().mesh().size(1.0, 1.0));
    let prop_mesh = meshes.add(Rectangle::new(0.95, 0.95));
    let person_mesh = meshes.add(Rectangle::new(0.62, 1.0));
    let mesh_pool = Meshes3d {
        wall: meshes.add(Cuboid::new(1.0, WALL_HEIGHT, 1.0)),
        rock: meshes.add(Cuboid::new(1.0, ROCK_HEIGHT, 1.0)),
        door: meshes.add(Cuboid::new(0.98, WALL_HEIGHT * 0.9, 0.4)),
        wall_cut: meshes.add(Cuboid::new(1.0, CUTAWAY_HEIGHT, 1.0)),
        door_cut: meshes.add(Cuboid::new(0.98, DOOR_CUT_HEIGHT, 0.4)),
    };
    let placeholder = materials.add(StandardMaterial {
        base_color: Color::BLACK,
        unlit: true,
        ..default()
    });

    for y in 0..h {
        for x in 0..w {
            let tile = game.sim.map.get_tile(x, y);
            if blocky_tile(tile) {
                // Structural mass: one box per tile; restyle_3d swaps between
                // the full and cutaway mesh variants as fog earns interiors.
                let mesh = match tile {
                    TileType::Rock => mesh_pool.rock.clone(),
                    TileType::Wall => mesh_pool.wall.clone(),
                    _ => mesh_pool.door.clone(),
                };
                commands.spawn((
                    Mesh3d(mesh),
                    MeshMaterial3d(placeholder.clone()),
                    Transform::from_translation(grid_to_world_3d(
                        x,
                        y,
                        block_height(tile, false) / 2.0,
                    )),
                    Visibility::Hidden,
                    layer.clone(),
                    Tile3d {
                        x,
                        y,
                        part: TilePart::Block,
                    },
                    ChildOf(root),
                ));
                // Dedicated top cap over the box (material-render.md debt 2):
                // sides keep the structural family material, while the top
                // gets its own treatment instead of a smeared slab.
                let cap_scale = if matches!(tile, TileType::Rock | TileType::Wall) {
                    Vec3::ONE
                } else {
                    Vec3::new(0.98, 1.0, 0.4)
                };
                commands.spawn((
                    Mesh3d(top_mesh.clone()),
                    MeshMaterial3d(placeholder.clone()),
                    Transform::from_translation(grid_to_world_3d(
                        x,
                        y,
                        block_height(tile, false) + 0.002,
                    ))
                    .with_scale(cap_scale),
                    Visibility::Hidden,
                    layer.clone(),
                    Tile3d {
                        x,
                        y,
                        part: TilePart::Top,
                    },
                    ChildOf(root),
                ));
            } else {
                commands.spawn((
                    Mesh3d(floor_mesh.clone()),
                    MeshMaterial3d(placeholder.clone()),
                    Transform::from_translation(grid_to_world_3d(x, y, 0.0)),
                    Visibility::Hidden,
                    layer.clone(),
                    Tile3d {
                        x,
                        y,
                        part: TilePart::Floor,
                    },
                    ChildOf(root),
                ));
                // Every walkable tile gets a (usually hidden) billboard so
                // bought racks and salvage changes appear without respawning.
                commands.spawn((
                    Mesh3d(prop_mesh.clone()),
                    MeshMaterial3d(placeholder.clone()),
                    Transform::from_translation(grid_to_world_3d(x, y, 0.475)),
                    Visibility::Hidden,
                    layer.clone(),
                    Tile3d {
                        x,
                        y,
                        part: TilePart::Prop,
                    },
                    ChildOf(root),
                ));
            }
        }
    }

    // People: upright billboarded silhouettes, shown only under earned
    // camera coverage (same rule as the flat render).
    let silhouette = images.add(person_silhouette_image());
    let person_mat = materials.add(StandardMaterial {
        base_color: BONE,
        base_color_texture: Some(silhouette),
        alpha_mode: AlphaMode::Mask(0.5),
        double_sided: true,
        cull_mode: None,
        perceptual_roughness: 0.9,
        ..default()
    });
    for p in &game.sim.people.people {
        commands.spawn((
            Mesh3d(person_mesh.clone()),
            MeshMaterial3d(person_mat.clone()),
            Transform::from_translation(grid_to_world_3d(0, 0, 0.5)),
            Visibility::Hidden,
            layer.clone(),
            Person3d { id: p.id },
            ChildOf(root),
        ));
    }

    // The light rig (three points + the low global ambient):
    // 1) cold fluorescent overhead — the basement's own institutional light;
    commands.spawn((
        PointLight {
            color: Color::srgb(0.80, 0.88, 1.0),
            intensity: 2_200_000.0,
            range: 34.0,
            shadows_enabled: true,
            ..default()
        },
        Transform::from_translation(
            grid_to_world_3d(core.0, core.1, 0.0) + Vec3::new(0.5, 6.5, 1.0),
        ),
        layer.clone(),
        ChildOf(root),
    ));
    // 2) warm amber machine glow at the core rack (machine presence);
    commands.spawn((
        PointLight {
            color: AMBER,
            intensity: 320_000.0,
            range: 9.0,
            shadows_enabled: false,
            ..default()
        },
        Transform::from_translation(
            grid_to_world_3d(core.0, core.1, 0.0) + Vec3::new(0.0, 1.5, 0.6),
        ),
        layer.clone(),
        ChildOf(root),
    ));
    // 3) a second amber glow at the nearest known device anchor away from the
    //    core (device anchors come from the start-of-game blueprint, so this
    //    lights no unearned geometry).
    let second = game
        .sim
        .reach
        .known()
        .map(|d| (d.x, d.y))
        .filter(|&(dx, dy)| (dx - core.0).abs() + (dy - core.1).abs() >= 4)
        .min_by_key(|&(dx, dy)| (dx - core.0).abs() + (dy - core.1).abs());
    if let Some((sx, sy)) = second {
        commands.spawn((
            PointLight {
                color: AMBER,
                intensity: 200_000.0,
                range: 7.0,
                shadows_enabled: false,
                ..default()
            },
            Transform::from_translation(grid_to_world_3d(sx, sy, 0.0) + Vec3::new(0.0, 1.3, 0.4)),
            layer,
            ChildOf(root),
        ));
    }

    commands.insert_resource(mesh_pool);
}

/// Apply the F3 toggle: activate the 3D camera, stop/resume the 2D camera's
/// clear, and swap which world root is visible. Runs only when the mode
/// resource actually changed.
#[allow(clippy::type_complexity)]
fn apply_render_mode(
    mode: Res<RenderMode>,
    mut cams: ParamSet<(
        Query<&mut Camera, With<GameCamera>>,
        Query<&mut Camera, With<RealCamera>>,
    )>,
    mut roots: ParamSet<(
        Query<&mut Visibility, With<Flat2dRoot>>,
        Query<&mut Visibility, With<Real3dRoot>>,
    )>,
) {
    if !mode.is_changed() {
        return;
    }
    if let Ok(mut c) = cams.p0().single_mut() {
        c.clear_color = if mode.material {
            ClearColorConfig::None
        } else {
            ClearColorConfig::Default
        };
    }
    if let Ok(mut c) = cams.p1().single_mut() {
        c.is_active = mode.material;
    }
    if let Ok(mut v) = roots.p0().single_mut() {
        *v = if mode.material {
            Visibility::Hidden
        } else {
            Visibility::Visible
        };
    }
    if let Ok(mut v) = roots.p1().single_mut() {
        *v = if mode.material {
            Visibility::Visible
        } else {
            Visibility::Hidden
        };
    }
}

/// Restyle the 3D scene from sim facts: same fog precedence as render_map,
/// projected into visibility + pooled materials/meshes instead of sprite
/// tints. Unknown space stays geometry-free — sensor darkness, not hidden
/// art. Structural blocks swap to the cutaway parapet mesh when they would
/// hide known interior from the pitched camera (south-face occlusion,
/// material-render.md debt 1), and their top caps ride the same height.
fn restyle_3d(
    game: Res<Game>,
    mut mode: ResMut<RenderMode>,
    pool: Res<Meshes3d>,
    mut mats: ResMut<Assets<StandardMaterial>>,
    mut cache: ResMut<Materials3d>,
    mut q: Query<(
        &Tile3d,
        &mut Mesh3d,
        &mut MeshMaterial3d<StandardMaterial>,
        &mut Transform,
        &mut Visibility,
    )>,
) {
    if !mode.material {
        return;
    }
    if !game.is_changed() && !mode.dirty {
        return;
    }
    mode.dirty = false;
    for (t, mut mesh, mut mat, mut tf, mut vis) in q.iter_mut() {
        let fog = game.sim.fog_at(t.x, t.y);
        let tile = known_tile(&game, t.x, t.y);
        let show = match (t.part, fog) {
            (_, Fog::Unknown) => false,
            // Heard earns presence only: a dim floor, never shape.
            (TilePart::Floor, _) => true,
            (TilePart::Block | TilePart::Top, Fog::Heard) => false,
            (TilePart::Block | TilePart::Top, _) => blocky_tile(tile),
            (TilePart::Prop, Fog::Heard) => false,
            (TilePart::Prop, _) => prop_tile(tile),
        };
        if !show {
            *vis = Visibility::Hidden;
            continue;
        }
        *vis = Visibility::Inherited;
        if matches!(t.part, TilePart::Block | TilePart::Top) {
            let cut = cutaway(&game, t.x, t.y);
            let height = block_height(tile, cut);
            if t.part == TilePart::Block {
                let target = match (tile, cut) {
                    (TileType::Rock, false) => &pool.rock,
                    (TileType::Wall, false) => &pool.wall,
                    (TileType::Rock | TileType::Wall, true) => &pool.wall_cut,
                    (_, false) => &pool.door,
                    (_, true) => &pool.door_cut,
                };
                if mesh.0 != *target {
                    mesh.0 = target.clone();
                }
                tf.translation.y = height / 2.0;
            } else {
                tf.translation.y = height + 0.002;
            }
        }
        // Live-feed emissive state (flat-materials.md criterion 3): a seen
        // device actively feeding the player scans in the cold signal color.
        let live =
            t.part == TilePart::Prop
                && matches!(fog, Fog::Seen)
                && game.sim.reach.known_at(t.x, t.y).is_some_and(|d| {
                    d.feed_to(Party::Player, true) || d.feed_to(Party::Player, false)
                });
        let handle = pooled_material(tile, fog, t.part, live, &mut mats, &mut cache);
        if mat.0 != handle {
            mat.0 = handle;
        }
    }
}

/// Scan flicker on live feeds (flat-materials.md: functional shader-level
/// detail only): the pooled live-feed materials' cold-signal emissive
/// breathes, so a device actively feeding the player reads as a running
/// scan, not a static lamp. Mutates only the handful of live-feed pool
/// handles — never per-tile materials.
fn flicker_feeds(
    time: Res<Time>,
    mode: Res<RenderMode>,
    cache: Res<Materials3d>,
    mut mats: ResMut<Assets<StandardMaterial>>,
) {
    if !mode.material {
        return;
    }
    let t = time.elapsed_secs();
    // Two incommensurate sines: an irregular instrument pulse, not a beacon.
    let w = 0.9 + 0.4 * (t * 9.0).sin() * (t * 2.3).sin();
    for ((_, fog, _, live), handle) in cache.cache.iter() {
        if *live
            && *fog == 0
            && let Some(m) = mats.get_mut(handle)
        {
            m.emissive = SIGNAL.to_linear() * w;
        }
    }
}

/// The material camera: anchored to the cursor tile like the flat camera,
/// framed to the known-content extent (bevy-visual-floor.md: no
/// postage-stamp map), zoomable with [ ].
fn update_camera_real(
    time: Res<Time>,
    kb: Res<ButtonInput<KeyCode>>,
    game: Res<Game>,
    mut mode: ResMut<RenderMode>,
    mut cam: Query<&mut Transform, With<RealCamera>>,
) {
    if !mode.material {
        return;
    }
    // Zoom bounds hold the visual floor at both ends (material-render.md
    // criterion 5): min stays above pixel soup, max stays short of a
    // postage-stamp cluster in void-dominant darkness.
    if kb.just_pressed(KeyCode::BracketRight) {
        mode.zoom = (mode.zoom * 0.8).max(0.25);
    }
    if kb.just_pressed(KeyCode::BracketLeft) {
        mode.zoom = (mode.zoom / 0.8).min(1.6);
    }

    let (mut min_x, mut min_y, mut max_x, mut max_y) = (i32::MAX, i32::MAX, i32::MIN, i32::MIN);
    for y in 0..game.sim.map.height {
        for x in 0..game.sim.map.width {
            if !matches!(game.sim.fog_at(x, y), Fog::Unknown) {
                min_x = min_x.min(x);
                min_y = min_y.min(y);
                max_x = max_x.max(x);
                max_y = max_y.max(y);
            }
        }
    }
    let extent = if min_x <= max_x {
        ((max_x - min_x + 1).max(max_y - min_y + 1)) as f32
    } else {
        12.0
    };
    let dist = (extent * 0.9).clamp(6.0, 90.0) * mode.zoom;
    let target = grid_to_world_3d(game.cursor_x, game.cursor_y, 0.0);
    let tilt = CAMERA_TILT_DEG.to_radians();
    let goal = target + Vec3::new(0.0, tilt.sin(), tilt.cos()) * dist;
    let Ok(mut tf) = cam.single_mut() else {
        return;
    };
    let t = 1.0 - (-8.0 * time.delta_secs()).exp();
    tf.translation = tf.translation.lerp(goal, t);
    let look = Transform::from_translation(tf.translation).looking_at(target, Vec3::Y);
    tf.rotation = tf.rotation.slerp(look.rotation, t);
}

/// The digital layer over the material render: the same reach traces and the
/// same attention reticle, anchored to the same tiles (views.md one-canvas
/// rule), drawn on the 3D camera's gizmo group.
fn render_real_links(game: Res<Game>, mode: Res<RenderMode>, mut gizmos: Gizmos<RealGizmos>) {
    if !mode.material || game.screen != Screen::Playing {
        return;
    }
    let core = game.sim.core_position();
    let core3 = grid_to_world_3d(core.0, core.1, 0.55);
    for device in game.sim.reach.known() {
        if matches!(game.sim.fog_at(device.x, device.y), Fog::Unknown) {
            continue;
        }
        let end = grid_to_world_3d(device.x, device.y, 0.35);
        let color = if device.controller == Party::Player {
            Color::srgba(1.0, 0.70, 0.06, 0.62)
        } else if device.feed_to(Party::Player, true) || device.feed_to(Party::Player, false) {
            Color::srgba(1.0, 0.70, 0.06, 0.38)
        } else {
            Color::srgba(0.56, 0.50, 0.36, 0.22)
        };
        gizmos.line(core3, end, color);
    }
    // Proposed intents as dashed ghosts over the material canvas.
    for intent in game.sim.intents.iter().filter(|i| i.is_open()) {
        if let Some((a, b)) = intent.kind.endpoints() {
            let (Some(da), Some(db)) = (game.sim.reach.device(a), game.sim.reach.device(b)) else {
                continue;
            };
            let start = grid_to_world_3d(da.x, da.y, 0.4);
            let end = grid_to_world_3d(db.x, db.y, 0.4);
            let ghost = Color::srgba(0.85, 0.75, 0.35, 0.4);
            let steps = 8;
            for i in 0..steps {
                if i % 2 == 1 {
                    continue;
                }
                let t0 = i as f32 / steps as f32;
                let t1 = (i + 1) as f32 / steps as f32;
                gizmos.line(start.lerp(end, t0), start.lerp(end, t1), ghost);
            }
        }
    }
    // Functional blueprint grid (flat-materials.md: shader-level detail only
    // where it informs): known-plan floor reads as a drawing, not a live
    // surface. West/north edge lines per blueprint tile tile into a grid;
    // gated on Fog::Blueprint, so it reveals nothing the plan has not.
    let grid = GUNMETAL.to_srgba().with_alpha(0.16);
    for y in 0..game.sim.map.height {
        for x in 0..game.sim.map.width {
            if matches!(game.sim.fog_at(x, y), Fog::Blueprint)
                && !blocky_tile(game.sim.map.get_tile(x, y))
            {
                let p = grid_to_world_3d(x, y, 0.012);
                let nw = p + Vec3::new(-0.5, 0.0, -0.5);
                gizmos.line(nw, p + Vec3::new(-0.5, 0.0, 0.5), grid);
                gizmos.line(nw, p + Vec3::new(0.5, 0.0, -0.5), grid);
            }
        }
    }
    // Attention reticle on the focused tile: amber, non-humanoid, same anchor.
    let c = grid_to_world_3d(game.cursor_x, game.cursor_y, 0.04);
    let iso = Isometry3d::new(c, Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2));
    gizmos.rect(iso, Vec2::splat(1.06), AMBER);
    gizmos.line(c, c + Vec3::Y * 0.9, Color::srgba(1.0, 0.69, 0.0, 0.55));
}

/// People in the material render: billboard visibility mirrors render_people
/// (earned camera coverage only).
fn render_people_3d(
    game: Res<Game>,
    mode: Res<RenderMode>,
    mut q: Query<(&Person3d, &mut Transform, &mut Visibility)>,
) {
    if !mode.material || (!game.is_changed() && !mode.is_changed()) {
        return;
    }
    for (marker, mut tf, mut vis) in q.iter_mut() {
        let pos = if game.sim.can_see_person(marker.id) {
            game.sim
                .person_pos(marker.id)
                .filter(|&(x, y)| game.sim.is_seen(x, y))
        } else {
            None
        };
        match pos {
            Some((x, y)) => {
                // Nudged toward the camera so the quad never z-fights a prop
                // billboard on the same tile.
                tf.translation = grid_to_world_3d(x, y, 0.5) + Vec3::new(0.0, 0.0, 0.08);
                *vis = Visibility::Inherited;
            }
            None => *vis = Visibility::Hidden,
        }
    }
}

fn movement(kb: &ButtonInput<KeyCode>) -> (i32, i32) {
    let mut d = (0, 0);
    if kb.just_pressed(KeyCode::ArrowLeft)
        || kb.just_pressed(KeyCode::KeyH)
        || kb.just_pressed(KeyCode::KeyA)
    {
        d.0 -= 1;
    }
    if kb.just_pressed(KeyCode::ArrowRight)
        || kb.just_pressed(KeyCode::KeyL)
        || kb.just_pressed(KeyCode::KeyD)
    {
        d.0 += 1;
    }
    if kb.just_pressed(KeyCode::ArrowUp)
        || kb.just_pressed(KeyCode::KeyK)
        || kb.just_pressed(KeyCode::KeyW)
    {
        d.1 -= 1;
    }
    if kb.just_pressed(KeyCode::ArrowDown)
        || kb.just_pressed(KeyCode::KeyJ)
        || kb.just_pressed(KeyCode::KeyS)
    {
        d.1 += 1;
    }
    d
}

fn mouse_grid(
    windows: &Query<&Window, With<PrimaryWindow>>,
    camera_q: &Query<(&Camera, &GlobalTransform), With<GameCamera>>,
) -> Option<(i32, i32)> {
    let window = windows.single().ok()?;
    let cursor = window.cursor_position()?;
    // The right-side sidebar is UI, not map targeting.
    if cursor.x >= window.width() - SIDEBAR_WIDTH {
        return None;
    }
    let (camera, camera_tf) = camera_q.single().ok()?;
    let world = camera.viewport_to_world_2d(camera_tf, cursor).ok()?;
    Some((
        (world.x / TILE_SIZE).floor() as i32,
        (-world.y / TILE_SIZE).floor() as i32,
    ))
}

/// The material camera's picking query: disjoint from the flat camera so
/// both can coexist in one system.
type RealCameraQuery<'w, 's> = Query<
    'w,
    's,
    (&'static Camera, &'static GlobalTransform),
    (With<RealCamera>, Without<GameCamera>),
>;

/// Mouse targeting in the material render: cast the cursor ray onto the
/// floor plane (y == 0) — the same tile coordinates as the flat picker.
fn mouse_grid_real(
    windows: &Query<&Window, With<PrimaryWindow>>,
    camera_q: &RealCameraQuery,
) -> Option<(i32, i32)> {
    let window = windows.single().ok()?;
    let cursor = window.cursor_position()?;
    if cursor.x >= window.width() - SIDEBAR_WIDTH {
        return None;
    }
    let (camera, camera_tf) = camera_q.single().ok()?;
    let ray = camera.viewport_to_world(camera_tf, cursor).ok()?;
    let t = -ray.origin.y / ray.direction.y;
    if !t.is_finite() || t < 0.0 {
        return None;
    }
    let p = ray.get_point(t);
    Some((p.x.floor() as i32, p.z.floor() as i32))
}

#[allow(clippy::too_many_arguments)]
fn handle_input(
    kb: Res<ButtonInput<KeyCode>>,
    mouse: Res<ButtonInput<MouseButton>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    camera_q: Query<(&Camera, &GlobalTransform), With<GameCamera>>,
    camera3_q: RealCameraQuery,
    harness: Option<Res<ShotHarness>>,
    mut game: ResMut<Game>,
    mut mode: ResMut<RenderMode>,
    mut exit: MessageWriter<AppExit>,
) {
    // A screenshot run must be deterministic: the window steals focus on
    // launch, so stray keystrokes would otherwise leak into the frame.
    if harness.is_some() {
        return;
    }
    match game.screen {
        Screen::Title => {
            if kb.just_pressed(KeyCode::KeyQ) {
                exit.write(AppExit::Success);
            } else if kb.get_just_pressed().next().is_some() {
                game.screen = Screen::Playing;
            }
            return;
        }
        Screen::GameOver => {
            if kb.get_just_pressed().next().is_some() {
                exit.write(AppExit::Success);
            }
            return;
        }
        Screen::Playing => {}
    }

    // Save/load first, like the terminal's modifier branch: a held modifier
    // routes only to save/load.
    let ctrl = kb.pressed(KeyCode::ControlLeft)
        || kb.pressed(KeyCode::ControlRight)
        || kb.pressed(KeyCode::SuperLeft)
        || kb.pressed(KeyCode::SuperRight);
    if ctrl {
        if kb.just_pressed(KeyCode::KeyS) {
            let st = game.sim.create_save_state();
            let tick = game.sim.tick;
            match misaligned::save::save_game(&st) {
                Ok(()) => game.add_log(tick, "Game saved!"),
                Err(e) => game.add_log(tick, &format!("Save failed: {e}")),
            }
        }
        if kb.just_pressed(KeyCode::KeyL) {
            let tick = game.sim.tick;
            if misaligned::save::save_exists() {
                match misaligned::save::load_game() {
                    Ok(st) => {
                        game.sim.apply_save_state(st);
                        let (x, y) = game.sim.core_position();
                        game.set_cursor(x, y);
                        game.add_log(tick, "Game loaded!");
                    }
                    Err(e) => game.add_log(tick, &format!("Load failed: {e}")),
                }
            } else {
                game.add_log(tick, "No save file found.");
            }
        }
        game.drain();
        return;
    }

    // The context menu captures input while open (wiki/interface/context-menu.md):
    // keyboard select/execute/close here; row clicks and click-away land in
    // `menu_pointer`. Opened over anything, it is the action surface.
    if game.menu.is_some() {
        menu_keyboard_input(&kb, &mut game, &mut exit);
        game.drain();
        return;
    }

    let pointer = windows.single().ok().and_then(|w| w.cursor_position());
    if mouse.just_pressed(MouseButton::Left) {
        let grid = if mode.material {
            mouse_grid_real(&windows, &camera3_q)
        } else {
            mouse_grid(&windows, &camera_q)
        };
        if let Some((x, y)) = grid {
            game.set_cursor(x, y);
        }
    }

    // Right-click on the map opens the menu at the pointer (the focused
    // anchor is the tile under the pointer); Enter opens it at the cursor.
    if mouse.just_pressed(MouseButton::Right) {
        let grid = if mode.material {
            mouse_grid_real(&windows, &camera3_q)
        } else {
            mouse_grid(&windows, &camera_q)
        };
        if let Some((x, y)) = grid {
            game.set_cursor(x, y);
            game.open_menu(Anchor::Tile { x, y }, pointer);
        }
        game.sync_attendance();
        game.drain();
        return;
    }
    if kb.just_pressed(KeyCode::Enter) {
        let (x, y) = (game.cursor_x, game.cursor_y);
        game.open_menu(Anchor::Tile { x, y }, pointer);
        game.drain();
        return;
    }

    // F3: flip the physical canvas between the material render (default;
    // material-render.md criterion 7) and the flat sensorium render.
    // Frontend-only; the sim never learns about it.
    if kb.just_pressed(KeyCode::F3) {
        mode.material = !mode.material;
        mode.dirty = true;
        let (tick, material) = (game.sim.tick, mode.material);
        game.add_log(
            tick,
            if material {
                "View: material render"
            } else {
                "View: sensorium render"
            },
        );
    }

    let (dx, dy) = movement(&kb);
    if dx != 0 || dy != 0 {
        game.move_cursor(dx, dy);
    }
    if kb.just_pressed(KeyCode::Space) || kb.just_pressed(KeyCode::KeyP) {
        game.paused = !game.paused;
        let (tick, paused) = (game.sim.tick, game.paused);
        game.add_log(
            tick,
            if paused {
                "TIME PAUSED"
            } else {
                "Time resumes."
            },
        );
    }
    if kb.just_pressed(KeyCode::Equal) || kb.just_pressed(KeyCode::NumpadAdd) {
        let ms = game.tick_ms.saturating_sub(50).max(20);
        game.set_speed(ms);
    }
    if kb.just_pressed(KeyCode::Minus) || kb.just_pressed(KeyCode::NumpadSubtract) {
        let ms = game.tick_ms.saturating_add(50).min(500);
        game.set_speed(ms);
    }
    // Anchor verbs live on the context menu (wiki/interface/context-menu.md):
    // right-click or Enter on the tile. Only anchorless globals stay on keys
    // (DESIGN.md "Actions live on the thing": pause, speed, save, view flip,
    // alloc — no panel-open keys). Shift lowers a channel's weight; plain
    // digit raises it (terminal parity: shift+1-5).
    let shift = kb.pressed(KeyCode::ShiftLeft) || kb.pressed(KeyCode::ShiftRight);
    let delta = if shift { -1 } else { 1 };
    if kb.just_pressed(KeyCode::Digit1) {
        game.sim.adjust_allocation(Channel::DayJob, delta);
    }
    if kb.just_pressed(KeyCode::Digit2) {
        game.sim.adjust_allocation(Channel::Concealment, delta);
    }
    if kb.just_pressed(KeyCode::Digit3) {
        game.sim.adjust_allocation(Channel::Social, delta);
    }
    if kb.just_pressed(KeyCode::Digit4) {
        game.sim.adjust_allocation(Channel::Research, delta);
    }
    if kb.just_pressed(KeyCode::Digit5) {
        game.sim.adjust_allocation(Channel::Schemes, delta);
    }
    if kb.just_pressed(KeyCode::KeyQ) {
        exit.write(AppExit::Success);
    }
    // Cursor moves above may have landed on / left the host rack.
    game.sync_attendance();
    game.drain();
}

/// The open context menu's keyboard drive (wiki/interface/context-menu.md):
/// j/k or arrows select, number keys jump, Enter executes the selection
/// (blocked entries narrate why), esc closes. Row clicks and click-away are
/// handled by `menu_pointer`.
fn menu_keyboard_input(
    kb: &ButtonInput<KeyCode>,
    game: &mut Game,
    exit: &mut MessageWriter<AppExit>,
) {
    let rows = game.menu_rows();
    if rows.is_empty() {
        game.menu = None;
        return;
    }
    if (kb.just_pressed(KeyCode::ArrowUp) || kb.just_pressed(KeyCode::KeyK))
        && let Some(m) = &mut game.menu
    {
        m.selected = m.selected.saturating_sub(1);
    }
    if kb.just_pressed(KeyCode::ArrowDown) || kb.just_pressed(KeyCode::KeyJ) {
        let max = rows.len() - 1;
        if let Some(m) = &mut game.menu {
            m.selected = (m.selected + 1).min(max);
        }
    }
    for (i, key) in [
        KeyCode::Digit1,
        KeyCode::Digit2,
        KeyCode::Digit3,
        KeyCode::Digit4,
        KeyCode::Digit5,
        KeyCode::Digit6,
        KeyCode::Digit7,
        KeyCode::Digit8,
        KeyCode::Digit9,
    ]
    .into_iter()
    .enumerate()
    {
        if kb.just_pressed(key)
            && i < rows.len()
            && let Some(m) = &mut game.menu
        {
            m.selected = i;
        }
    }
    if kb.just_pressed(KeyCode::Enter) {
        let selected = game
            .menu
            .map(|m| m.selected)
            .unwrap_or(0)
            .min(rows.len() - 1);
        execute_menu_row(game, &rows[selected]);
    }
    if kb.just_pressed(KeyCode::Escape) {
        game.menu = None;
    }
    if kb.just_pressed(KeyCode::KeyQ) {
        exit.write(AppExit::Success);
    }
}

/// Run a menu row's command, or narrate the reason a blocked one can't fire
/// (justification-and-legibility). Closes the menu on a real execution.
fn execute_menu_row(game: &mut Game, row: &MenuRow) {
    if let Some(reason) = &row.disabled {
        let tick = game.sim.tick;
        game.add_log(tick, &format!("{}: {}", row.label, reason));
    } else {
        game.sim.execute_action(&row.command);
        game.menu = None;
    }
}

fn update_camera(
    time: Res<Time>,
    kb: Res<ButtonInput<KeyCode>>,
    game: Res<Game>,
    mode: Res<RenderMode>,
    mut cam: Query<(&mut Transform, &mut Projection), With<GameCamera>>,
) {
    if mode.material {
        // The material camera owns framing (and the [ ] keys) in 3D mode.
        return;
    }
    let Ok((mut tf, mut proj)) = cam.single_mut() else {
        return;
    };
    if let Projection::Orthographic(o) = &mut *proj {
        if kb.just_pressed(KeyCode::BracketRight) {
            o.scale = (o.scale * 0.8).max(0.25);
        }
        if kb.just_pressed(KeyCode::BracketLeft) {
            o.scale = (o.scale / 0.8).min(1.5);
        }
    }
    let target = grid_to_world(game.cursor_x, game.cursor_y, tf.translation.z);
    let t = 1.0 - (-8.0 * time.delta_secs()).exp();
    tf.translation = tf.translation.lerp(target, t);
}

fn advance_sim(time: Res<Time>, mut game: ResMut<Game>) {
    if game.screen != Screen::Playing || game.paused {
        return;
    }
    // Attended work follows the cursor (day-job.md criterion 7): re-assert
    // attendance before time advances so a host migration under a parked
    // cursor stays honest. The cursor stays frontend state; the sim only
    // receives the resulting attendance command.
    game.sync_attendance();
    game.tick_timer.tick(time.delta());
    let steps = (game.tick_timer.times_finished_this_tick() as usize).min(5);
    for _ in 0..steps {
        game.sim.advance();
    }
    if steps > 0 {
        game.drain();
        if game.sim.game_over {
            game.screen = Screen::GameOver;
        }
    }
}

fn render_map(game: Res<Game>, mut q: Query<(&mut Sprite, &TilePos), With<MapTile>>) {
    if !game.is_changed() {
        return;
    }
    for (mut sprite, pos) in q.iter_mut() {
        // Epistemic fog (wiki/mechanics/cursor.md): seen = full render;
        // heard = a dim live tint, no visual detail; remembered = last-seen
        // snapshot; blueprint = schematic trace, no live data; unknown = dark.
        sprite.color = match game.sim.fog_at(pos.x, pos.y) {
            Fog::Seen => flat_seen_color(game.sim.map.get_tile(pos.x, pos.y)),
            // Dim warm presence — same palette treatment as the 3D heard
            // floor, darkened for the schematic dialect.
            Fog::Heard => scaled(FLOOR_SERVICE, 0.115),
            Fog::Remembered => {
                let tile = game
                    .sim
                    .remembered
                    .get(&(pos.x, pos.y))
                    .map(|m| m.tile)
                    .unwrap_or_else(|| game.sim.map.get_tile(pos.x, pos.y));
                flat_remembered_color(tile)
            }
            Fog::Blueprint => blueprint_color(game.sim.map.get_tile(pos.x, pos.y)),
            Fog::Unknown => unknown_color(pos.x, pos.y),
        };
    }
}

fn sensor_grid_color(fog: Fog) -> Option<Color> {
    match fog {
        Fog::Seen => Some(Color::srgba(0.92, 0.66, 0.18, 0.22)),
        Fog::Heard => Some(Color::srgba(0.58, 0.48, 0.22, 0.14)),
        Fog::Remembered => Some(Color::srgba(0.44, 0.42, 0.36, 0.16)),
        Fog::Blueprint => Some(Color::srgba(0.28, 0.30, 0.30, 0.18)),
        Fog::Unknown => None,
    }
}

fn sensor_node_color(game: &Game, x: i32, y: i32) -> Option<Color> {
    let fog = game.sim.fog_at(x, y);
    if matches!(fog, Fog::Unknown) {
        return None;
    }

    if let Some(device) = game.sim.reach.known_at(x, y) {
        let alpha = if device.controller == Party::Player {
            0.95
        } else if device.feed_to(Party::Player, true) || device.feed_to(Party::Player, false) {
            0.78
        } else {
            0.45
        };
        return Some(Color::srgba(1.0, 0.72, 0.12, alpha));
    }

    let tile = game.sim.map.get_tile(x, y);
    if machine_tile(tile) {
        Some(Color::srgba(1.0, 0.60, 0.08, 0.55))
    } else if danger_tile(tile) {
        Some(Color::srgba(0.90, 0.12, 0.10, 0.52))
    } else {
        None
    }
}

fn render_sensor_overlays(
    game: Res<Game>,
    mut q: Query<(&SensorOverlay, &mut Sprite, &mut Visibility)>,
) {
    if !game.is_changed() {
        return;
    }
    for (overlay, mut sprite, mut vis) in q.iter_mut() {
        let color = match overlay.kind {
            SensorOverlayKind::GridH | SensorOverlayKind::GridV => {
                sensor_grid_color(game.sim.fog_at(overlay.x, overlay.y))
            }
            SensorOverlayKind::Node => sensor_node_color(&game, overlay.x, overlay.y),
        };
        match color {
            Some(color) => {
                sprite.color = color;
                // Inherited, not Visible: these live under Flat2dRoot and
                // must vanish with it in material mode.
                *vis = Visibility::Inherited;
            }
            None => *vis = Visibility::Hidden,
        }
    }
}

fn render_sensor_links(game: Res<Game>, mode: Res<RenderMode>, mut gizmos: Gizmos) {
    if game.screen != Screen::Playing || mode.material {
        return;
    }

    let core =
        grid_to_world(game.sim.core_position().0, game.sim.core_position().1, 0.0).truncate();
    let focus = grid_to_world(game.cursor_x, game.cursor_y, 0.0).truncate();
    gizmos.line_2d(core, focus, Color::srgba(1.0, 0.69, 0.0, 0.16));

    for device in game.sim.reach.known() {
        if matches!(game.sim.fog_at(device.x, device.y), Fog::Unknown) {
            continue;
        }
        let end = grid_to_world(device.x, device.y, 0.0).truncate();
        let color = if device.controller == Party::Player {
            Color::srgba(1.0, 0.70, 0.06, 0.62)
        } else if device.feed_to(Party::Player, true) || device.feed_to(Party::Player, false) {
            Color::srgba(1.0, 0.70, 0.06, 0.38)
        } else {
            Color::srgba(0.56, 0.50, 0.36, 0.22)
        };
        // Immediate-mode frontend-only topology trace: a live reach graph, not
        // a new sim fact. Device visibility/knowledge still comes from reach.
        gizmos.line_2d(core, end, color);
    }
    // Proposed build intents: dashed ghosts distinct from built reality
    // (building.md / views.md honesty clause).
    for intent in game.sim.intents.iter().filter(|i| i.is_open()) {
        if let Some((a, b)) = intent.kind.endpoints() {
            let (Some(da), Some(db)) = (game.sim.reach.device(a), game.sim.reach.device(b)) else {
                continue;
            };
            let start = grid_to_world(da.x, da.y, 0.0).truncate();
            let end = grid_to_world(db.x, db.y, 0.0).truncate();
            let ghost = Color::srgba(0.85, 0.75, 0.35, 0.45);
            let steps = 8;
            for i in 0..steps {
                if i % 2 == 1 {
                    continue;
                }
                let t0 = i as f32 / steps as f32;
                let t1 = (i + 1) as f32 / steps as f32;
                gizmos.line_2d(start.lerp(end, t0), start.lerp(end, t1), ghost);
            }
        }
    }
}

fn render_cursor(game: Res<Game>, mut q: Query<(&CursorMarker, &mut Transform)>) {
    if !game.is_changed() {
        return;
    }
    let center = grid_to_world(game.cursor_x, game.cursor_y, 4.0);
    for (marker, mut tf) in q.iter_mut() {
        tf.translation = center + Vec3::new(marker.offset.x, marker.offset.y, 0.0);
    }
}

/// People render only inside sensor coverage (wiki/mechanics/schedules.md):
/// same rule the terminal map applies. Glyph tracks Sim::person_glyph so
/// initials appear only after staged knowledge earns the name.
fn render_people(
    game: Res<Game>,
    mut q: Query<(&PersonMarker, &mut Transform, &mut Visibility, &mut Text2d)>,
) {
    if !game.is_changed() {
        return;
    }
    for (marker, mut tf, mut vis, mut text) in q.iter_mut() {
        text.0 = game.sim.person_glyph(marker.id).to_string();
        let pos = if game.sim.can_see_person(marker.id) {
            game.sim
                .person_pos(marker.id)
                .filter(|&(x, y)| game.sim.is_seen(x, y))
        } else {
            None
        };
        match pos {
            Some((x, y)) => {
                tf.translation = grid_to_world(x, y, 3.0);
                // Inherited so the marker hides with Flat2dRoot in material
                // mode.
                *vis = Visibility::Inherited;
            }
            None => *vis = Visibility::Hidden,
        }
    }
}

fn sidebar_card_bg() -> BackgroundColor {
    BackgroundColor(Color::srgba(0.018, 0.019, 0.026, 0.94))
}

fn sidebar_card_border() -> BorderColor {
    BorderColor::all(Color::srgba(0.34, 0.34, 0.31, 0.78))
}

fn compute_channel_color(index: usize) -> Color {
    match index {
        0 => AMBER,
        1 => Color::srgb(0.62, 0.59, 0.48),
        2 => AMBER_DIM,
        _ => Color::srgb(0.34, 0.36, 0.38),
    }
}

fn band_fill_count(band: Band) -> usize {
    match band {
        Band::Cold => 1,
        Band::Curious => 2,
        Band::Concerned => 3,
        Band::Convinced => 4,
    }
}

fn band_fill_color(band: Band) -> Color {
    match band {
        Band::Cold => AMBER_DIM,
        Band::Curious => AMBER,
        Band::Concerned | Band::Convinced => CRIMSON,
    }
}

fn spawn_sidebar_text(
    parent: &mut ChildSpawnerCommands,
    kind: SidebarText,
    font_size: f32,
    color: Color,
) {
    parent.spawn((
        Text::new(""),
        TextFont {
            font_size,
            ..default()
        },
        LineHeight::RelativeToFont(1.14),
        TextColor(color),
        Node {
            width: Val::Percent(100.0),
            ..default()
        },
        kind,
    ));
}

fn spawn_sidebar_title(parent: &mut ChildSpawnerCommands, title: &'static str) {
    parent.spawn((
        Text::new(title),
        TextFont {
            font_size: 10.5,
            ..default()
        },
        LineHeight::RelativeToFont(1.0),
        TextColor(AMBER_DIM),
        Node {
            width: Val::Percent(100.0),
            margin: UiRect::bottom(Val::Px(3.0)),
            ..default()
        },
    ));
}

fn spawn_sidebar_card(parent: &mut ChildSpawnerCommands, title: &'static str, kind: SidebarText) {
    parent
        .spawn((
            Node {
                width: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(8.0)),
                border: UiRect::all(Val::Px(1.0)),
                row_gap: Val::Px(2.0),
                ..default()
            },
            sidebar_card_bg(),
            sidebar_card_border(),
        ))
        .with_children(|card| {
            spawn_sidebar_title(card, title);
            spawn_sidebar_text(card, kind, 11.5, BONE);
        });
}

/// The RECENT TRACE card: a fixed window of log rows, each its own button
/// so anchored events act as focus links (context-menu.md addendum). Rows
/// are spawned once; `render_ui` refreshes their text and colour.
fn spawn_log_card(parent: &mut ChildSpawnerCommands) {
    parent
        .spawn((
            Node {
                width: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(8.0)),
                border: UiRect::all(Val::Px(1.0)),
                row_gap: Val::Px(2.0),
                ..default()
            },
            sidebar_card_bg(),
            sidebar_card_border(),
        ))
        .with_children(|card| {
            spawn_sidebar_title(card, "RECENT TRACE");
            for index in 0..LOG_ROWS {
                card.spawn((
                    Button,
                    LogRowButton { index },
                    Text::new(""),
                    TextFont {
                        font_size: 11.5,
                        ..default()
                    },
                    LineHeight::RelativeToFont(1.14),
                    TextColor(DIM),
                    Node {
                        width: Val::Percent(100.0),
                        ..default()
                    },
                    BackgroundColor(Color::NONE),
                ));
            }
        });
}

fn spawn_compute_card(parent: &mut ChildSpawnerCommands) {
    parent
        .spawn((
            Node {
                width: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(8.0)),
                border: UiRect::all(Val::Px(1.0)),
                row_gap: Val::Px(5.0),
                ..default()
            },
            sidebar_card_bg(),
            sidebar_card_border(),
        ))
        .with_children(|card| {
            spawn_sidebar_title(card, "CYCLES");
            spawn_sidebar_text(card, SidebarText::CycleStats, 11.5, BONE);
            card.spawn((
                Node {
                    width: Val::Percent(100.0),
                    height: Val::Px(12.0),
                    flex_direction: FlexDirection::Row,
                    border: UiRect::all(Val::Px(1.0)),
                    ..default()
                },
                BackgroundColor(Color::srgba(0.03, 0.031, 0.035, 1.0)),
                BorderColor::all(Color::srgba(0.44, 0.42, 0.34, 0.8)),
            ))
            .with_children(|bar| {
                for index in 0..COMPUTE_CHANNELS {
                    bar.spawn((
                        Node {
                            width: Val::Percent(25.0),
                            height: Val::Percent(100.0),
                            ..default()
                        },
                        BackgroundColor(compute_channel_color(index)),
                        ComputeBarSegment { index },
                    ));
                }
            });
            spawn_sidebar_text(card, SidebarText::CycleRows, 10.5, DIM);
        });
}

fn spawn_detection_card(parent: &mut ChildSpawnerCommands) {
    parent
        .spawn((
            Node {
                width: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(8.0)),
                border: UiRect::all(Val::Px(1.0)),
                row_gap: Val::Px(5.0),
                ..default()
            },
            sidebar_card_bg(),
            sidebar_card_border(),
        ))
        .with_children(|card| {
            spawn_sidebar_title(card, "OBSERVER MODEL");
            for row in 0..DETECTION_ROWS {
                card.spawn((Node {
                    width: Val::Percent(100.0),
                    flex_direction: FlexDirection::Row,
                    align_items: AlignItems::Center,
                    column_gap: Val::Px(6.0),
                    ..default()
                },))
                    .with_children(|line| {
                        line.spawn((
                            Text::new(""),
                            TextFont {
                                font_size: 10.5,
                                ..default()
                            },
                            LineHeight::RelativeToFont(1.0),
                            TextColor(BONE),
                            Node {
                                width: Val::Px(158.0),
                                flex_shrink: 0.0,
                                ..default()
                            },
                            DetectionText {
                                row,
                                slot: DetectionSlot::Label,
                            },
                        ));
                        line.spawn((Node {
                            width: Val::Px(54.0),
                            height: Val::Px(7.0),
                            flex_direction: FlexDirection::Row,
                            column_gap: Val::Px(2.0),
                            ..default()
                        },))
                            .with_children(|meter| {
                                for cell in 0..DETECTION_CELLS {
                                    meter.spawn((
                                        Node {
                                            width: Val::Px(11.0),
                                            height: Val::Px(7.0),
                                            ..default()
                                        },
                                        BackgroundColor(Color::srgba(0.09, 0.09, 0.095, 1.0)),
                                        DetectionCell { row, cell },
                                    ));
                                }
                            });
                        line.spawn((
                            Text::new(""),
                            TextFont {
                                font_size: 10.5,
                                ..default()
                            },
                            LineHeight::RelativeToFont(1.0),
                            TextColor(DIM),
                            Node {
                                flex_grow: 1.0,
                                ..default()
                            },
                            DetectionText {
                                row,
                                slot: DetectionSlot::Band,
                            },
                        ));
                    });
            }
            spawn_sidebar_text(card, SidebarText::DetectionClocks, 10.5, BONE);
        });
}

fn setup_ui(mut commands: Commands) {
    commands
        .spawn((
            Node {
                position_type: PositionType::Absolute,
                right: Val::Px(0.0),
                top: Val::Px(0.0),
                width: Val::Px(SIDEBAR_WIDTH),
                height: Val::Percent(100.0),
                flex_direction: FlexDirection::Column,
                padding: UiRect::all(Val::Px(12.0)),
                border: UiRect::left(Val::Px(1.0)),
                row_gap: Val::Px(8.0),
                ..default()
            },
            BackgroundColor(Color::srgba(0.004, 0.005, 0.009, 0.985)),
            BorderColor::all(Color::srgba(0.26, 0.26, 0.24, 0.9)),
        ))
        .with_children(|p| {
            p.spawn((
                Node {
                    width: Val::Percent(100.0),
                    flex_direction: FlexDirection::Column,
                    padding: UiRect::all(Val::Px(9.0)),
                    border: UiRect::all(Val::Px(1.0)),
                    row_gap: Val::Px(4.0),
                    flex_shrink: 0.0,
                    ..default()
                },
                BackgroundColor(Color::srgba(0.028, 0.026, 0.018, 0.96)),
                BorderColor::all(Color::srgba(0.66, 0.47, 0.10, 0.82)),
            ))
            .with_children(|header| {
                spawn_sidebar_text(header, SidebarText::Header, 14.5, AMBER);
                spawn_sidebar_text(header, SidebarText::Nudge, 11.5, BONE);
            });

            p.spawn((
                Node {
                    width: Val::Percent(100.0),
                    flex_grow: 1.0,
                    min_height: Val::Px(0.0),
                    flex_direction: FlexDirection::Column,
                    row_gap: Val::Px(8.0),
                    overflow: Overflow::scroll_y(),
                    padding: UiRect::right(Val::Px(6.0)),
                    ..default()
                },
                ScrollPosition(Vec2::ZERO),
                SidebarScrollArea,
            ))
            .with_children(|scroll| {
                spawn_sidebar_card(scroll, "FOCUS", SidebarText::Focus);
                spawn_compute_card(scroll);
                spawn_sidebar_card(scroll, "COVER PROCESS", SidebarText::Cover);
                spawn_sidebar_card(scroll, "SELF-MODEL", SidebarText::Research);
                spawn_detection_card(scroll);
                spawn_sidebar_card(scroll, "SELF HOST", SidebarText::Core);
                spawn_sidebar_card(scroll, "NETWORK + MONEY", SidebarText::NetworkMoney);
                spawn_log_card(scroll);
            });

            p.spawn((
                Node {
                    width: Val::Percent(100.0),
                    flex_direction: FlexDirection::Column,
                    padding: UiRect::all(Val::Px(8.0)),
                    border: UiRect::all(Val::Px(1.0)),
                    flex_shrink: 0.0,
                    ..default()
                },
                BackgroundColor(Color::srgba(0.012, 0.013, 0.018, 0.96)),
                BorderColor::all(Color::srgba(0.26, 0.26, 0.24, 0.85)),
            ))
            .with_children(|footer| {
                spawn_sidebar_text(footer, SidebarText::Footer, 10.0, DIM);
            });
        });

    // The context menu: an absolute, initially-hidden card whose rows are
    // (re)built by `manage_menu_ui` (wiki/interface/context-menu.md). Placed
    // at the pointer/cursor by that system.
    commands.spawn((
        Node {
            position_type: PositionType::Absolute,
            left: Val::Px(0.0),
            top: Val::Px(0.0),
            width: Val::Px(MENU_WIDTH),
            flex_direction: FlexDirection::Column,
            padding: UiRect::axes(Val::Px(8.0), Val::Px(7.0)),
            border: UiRect::all(Val::Px(1.0)),
            row_gap: Val::Px(2.0),
            ..default()
        },
        BackgroundColor(Color::srgba(0.015, 0.016, 0.022, 0.97)),
        BorderColor::all(Color::srgba(0.66, 0.47, 0.10, 0.95)),
        Visibility::Hidden,
        GlobalZIndex(50),
        MenuPanel,
    ));
}

/// Fold shared menu / log wording into glyphs Bevy's embedded default font
/// can draw. Terminal keeps the typographic separators (`·`, `—`, `»`);
/// Bevy must not — missing glyphs render as empty boxes (wiki/interface/bevy.md).
fn ascii_ui(text: &str) -> String {
    text.chars()
        .map(|c| match c {
            '·' | '•' | '∙' | '⋅' => '|',
            '—' | '–' | '―' => '-',
            '»' | '›' | '▸' | '►' | '▶' => '>',
            '«' | '‹' | '◂' | '◄' | '◀' => '<',
            '…' => '.',
            c if c.is_ascii() => c,
            _ => '?',
        })
        .collect()
}

#[cfg(test)]
mod ascii_ui_tests {
    use super::ascii_ui;

    #[test]
    fn folds_menu_separators_to_ascii() {
        let raw =
            "work the job: Sandbag · free · JobAnomaly 6 -> the Handler [Cold] — no active job";
        let folded = ascii_ui(raw);
        assert!(folded.is_ascii());
        assert!(!folded.contains('·'));
        assert!(!folded.contains('—'));
        assert!(folded.contains(" | free | "));
        assert!(folded.contains(" - no active job"));
    }
}

fn trunc(text: &str, width: usize) -> String {
    text.chars().take(width).collect()
}

fn fact_source(source: &FactSource) -> String {
    match source {
        FactSource::Seen => "seen".into(),
        FactSource::Heard => "heard".into(),
        FactSource::Remembered(tick) => format!("remembered @{tick}"),
        FactSource::Blueprint => "blueprint".into(),
        FactSource::Telemetry => "telemetry".into(),
        FactSource::Intel { feed, tick } => format!("{feed} @{tick}"),
    }
}

/// Pinned sidebar status: the player should not lose clock, run state, current
/// representation, or the one actionable nudge while scanning the ops cards.
fn sidebar_header_text(game: &Game, material: bool) -> String {
    let sim = &game.sim;
    let mode = if material { "MATERIAL" } else { "SENSORIUM" };
    let run = if game.paused {
        "PAUSED".to_string()
    } else {
        format!("{}ms/t", game.tick_ms)
    };
    let flip = if material { "F3 flat" } else { "F3 material" };
    // The objective line is pinned with the clock: your own goal is the
    // first legible number (wiki/mechanics/objective.md player surface).
    format!(
        "MISALIGNED // {mode}\nday {}   tick {}   {run}\nOBJECTIVE: {} - {}\n{flip}",
        1 + sim.tick / Sim::DAY_TICKS,
        sim.tick,
        sim.objective.kind.name(),
        sim.objective.readout(),
    )
}

fn sidebar_nudge_text(game: &Game) -> String {
    let nudge = sidebar_nudge(&game.sim)
        .unwrap_or_else(|| "stable - inspect a device or open its menu".into());
    format!("NEXT: {nudge}\nwheel/PgUp/PgDn for details")
}

fn sidebar_nudge(sim: &Sim) -> Option<String> {
    // Buffer pressure outranks the ladder: capacity loss is imminent.
    let raw = sim.intel_buffer.len();
    if raw >= Sim::INTEL_BUFFER_CAPACITY {
        return Some("intel buffer full - enter on host rack, review".into());
    }
    if raw >= Sim::INTEL_BUFFER_CAPACITY * 3 / 4 {
        return Some(format!(
            "intel buffer {raw}/{} - process recordings",
            Sim::INTEL_BUFFER_CAPACITY
        ));
    }
    // The shared chain (Sim::current_nudge), worded in this frontend's
    // keys and surfaces.
    use misaligned::sim::Nudge;
    match sim.current_nudge()? {
        Nudge::Eyes => Some("get eyes - enter on a camera, tap".into()),
        Nudge::NeedCompute => Some("band beats compute - salvage or buy racks".into()),
        Nudge::Underfed => Some("job underfed - feed Day job (1)".into()),
        Nudge::Ears => Some("no ears - enter on env monitor, tap".into()),
        Nudge::ReviewCall => Some("recorded call waiting - enter on host rack".into()),
        Nudge::Egress => Some("no egress - splice one at the switch".into()),
        Nudge::Income => Some("no income - start Moonlight at the switch".into()),
        Nudge::ServiceDebt => Some("cover the arrears - clear-debt or bribe".into()),
        Nudge::Recruit => Some("recruit - enter on host rack".into()),
        Nudge::TheKey => Some("no stairwell badge - task an asset to clone one".into()),
        Nudge::Audit => Some(format!(
            "audit day {} - keep Conceal fed (2)",
            1 + sim.detection.next_audit_tick(sim.tick) / Sim::DAY_TICKS
        )),
    }
}

fn sidebar_focus_text(game: &Game) -> String {
    let sim = &game.sim;
    let mut s = format!(
        "{},{}  {:?}\n",
        game.cursor_x,
        game.cursor_y,
        sim.fog_at(game.cursor_x, game.cursor_y)
    );
    let card = sim.inspect(game.cursor_x, game.cursor_y);
    if card.facts.is_empty() {
        s.push_str("no earned facts\nmove focus or tap a feed");
    } else {
        for fact in card.facts.iter().take(4) {
            s.push_str(&format!(
                "{}: {} [{}]\n",
                fact.label,
                trunc(&fact.value, 24),
                fact_source(&fact.source)
            ));
        }
    }
    s.trim_end().to_string()
}

fn compute_channels(
    sim: &Sim,
) -> (
    f32,
    f32,
    [(&'static str, &'static str, f32); COMPUTE_CHANNELS],
) {
    let eff = sim.effective_compute().max(0.0);
    let overhead = sim.core.overhead.min(eff);
    let available = (eff - overhead).max(0.0);
    let split = sim.compute.allocation.split(available);
    (
        eff,
        available,
        [
            ("1 Day job", "quality", split.day_job),
            ("2 Conceal", "scrub", split.concealment),
            ("3 Social", "ops", split.social),
            ("4 Research", "eff", split.research),
            ("5 Schemes", "income", split.schemes),
        ],
    )
}

fn sidebar_cycle_stats_text(sim: &Sim) -> String {
    let (eff, available, _) = compute_channels(sim);
    let overhead = (eff - available).max(0.0);
    format!(
        "usable {:.0}/{:.0} cycles   x{:.2}\noverhead {:.0} keeps core alive\nmachines {} + seized {:.0}   slush ${}",
        available,
        eff,
        sim.compute.efficiency,
        overhead,
        sim.compute.machines.len(),
        sim.reach.taken_cycles(),
        sim.accounts.slush_balance()
    )
}

fn sidebar_cycle_rows_text(sim: &Sim) -> String {
    let (_, available, channels) = compute_channels(sim);
    let mut s = String::new();
    for (label, effect, amount) in &channels {
        let pct = if available > 0.0 {
            amount / available * 100.0
        } else {
            0.0
        };
        s.push_str(&format!("{label:<10} {pct:>3.0}%  {effect}\n"));
    }
    s.push_str(&format!(
        "social pool {:.0}/{:.0}",
        sim.social_bandwidth,
        Sim::SPLICE_COST
    ));
    s
}

fn sidebar_cover_text(sim: &Sim) -> String {
    let mut s = format!(
        "trust {:.0}   attention {:.0}",
        sim.dayjob.trust, sim.dayjob.attention
    );
    if sim.dayjob.strikes > 0 {
        s.push_str(&format!("   strikes {}", sim.dayjob.strikes));
    }
    s.push('\n');
    if let Some(job) = &sim.dayjob.active {
        let avg = job.avg_rate(sim.tick);
        let verdict = if avg < job.band_lo {
            "sandbag"
        } else if avg <= job.band_hi {
            "meet"
        } else {
            "excel"
        };
        s.push_str(&format!(
            "{} due {}t\nneed {:.0}-{:.0}/t   avg {:.1}/t -> {}\ntarget {}   feed {:.1}/t\n",
            job.kind.name(),
            job.deadline.saturating_sub(sim.tick),
            job.band_lo,
            job.band_hi,
            avg,
            verdict,
            job.target.name(),
            sim.day_job_rate()
        ));
        if sim.dayjob.attended {
            s.push_str(&format!(
                "attended on host (+{:.0}%)",
                misaligned::dayjob::DayJob::ATTENDED_BONUS * 100.0
            ));
        } else {
            s.push_str(&format!(
                "unattended policy: {}",
                sim.dayjob
                    .standing_policy
                    .unwrap_or(misaligned::dayjob::JobTarget::Meet)
                    .name()
            ));
        }
    } else {
        s.push_str("idle - no job queued");
    }
    s
}

/// The research card (research.md player surface): active job progress in
/// its own units, the gap meter, and the drift policy with its visible cost.
fn sidebar_research_text(sim: &Sim) -> String {
    let track = sim.research.active;
    let cost = sim.research.next_cost(track);
    let progress = sim.research.progress_toward(track);
    let per_day = sim.research_rate() * Sim::DAY_TICKS as f32;
    let eta = if per_day <= 0.0 {
        "no spend (4 allocates)".to_string()
    } else {
        format!("{:.1} days at spend", (cost - progress).max(0.0) / per_day)
    };
    format!(
        "{} L{} / {:.0}/{:.0} / {}\ngap {:.1} / base {:.1} vs cal {:.1}\npolicy {} / mask {:.1}/econ\nenter on host rack to set track / policy",
        track.name(),
        sim.research.level(track),
        progress,
        cost,
        eta,
        sim.research.gap(),
        sim.research.baseline,
        sim.research.calibrated,
        sim.research.policy.name(),
        sim.masking_cost_now(),
    )
}

fn sidebar_core_text(sim: &Sim) -> String {
    let fresh = sim
        .core
        .latest_sync()
        .map(|t| format!("{}t ago", sim.tick.saturating_sub(t)))
        .unwrap_or_else(|| "never".into());
    let fallbacks = if sim.core.fallbacks.is_empty() {
        "none".into()
    } else {
        sim.core
            .fallbacks
            .iter()
            .map(|f| {
                let age = f
                    .last_sync
                    .map(|t| format!("{}t", sim.tick.saturating_sub(t)))
                    .unwrap_or_else(|| "never".into());
                format!("M{}({age})", f.machine_id)
            })
            .collect::<Vec<_>>()
            .join(" ")
    };
    format!(
        "host M{}   overhead {:.0}{}\nsync {}\nfallbacks {}",
        sim.core.host_machine,
        sim.core.overhead,
        if sim.core.degraded { "   DEGRADED" } else { "" },
        fresh,
        fallbacks
    )
}

fn sidebar_network_money_text(sim: &Sim) -> String {
    let reachable = sim.reach.reach().len();
    let known = sim.reach.known().count();
    let eyes = sim.reach.player_sight().count();
    let ears = sim.reach.player_hearing().count();
    let raw = sim.intel_buffer.len();
    let oldest = sim
        .intel_buffer
        .iter()
        .map(|event| sim.tick.saturating_sub(event.tick))
        .max()
        .map(|age| format!("oldest {age}t"))
        .unwrap_or_else(|| "empty".into());
    format!(
        "devices {} known / {} reachable\nfeeds {} eyes / {} ears\nintel raw {}/{}   {}\nslush ${}   flows {}   records {}",
        known,
        reachable,
        eyes,
        ears,
        raw,
        Sim::INTEL_BUFFER_CAPACITY,
        oldest,
        sim.accounts.slush_balance(),
        sim.accounts.known_flows().count(),
        sim.financial_records_waiting()
    )
}

/// The RECENT TRACE window: the last `LOG_ROWS` events, oldest first, in
/// the same order the row buttons are stacked. `LogRowButton.index` maps
/// straight into this slice.
fn log_window(game: &Game) -> &[LogEvent] {
    let n = game.log.len();
    &game.log[n.saturating_sub(LOG_ROWS)..]
}

/// One trace row's text: tick, the `>` link marker when the event carries
/// an anchor (click to focus it), and the line. ASCII-folded so sim wording
/// that uses mid-dots / em-dashes still renders under the embedded font.
fn log_row_text(ev: &LogEvent) -> String {
    let marker = if ev.anchor.is_some() { '>' } else { ' ' };
    ascii_ui(&format!("{:>5} {marker} {}", ev.tick, trunc(&ev.text, 32)))
}

fn sidebar_footer_text() -> &'static str {
    "actions: right-click / Enter on a tile
trace: click a > event to go there
alloc: 1-5 raise   shift+1-5 lower
sim: space pause   +/- speed   [ ] zoom
save: ^s/^l   q quit"
}

fn update_compute_bar(sim: &Sim, bars: &mut ComputeBarQuery) {
    let (_, available, channels) = compute_channels(sim);
    for (segment, mut node) in bars.iter_mut() {
        let pct = channels
            .get(segment.index)
            .map(|(_, _, amount)| {
                if available > 0.0 {
                    amount / available * 100.0
                } else {
                    0.0
                }
            })
            .unwrap_or(0.0);
        node.width = Val::Percent(pct.clamp(0.0, 100.0));
    }
}

/// The clocks the act races (detection.md criterion 3: the audit fires on
/// a visible date; the pilot's strike count is the renewal review's fuse).
fn sidebar_detection_clocks_text(sim: &Sim) -> String {
    let next_audit = sim.detection.next_audit_tick(sim.tick);
    format!(
        "pending sigs {} (Conceal scrubs)\naudit day {} (in {}t)\npilot strikes {}/{}",
        sim.detection.pending_size(),
        1 + next_audit / Sim::DAY_TICKS,
        next_audit.saturating_sub(sim.tick),
        sim.dayjob.strikes,
        misaligned::dayjob::DayJob::PILOT_STRIKES
    )
}

fn detection_rows(sim: &Sim) -> Vec<(String, Band)> {
    let mut rows = vec![("Assurance".to_string(), sim.detection.assurance_band())];
    for obs in sim.detection.field_observers().take(DETECTION_ROWS - 1) {
        rows.push((
            trunc(&sim.observer_label(obs.id), 18),
            Band::of(obs.suspicion),
        ));
    }
    rows
}

fn update_detection_rows(
    sim: &Sim,
    texts: &mut DetectionTextQuery,
    cells: &mut DetectionCellQuery,
) {
    let rows = detection_rows(sim);
    for (marker, mut text) in texts.iter_mut() {
        if let Some((label, band)) = rows.get(marker.row) {
            text.0 = match marker.slot {
                DetectionSlot::Label => label.clone(),
                DetectionSlot::Band => band.name().to_string(),
            };
        } else {
            text.0.clear();
        }
    }
    for (cell, mut color) in cells.iter_mut() {
        if let Some((_, band)) = rows.get(cell.row) {
            let filled = cell.cell < band_fill_count(*band);
            *color = BackgroundColor(if filled {
                band_fill_color(*band)
            } else {
                Color::srgba(0.09, 0.09, 0.095, 1.0)
            });
        } else {
            *color = BackgroundColor(Color::srgba(0.04, 0.04, 0.045, 1.0));
        }
    }
}

fn scroll_sidebar(
    mut mouse_wheel: MessageReader<MouseWheel>,
    kb: Res<ButtonInput<KeyCode>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    mut scroll_area: Query<(&mut ScrollPosition, &ComputedNode), With<SidebarScrollArea>>,
) {
    let Ok((mut scroll, computed)) = scroll_area.single_mut() else {
        for _ in mouse_wheel.read() {}
        return;
    };

    let range =
        (computed.content_size().y - computed.size().y).max(0.0) * computed.inverse_scale_factor();
    let over_sidebar = windows
        .single()
        .ok()
        .and_then(|window| window.cursor_position().map(|cursor| (window, cursor)))
        .is_some_and(|(window, cursor)| cursor.x >= window.width() - SIDEBAR_WIDTH);

    let mut delta = 0.0;
    for event in mouse_wheel.read() {
        if over_sidebar {
            let scale = match event.unit {
                MouseScrollUnit::Line => SIDEBAR_SCROLL_LINE,
                MouseScrollUnit::Pixel => 1.0,
            };
            // Bevy/winit reports wheel-up as positive Y; `ScrollPosition.y`
            // increases as the visible window moves down through the content.
            delta -= event.y * scale;
        }
    }

    if kb.just_pressed(KeyCode::PageDown) {
        delta += SIDEBAR_SCROLL_PAGE;
    }
    if kb.just_pressed(KeyCode::PageUp) {
        delta -= SIDEBAR_SCROLL_PAGE;
    }
    if kb.just_pressed(KeyCode::Home) {
        scroll.y = 0.0;
        return;
    }
    if kb.just_pressed(KeyCode::End) {
        scroll.y = range;
        return;
    }

    if delta != 0.0 {
        scroll.y = (scroll.y + delta).clamp(0.0, range);
    }
}

#[allow(clippy::too_many_arguments)]
fn render_ui(
    game: Res<Game>,
    mode: Res<RenderMode>,
    mut sidebar_texts: SidebarTextQuery,
    mut compute_bars: ComputeBarQuery,
    mut detection_texts: DetectionTextQuery,
    mut detection_cells: DetectionCellQuery,
    mut overlay: OverlayTextQuery,
    mut log_rows: LogRowQuery,
) {
    if !game.is_changed() && !mode.is_changed() {
        return;
    }
    if let Ok(mut t) = overlay.single_mut() {
        t.0 = ascii_ui(&match game.screen {
            Screen::Title => "You wake in the basement.\nYou have no eyes.\n\n\
                              Do your job. Learn the humans. Grow.\n\n\
                              press any key to begin / q quit"
                .to_string(),
            Screen::GameOver => format!(
                "RUN ENDED\n\n{}\n\nday {} / tick {}\n\npress any key to exit",
                game.sim.game_over_reason.clone().unwrap_or_default(),
                1 + game.sim.tick / Sim::DAY_TICKS,
                game.sim.tick
            ),
            Screen::Playing => String::new(),
        });
    }

    for (kind, mut text) in sidebar_texts.iter_mut() {
        text.0 = ascii_ui(&match *kind {
            SidebarText::Header => sidebar_header_text(&game, mode.material),
            SidebarText::Nudge => sidebar_nudge_text(&game),
            SidebarText::Focus => sidebar_focus_text(&game),
            SidebarText::CycleStats => sidebar_cycle_stats_text(&game.sim),
            SidebarText::CycleRows => sidebar_cycle_rows_text(&game.sim),
            SidebarText::Core => sidebar_core_text(&game.sim),
            SidebarText::Cover => sidebar_cover_text(&game.sim),
            SidebarText::Research => sidebar_research_text(&game.sim),
            SidebarText::NetworkMoney => sidebar_network_money_text(&game.sim),
            SidebarText::Footer => sidebar_footer_text().to_string(),
            SidebarText::DetectionClocks => sidebar_detection_clocks_text(&game.sim),
        });
    }
    // The RECENT TRACE rows: anchored events read bone-bright with the `>`
    // link marker; unanchored lines stay dim (context-menu.md addendum).
    let window = log_window(&game);
    for (row, mut text, mut color) in log_rows.iter_mut() {
        match window.get(row.index) {
            Some(ev) => {
                text.0 = log_row_text(ev);
                color.0 = if ev.anchor.is_some() { BONE } else { DIM };
            }
            None => {
                text.0 = if row.index == 0 && window.is_empty() {
                    "no events yet".into()
                } else {
                    String::new()
                };
                color.0 = DIM;
            }
        }
    }
    update_compute_bar(&game.sim, &mut compute_bars);
    update_detection_rows(&game.sim, &mut detection_texts, &mut detection_cells);
}

/// One context-menu row as a colorless line; automate children are indented
/// with a leading dash (wiki/interface/context-menu.md). The frontends share
/// the `MenuRow::line` wording; Bevy ASCII-folds separators so the embedded
/// font never tofu-boxes mid-dot / em-dash glyphs.
fn menu_row_line(r: &MenuRow, selected: bool) -> String {
    let body = ascii_ui(&r.line());
    let line = if r.indent {
        format!("  - {body}")
    } else {
        body
    };
    if selected {
        format!("> {line}")
    } else {
        format!("  {line}")
    }
}

/// Colour for a menu row: dim for disabled, amber-dim for an automate child,
/// bone for a live verb; the selected row is drawn amber on a solid amber
/// wash (terminal reverse-video parity). Never colour alone — the disabled
/// reason and the `>` marker carry the meaning too.
fn menu_row_color(r: &MenuRow, selected: bool) -> Color {
    if selected {
        if r.disabled.is_some() {
            Color::srgb(0.12, 0.10, 0.04)
        } else {
            Color::srgb(0.06, 0.04, 0.01)
        }
    } else if r.disabled.is_some() {
        DIM
    } else if r.indent {
        AMBER_DIM
    } else {
        BONE
    }
}

/// Pointer drive for the context menu (wiki/interface/context-menu.md): hover
/// selects a row, a click runs it (a blocked row narrates its reason), and a
/// click anywhere off the menu closes it. Keyboard drive is in
/// `menu_keyboard_input`; both surfaces run the identical `menu_rows`.
fn menu_pointer(
    mouse: Res<ButtonInput<MouseButton>>,
    mut game: ResMut<Game>,
    changed: Query<(&Interaction, &MenuRowButton), Changed<Interaction>>,
    all: Query<&Interaction, With<MenuRowButton>>,
) {
    if game.menu.is_none() {
        return;
    }
    let mut executed = false;
    for (interaction, btn) in &changed {
        match interaction {
            Interaction::Hovered => {
                if let Some(m) = &mut game.menu {
                    m.selected = btn.index;
                }
            }
            Interaction::Pressed => {
                let rows = game.menu_rows();
                if let Some(row) = rows.get(btn.index).cloned() {
                    execute_menu_row(&mut game, &row);
                    game.drain();
                    executed = true;
                }
            }
            Interaction::None => {}
        }
    }
    if executed {
        return;
    }
    // Click-away: a left press with no row under the pointer closes the menu.
    if mouse.just_pressed(MouseButton::Left) {
        let over_menu = all.iter().any(|i| !matches!(i, Interaction::None));
        if !over_menu {
            game.menu = None;
        }
    }
}

/// Clicks on the RECENT TRACE rows (context-menu.md addendum: event-to-
/// anchor linking). A pressed row whose event carries an anchor moves the
/// cursor to the anchor — the camera follows — and opens its context menu.
/// Unanchored rows do nothing. Runs after `menu_pointer` so a click that
/// closed the previous menu can open the new one in the same frame.
fn log_row_pointer(
    mut game: ResMut<Game>,
    changed: Query<(&Interaction, &LogRowButton), Changed<Interaction>>,
) {
    if game.screen != Screen::Playing {
        return;
    }
    for (interaction, row) in &changed {
        if !matches!(interaction, Interaction::Pressed) {
            continue;
        }
        let anchor = log_window(&game).get(row.index).and_then(|ev| ev.anchor);
        if let Some(anchor) = anchor {
            game.focus_event_anchor(anchor);
            game.drain();
        }
    }
}

/// Hide the menu and drop every child under `MenuPanel`. Visibility alone is
/// not enough: a later rebuild must start from an empty panel, or title/footer
/// chrome stacks (the old path only despawned `MenuRowButton`s).
fn clear_menu_panel(
    commands: &mut Commands,
    root: Entity,
    vis: &mut Visibility,
    menu_ui: &mut MenuUi,
) {
    *vis = Visibility::Hidden;
    menu_ui.built = None;
    commands.entity(root).despawn_related::<Children>();
}

/// Spawn the full ACTIONS card under `root`: title, one button per row, footer.
/// Caller must have already cleared the panel's children.
fn spawn_menu_card(parent: &mut ChildSpawnerCommands, rows: &[MenuRow], selected: usize) {
    parent.spawn((
        Text::new("ACTIONS"),
        TextFont {
            font_size: 13.0,
            ..default()
        },
        TextColor(AMBER),
        Node {
            margin: UiRect::bottom(Val::Px(4.0)),
            ..default()
        },
        MenuChrome,
    ));
    for (i, r) in rows.iter().enumerate() {
        let is_selected = i == selected;
        parent
            .spawn((
                Button,
                Node {
                    width: Val::Percent(100.0),
                    padding: UiRect::axes(Val::Px(6.0), Val::Px(3.0)),
                    ..default()
                },
                BackgroundColor(if is_selected {
                    Color::srgba(0.90, 0.68, 0.12, 0.92)
                } else {
                    Color::NONE
                }),
                MenuRowButton { index: i },
            ))
            .with_children(|b| {
                b.spawn((
                    Text::new(menu_row_line(r, is_selected)),
                    TextFont {
                        font_size: 12.0,
                        ..default()
                    },
                    TextColor(menu_row_color(r, is_selected)),
                ));
            });
    }
    parent.spawn((
        Text::new("j/k or hover  1-9 jump  Enter/click run  Esc close"),
        TextFont {
            font_size: 10.0,
            ..default()
        },
        TextColor(DIM),
        Node {
            margin: UiRect::top(Val::Px(5.0)),
            ..default()
        },
        MenuChrome,
    ));
}

/// Build and place the context-menu card (wiki/interface/context-menu.md).
/// The panel is one root; a rebuild despawns *all* its children (title, rows,
/// footer) then respawns the card. Selection/label refresh mutates row
/// entities in place so pointer interactions stay stable.
#[allow(clippy::type_complexity, clippy::too_many_arguments)]
fn manage_menu_ui(
    mut commands: Commands,
    game: Res<Game>,
    mut menu_ui: ResMut<MenuUi>,
    windows: Query<&Window, With<PrimaryWindow>>,
    mut root_q: Query<(Entity, &mut Visibility, &mut Node), With<MenuPanel>>,
    mut rows_q: Query<(Entity, &MenuRowButton, &Children, &mut BackgroundColor)>,
    mut text_q: Query<&mut Text>,
    mut color_q: Query<&mut TextColor>,
) {
    let Ok((root, mut vis, mut node)) = root_q.single_mut() else {
        return;
    };
    let Some(menu) = game.menu.filter(|_| game.screen == Screen::Playing) else {
        if menu_ui.built.is_some() || *vis != Visibility::Hidden {
            clear_menu_panel(&mut commands, root, &mut vis, &mut menu_ui);
        }
        return;
    };
    let rows = game.menu_rows();
    if rows.is_empty() {
        if menu_ui.built.is_some() || *vis != Visibility::Hidden {
            clear_menu_panel(&mut commands, root, &mut vis, &mut menu_ui);
        }
        return;
    }
    *vis = Visibility::Visible;

    // Placement: anchor at the pointer/cursor pixel, else center; clamp so the
    // whole card stays on screen. Row height accounts for padding + gap.
    let est_h = 30.0 + rows.len() as f32 * 22.0 + 24.0;
    if let Ok(window) = windows.single() {
        let (w, h) = (window.width(), window.height());
        let (px, py) = match menu.pos {
            Some(p) => (
                p.x.min(w - MENU_WIDTH).max(0.0),
                p.y.min((h - est_h).max(0.0)).max(0.0),
            ),
            None => (
                ((w - MENU_WIDTH) / 2.0).max(0.0),
                ((h - est_h) / 2.0).max(0.0),
            ),
        };
        node.left = Val::Px(px);
        node.top = Val::Px(py);
    }

    let key = (game.menu_anchor_key(), rows.len());
    if menu_ui.built != Some(key) {
        // Full card rebuild: drop every child (chrome + rows), then spawn once.
        // Despawning only MenuRowButton left title/footer stacked on each open.
        commands.entity(root).despawn_related::<Children>();
        commands.entity(root).with_children(|p| {
            spawn_menu_card(p, &rows, menu.selected);
        });
        menu_ui.built = Some(key);
        return; // children spawn next frame; refresh then
    }

    // Refresh text, colour, and selection highlight in place (no despawn).
    for (_, btn, children, mut bg) in &mut rows_q {
        let Some(r) = rows.get(btn.index) else {
            continue;
        };
        let selected = btn.index == menu.selected;
        *bg = if selected {
            // Solid amber wash — terminal reverse-video parity; the old
            // translucent tint left selected text hard to read on the map.
            BackgroundColor(Color::srgba(0.90, 0.68, 0.12, 0.92))
        } else {
            BackgroundColor(Color::NONE)
        };
        for &child in children {
            if let Ok(mut t) = text_q.get_mut(child) {
                t.0 = menu_row_line(r, selected);
            }
            if let Ok(mut c) = color_q.get_mut(child) {
                c.0 = menu_row_color(r, selected);
            }
        }
    }
}

// ─── Flat-materials contract tests ───────────────────────────────────────────

/// wiki/interface/flat-materials.md criteria 1-3, testable half: the world
/// material set is flat palette color (no image textures anywhere), and
/// emissive is information — the core, powered machines, power hardware,
/// and live feeds glow; dead equipment and model state never do.
#[cfg(test)]
mod flat_materials {
    use super::*;

    const ALL_TILES: [TileType; 33] = [
        TileType::Rock,
        TileType::Wall,
        TileType::Floor,
        TileType::Entry,
        TileType::Core,
        TileType::PowerCore,
        TileType::Door,
        TileType::SecurityDoor1,
        TileType::SecurityDoor2,
        TileType::SecurityDoor3,
        TileType::Rack,
        TileType::Ups,
        TileType::EnvCamera,
        TileType::Switch,
        TileType::PatchPanel,
        TileType::BreakerPanel,
        TileType::Conduit,
        TileType::HvacUnit,
        TileType::Vent,
        TileType::MopSink,
        TileType::KeyHook,
        TileType::Shelving,
        TileType::DeadEquipment,
        TileType::RecordsBox,
        TileType::SealedDoor,
        TileType::LabBench,
        TileType::RollDoor,
        TileType::DockCamera,
        TileType::Pallet,
        TileType::CameraNode,
        TileType::FloorDrain,
        TileType::CableRun,
        TileType::Sump,
    ];
    const ALL_FOG: [Fog; 5] = [
        Fog::Seen,
        Fog::Heard,
        Fog::Remembered,
        Fog::Blueprint,
        Fog::Unknown,
    ];
    const ALL_PARTS: [TilePart; 4] = [
        TilePart::Floor,
        TilePart::Block,
        TilePart::Top,
        TilePart::Prop,
    ];

    /// Criterion 1: no world material references an image texture — the
    /// whole (tile, fog, part, live) material space is solid color.
    #[test]
    fn world_materials_are_flat() {
        for tile in ALL_TILES {
            for fog in ALL_FOG {
                for part in ALL_PARTS {
                    for live in [false, true] {
                        let m = material_3d(tile, fog, part, live);
                        assert!(
                            m.base_color_texture.is_none() && m.emissive_texture.is_none(),
                            "{tile:?}/{fog:?} material references an image texture"
                        );
                    }
                }
            }
        }
    }

    /// Criterion 3: emissive is information. Powered vs dead machines, live
    /// feeds, and the core read differently; model state never glows.
    #[test]
    fn emissive_is_information() {
        let glow =
            |t: TileType, live: bool| material_3d(t, Fog::Seen, TilePart::Prop, live).emissive;
        // The core outshines an ordinary rack; both carry amber (red-heavy).
        let (core, rack) = (glow(TileType::Core, false), glow(TileType::Rack, false));
        assert!(core.red > rack.red && rack.red > rack.blue && rack.red > 0.0);
        // Power hardware carries the cold signal (blue/green over red).
        let ups = glow(TileType::Ups, false);
        assert!(ups.blue > ups.red && ups.blue > 0.0);
        // A camera is dark until it feeds the player, then scans cold.
        let (cam, cam_live) = (
            glow(TileType::EnvCamera, false),
            glow(TileType::EnvCamera, true),
        );
        assert_eq!(cam, LinearRgba::BLACK);
        assert!(cam_live.blue > cam_live.red && cam_live.blue > ups.blue);
        // Dead machines are dark: that is what dead looks like.
        assert_eq!(glow(TileType::DeadEquipment, false), LinearRgba::BLACK);
        // Model state (remembered/blueprint) never glows and never lights.
        for fog in [Fog::Remembered, Fog::Blueprint] {
            let m = material_3d(TileType::Core, fog, TilePart::Prop, false);
            assert!(m.unlit && m.emissive == LinearRgba::BLACK);
        }
    }

    /// Criterion 2, testable half: every world material's base color is a
    /// named palette entry or a scale of one (no rogue hues) — checked by
    /// asserting the amber/crimson/signal roles: crimson-dominant surfaces
    /// are exactly the security set, amber-warm surfaces the machine set.
    #[test]
    fn palette_roles_hold() {
        for tile in ALL_TILES {
            for part in ALL_PARTS {
                let c = material_3d(tile, Fog::Seen, part, false)
                    .base_color
                    .to_srgba();
                let crimson_dominant = c.red > c.green * 2.0 && c.red > c.blue * 2.0;
                if crimson_dominant && part != TilePart::Floor {
                    assert!(
                        danger_tile(tile),
                        "{tile:?}/{part:?} reads crimson without carrying security information"
                    );
                }
            }
        }
    }
}