concinnity-dev 0.19.119

//! The editor's per-frame drive. Implements the run loop's `FrameHook` seam: each
//! frame it hit-tests the editor HUD's controls against the live input, mutates
//! the working authored entry list, persists on SAVE, drives the world's cursor /
//! freeze state, and re-anchors + recolors the HUD. This is the whole editor: it
//! lives in the editor crate (never linked by the shipped runtime), so no editor
//! code is compiled into a shipped game.
//!
//! The top bar (`hud.rs`) owns SAVE and the Templates dropdown. The Assets button
//! opens the assets panel (`assets_panel.rs`): a search field over every asset of the
//! expanded world, grouped by origin into one collapsible tree (`asset_tree.rs`),
//! and a "+" that opens a typed autocomplete of the addable types. Clicking a row
//! (or picking a type from the "+" picker) opens the add / edit form in its own
//! floating panel (`form_panel.rs`). A row the build generates has no world.jsonl
//! line of its own: its form is seeded from what the expansion produced, and only
//! confirming appends the line -- which then overrides the expansion. The search
//! field and the form's name heading are real `TextInput` assets edited by the
//! engine's text-input system; the hook reads them back. All three panels
//! (Assets, edit form, Preview) are floating: holding their title bars drags them
//! (the hook owns each origin, clamped so a panel can never leave the screen).
//!
//! Cursor control follows the simulation transport (`editor/sim.rs`): while
//! Stopped or Paused the editor holds the cursor and the world sits frozen
//! (`MenuOverride(Some(true))`); Play hands the cursor to the running world
//! (`Some(false)`); Escape pauses and takes it back. Stop restores the authored
//! state through the same preview rebuild every committed edit takes. F1 hides /
//! shows the whole HUD.
//!
//! An edit shows in the preview the frame after it is committed, and SAVE only
//! persists: `apply_world_swap` writes the change into the running world where
//! the running world can express it (`editor/live/`), and otherwise recompiles
//! and swaps a fresh world under the live render backend, which is transplanted
//! across as a `PendingBackend` so the OS window is never recreated. SAVE
//! re-serializes the entry list to world.jsonl and stops there: the compiled
//! blobs are refreshed by an explicit build, not by editing.

use concinnity_core::components::FrameInput;
use concinnity_core::ecs::{
    CursorShape, DesiredCursor, FlyCam, HiddenAssets, HudLayers, MenuOverride, ViewOverrides,
    World, WorldLines,
};
use concinnity_engine::app::runtime::Runtime;
use concinnity_engine::live_edit::PendingBackend;
use concinnity_engine::shutdown::ShutdownToken;

use super::asset_handle::AssetHandle;
use super::behavior;
use super::entry_list::{EntryId, EntryList};
use super::history::History;
use super::hud;
use super::live;
use super::notify;
use super::outlines;
use super::overrides;
use super::panels::asset_list::ListRow;
use super::panels::asset_tree::TreeRow;
use super::panels::console::ConsoleSink;
use super::panels::form::FormField;
use super::panels::health::HealthState;
use super::panels::lighting;
use super::panels::registry::{self, PanelKey, PerPanel};
use super::selection::Selection;
use super::session_store;
use super::sim;
use super::view_menu;
use super::viewport::cursor;
use super::viewport::framing;
use super::viewport::gizmo;
use super::viewport::resize;
use super::viewport::snap;
use super::widget;
use super::worlds;
use crate::debug::hot_reload::WorldPathHandle;
use crate::editor::text_area::clipboard::InternalClipboard;
use crate::frame_hook::FrameHook;
use edit::assets_state::AssetsState;
use edit::behavior_state::BehaviorState;
use edit::console_state::ConsoleState;
use edit::content_state::ContentState;
use edit::import_state::ImportState;
use edit::lighting_state::LightingState;
use edit::map_state::MapState;
use edit::palette_state::PaletteState;
use edit::shaders_state::ShadersState;
use edit::shape_state::ShapeState;
use edit::story_state::StoryState;
use edit::templates_state::TemplatesState;
use edit::variables_state::VariablesState;
use edit::worlds_state::WorldsState;
use form_state::{FormState, FormTarget, FormTemplate};

// Draw layer for the top bar: far above the floating panels' layers (which are a
// small 1..=6 rank), so the bar always sits on top even under a dragged panel.
const TOP_BAR_LAYER: i32 = 1_000;

// An active title-bar drag: the grabbed panel and the cursor's offset from its
// origin at the press, so the panel follows without snapping to the cursor.
#[derive(Debug, Clone, Copy)]
struct Drag {
    key: PanelKey,
    grab: [f32; 2],
}

pub(crate) struct EditorHook {
    // Path to the world.jsonl the edits are written back to.
    world_path: String,
    // The same path, shared with the hot-reload driver that watches it.
    world_path_handle: WorldPathHandle,
    // The authored entry list (names live here, unlike the compiled blob), each
    // entry beside the session key the editor addresses it by. Edits mutate
    // this; SAVE serializes it back to `world_path`.
    entries: EntryList,
    // Undo/redo stacks over `entries`. `baseline` mirrors `entries` as of the
    // last committed edit (or undo/redo), so when `mark_changed` runs after a
    // mutation it still holds the pre-edit list -- the undo snapshot. `saved`
    // mirrors the on-disk state, so a history jump can recompute `dirty`.
    history: History,
    baseline: EntryList,
    saved: EntryList,
    // Whether `entries` has changes not yet written to disk.
    dirty: bool,
    // The simulation transport (Play / Pause / Step / Stop). Starts Stopped:
    // the editor owns the cursor at launch so the HUD is immediately usable.
    sim: sim::SimControl,
    // Whether the whole HUD is shown (F1 toggle). Starts shown.
    hud_visible: bool,
    // Whether the world-origin axes draw in the viewport (Preview panel row).
    // Starts on: the axes are the viewport's orientation reference.
    axes_visible: bool,
    // Set whenever the authored entries change (add / edit / delete / template);
    // consumed by `apply_world_swap` to bring the live preview world back in
    // line with them. SAVE does not set this -- the preview is already current.
    rebuild_preview: bool,
    // Set alongside it when only a full rebuild will do: the running world
    // holds state no authored diff describes (a simulation that ran, a story
    // source re-read from disk), so the live-apply path must not claim it.
    rebuild_required: bool,
    // The entry list the live preview world was built from, and the template
    // baselines that build's expansion merged authored patches over. An edit is
    // applied to the running world by diffing against these; a rebuild re-seeds
    // both. The baselines are seeded on demand (the first edit that could be
    // applied live expands the list once to find them), and an edit cannot be
    // applied live until they are.
    world_entries: EntryList,
    world_shadows: Option<live::ShadowBaselines>,
    templates: TemplatesState,
    lighting: LightingState,
    shape: ShapeState,
    story: StoryState,
    // The Shaders list and the Shader source panel it opens.
    shaders: ShadersState,
    // What a text area copies to when the window reaches no system clipboard.
    text_clipboard: InternalClipboard,
    // The session's monotonic clock, for timing presses into double-clicks.
    clock: std::time::Instant,
    import: ImportState,
    console: ConsoleState,
    // The shared log sink, and whether a worker is mid-build (the /cook guard).
    console_sink: ConsoleSink,
    console_build_running: std::sync::Arc<std::sync::atomic::AtomicBool>,
    // The toast queue (`editor/notify.rs`): result sites push, the per-frame
    // drive (`hook/drive/notify.rs`) draws the stack. The latch skips the
    // overlay's hide pass while nothing is live, so an idle queue costs one
    // lock check a frame.
    notifier: notify::Notifier,
    toasts_hidden: bool,
    behavior: BehaviorState,
    // The Map panel: the world's places and the moves between them
    // (`editor/map/`). It reads the entry list and writes nothing, so its
    // state is where the canvas is looked at.
    map: MapState,
    variables: VariablesState,
    // Live-debug values fed by the runtime's execution trace (`hook/drive/trace.rs`).
    trace_seen: u64,
    live_vars: Vec<(String, String, String)>,
    live_locals: Vec<(String, String, String)>,
    // Ctrl state sampled from this frame's input, for the panel presses that
    // resolve without direct input access (a Ctrl+click on a chart card
    // toggles its breakpoint).
    ctrl_held: bool,
    // Editor-session hide / lock sets, by handle, like the selection (an id
    // drifts across preview rebuilds, and a label follows its entry). Hidden
    // assets skip rendering (via the published `HiddenAssets` resource);
    // locked ones are skipped by viewport picking. Neither touches the
    // authored entries.
    hidden_assets: std::collections::BTreeSet<AssetHandle>,
    locked_assets: std::collections::BTreeSet<AssetHandle>,
    // An active isolate (`hook/hide.rs`): the assets kept visible, hiding
    // everything else. Composes with (and never mutates) `hidden_assets`.
    isolate: Option<std::collections::BTreeSet<AssetHandle>>,
    // Shift state sampled from this frame's input, for the panel presses that
    // resolve without direct input access (the Assets tree's additive select).
    shift_held: bool,
    // Viewport sampled from this frame's input, for the panel presses that
    // resolve without direct input access (framing a palette pick).
    viewport: [f32; 2],
    // Window chrome floating over the top of the frame, sampled from the same
    // input. The start screen's docked sidebar starts its content below it so
    // the OS window buttons never land on a control.
    top_inset: f32,
    assets: AssetsState,
    content: ContentState,
    // The right-click "Create here" menu (`hook/drive/create_menu.rs`), if open.
    create_menu: Option<drive::create_menu::CreateMenu>,
    // The confirmation dialog (`hook/drive/modal.rs`), if open. Screen-modal:
    // while open every press and wheel is swallowed before any other routing,
    // and only one of its buttons closes it.
    modal: Option<crate::editor::modal::Dialog>,
    worlds: WorldsState,
    // Whether the session's world has never been named: `+` starts one, the
    // whole editor comes up on it, and the first SAVE asks what to call it
    // before anything reaches disk.
    untitled: bool,
    // The start screen (`hook/worlds_start.rs`): a session that named no world
    // on the command line opens on the Worlds panel alone, which owns the
    // window and previews the picked world behind itself. Set at construction
    // and cleared for good the first time a world is opened.
    start_mode: bool,
    // The world the start screen picked before it had a window to show it in
    // (`hook/worlds_start.rs`): held until the screen itself is up and drawn,
    // then staged like any other preview. `start_drawn` counts the frames the
    // screen has been laid out for, which is what "up" means here.
    start_preview: Option<String>,
    start_drawn: u32,
    // The start screen's attract camera (`hook/drive/cinematic.rs`): the shot
    // cycle running over the previewed world, the clock it advances on, and the
    // pose that world's own camera held before the cycle took it -- put back
    // the moment the screen hands the session a world.
    cinematic: Option<worlds::cinematic::Cinematic>,
    // Whether the running cycle has taken its first frame.
    cinematic_ticking: bool,
    cinematic_restore: Option<framing::CameraPose>,
    palette: PaletteState,
    // The Health panel's sampler. Ticked every frame whether or not the panel is
    // shown, so its rates cover a continuous window.
    health: HealthState,
    // The Display menu (`hook/drive/view_menu.rs`): open state, the viewport
    // view mode, the show flags, and the editor-side billboard-icons toggle.
    display_menu_open: bool,
    view_mode: view_menu::ViewMode,
    show_flags: view_menu::ShowFlags,
    // What the last tick published, to tell an outside change from its own.
    published_view: ViewOverrides,
    show_billboards: bool,
    // The Display menu's always-on extent-outline categories (selection
    // outlines regardless; `hook/drive/outline.rs`).
    extent_show: outlines::CategorySet,
    // The runtime's shutdown token, handed over before the loop starts. The
    // menu bar's Quit cancels it.
    shutdown: Option<ShutdownToken>,
    // The add / edit form (`hook/editing.rs`).
    form: FormState,
    // Template baselines for every template-derived asset, derived from the
    // working entries. Invalidated by every edit, rebuilt on demand.
    template_index: Option<overrides::TemplateIndex>,
    // The viewport selection set (`editor/selection.rs`), held as
    // `AssetHandle`s and re-resolved against the entry list every frame
    // (`hook/handles.rs`): a live-preview rebuild resets the interner, so a
    // stored AssetId would drift onto another asset, and a name is content the
    // user renames. `pick_last` is the transient repeat-click cycle;
    // `marquee` an in-flight box select.
    selection: Selection,
    pick_last: Option<pick::PickLast>,
    marquee: Option<drag::marquee::MarqueeDrag>,
    // An in-flight Alt+drag tumble around the selection
    // (`hook/drive/orbit.rs`), if any.
    orbit: Option<drive::orbit::OrbitDrag>,
    // The gizmo's edit mode (T/R/S keys) and an active drag
    // (`hook/drag/gizmo.rs`), if any.
    gizmo_mode: gizmo::GizmoMode,
    gizmo_drag: Option<drag::gizmo::GizmoDrag>,
    // Grid / angle snapping for gizmo drags (Preview panel rows + /snap).
    snap: snap::SnapSettings,
    // Whether a drag-out placement orients the drop to the struck surface's
    // face normal (Preview panel row). Session state, off by default.
    align_to_surface: bool,
    // The edit-mode fly camera (`hook/fly.rs`).
    fly: bool,
    // An in-flight framing / bookmark camera glide (`hook/drive/glide.rs`).
    glide: Option<drive::glide::CameraGlide>,
    // Saved camera poses (`hook/bookmarks.rs`), loaded from the per-project
    // session store and persisted on save.
    bookmarks: [Option<framing::CameraPose>; session_store::BOOKMARK_SLOTS],
    // Whether each floating panel is open. A panel whose showing follows from
    // other state (the edit form, the Template detail, the Shader source)
    // answers `Panel::is_open` from that state instead and never reads its flag.
    open: PerPanel<bool>,
    // The floating panels' dragged origins; `None` means the panel still sits at
    // its default anchor. Always clamped fully on screen before use.
    positions: PerPanel<Option<[f32; 2]>>,
    // The user's per-panel size overrides; `None` means the panel is at its
    // content-derived default. Only ever grows a panel past that default (see
    // `effective_size`), and only the resizable panels are set.
    sizes: PerPanel<Option<[f32; 2]>>,
    // The title-bar drag in progress, if any.
    drag: Option<Drag>,
    // The edge / corner resize in progress, if any.
    resize: Option<resize::Resize>,
    // The floating panels back-to-front: the last entry is the frontmost (drawn on
    // top + first to receive clicks). Dragging or clicking a panel moves it to the
    // end. Its position drives the per-frame `HudLayers` publish so overlapping
    // panels occlude cleanly instead of merging.
    panel_order: Vec<PanelKey>,
    // The preview rebuild blocks the frame loop, so when the last one measured
    // slow its card goes up ahead of the stall: `rebuild_op` holds the card,
    // `rebuild_countdown` the frames left before the rebuild runs (the card
    // must be drawn and presented first), and `last_rebuild_secs` the honest
    // measure that gates the whole affordance.
    rebuild_op: Option<notify::OpHandle>,
    rebuild_countdown: u8,
    last_rebuild_secs: f32,
}

// Owned per-tick data backing a `PanelView` (computed from the cooked tree + the
// live search field, then borrowed for both hit-testing and layout).
struct PanelData {
    rows: Vec<TreeRow>,
    // The hide / lock sets and the open row menu, projected onto the names the
    // tree rows are drawn under.
    hidden: std::collections::BTreeSet<String>,
    locked: std::collections::BTreeSet<String>,
    row_menu: Option<String>,
    picker_options: Option<Vec<crate::editor::panels::assets_panel::PickerOption>>,
    form_title: String,
    form_overrides: Option<FormOverridesData>,
    form_extras: Vec<crate::editor::panels::form_extras::ExtraRow>,
    form_blocked: Option<String>,
}

// Owned per-tick override state backing a `form_panel::OverridesView`.
struct FormOverridesData {
    marks: Vec<overrides::FieldOrigin>,
    count: usize,
    field_menu: Option<(usize, Vec<String>)>,
    entity_menu: Option<Vec<String>>,
}

// Owned per-tick data backing a `TemplateView` (the open template's title,
// description, and grouped asset rows).
#[derive(Default)]
struct TemplateDetailData {
    title: String,
    description: String,
    rows: Vec<ListRow>,
}

// Owned per-tick data backing a `LightingView` (the row list and the
// per-binding fields derived from the current entries).
struct LightingData {
    rows: Vec<lighting::Row>,
    fields: Vec<Option<FormField>>,
}

// The panels open at launch: the Preview panel alone.
fn initial_open() -> PerPanel<bool> {
    let mut open = PerPanel::splat(false);
    open[PanelKey::Preview] = true;
    open
}

// Move a scroll offset one row toward the wheel direction, clamped to `max`.
fn scroll_step(cur: usize, delta: f32, max: usize) -> usize {
    if delta > 0.0 {
        (cur + 1).min(max)
    } else {
        cur.saturating_sub(1)
    }
}

// The physical control slot showing logical form field `j` under scroll offset
// `scroll`, or `None` when the field is outside the visible window of `window`
// rows. The panel's control pool is slot-indexed, so seeding / reading a field
// goes through its slot.
fn visible_slot(j: usize, scroll: usize, window: usize) -> Option<usize> {
    (j >= scroll && j < scroll + window).then(|| j - scroll)
}

// The first line of a validation error, clipped to fit the panel's status line.
fn short_status(e: &str) -> String {
    let line = e.lines().next().unwrap_or(e);
    let clipped: String = line.chars().take(44).collect();
    if clipped.len() < line.len() {
        format!("{clipped}...")
    } else {
        clipped
    }
}

// The `$id` an entry declares, if any. An anonymous entry has none; the name
// the world knows it by is its handle (`EditorHook::handle_name`).
fn declared_id(e: &serde_json::Value) -> Option<&str> {
    concinnity_cook::authoring::world::entry_id(e)
}
fn entry_type(e: &serde_json::Value) -> Option<&str> {
    e.get("type").and_then(|v| v.as_str())
}

// The ids of the working entries whose type is one of `types`, or of every
// entry when `types` is empty (the reference options a field targeting those
// types can pick from). An anonymous entry cannot be referenced, so it is not
// offered.
fn names_of_types(entries: &[serde_json::Value], types: &[&str]) -> Vec<String> {
    entries
        .iter()
        .filter(|e| types.is_empty() || entry_type(e).is_some_and(|t| types.contains(&t)))
        .filter_map(|e| declared_id(e).map(String::from))
        .collect()
}

// The three role groups: the authored-entry mutations behind each panel, the
// per-frame drives of the live furniture, and the pointer gestures. Everything
// else here is the shared spine they run on.
mod drag;
mod drive;
mod edit;

mod behavior_asset;
mod behavior_keys;
mod bookmarks;
mod browse;
mod camera_pose;
mod cook_worker;
mod drop_floor;
mod duplicate;
mod editing;
mod edits;
mod fly;
mod form_extras;
mod form_state;
mod handles;
mod hide;
mod layout;
// The per-panel `Panel` impls, reachable by the registry (`editor/panels/registry.rs`).
pub(super) mod panels;
mod pick;
mod routing;
mod sim_control;
mod worlds_start;

// The tests, mirroring the layout above: `tests/edit/console_tests.rs`
// covers `edit/console.rs`.
#[cfg(test)]
mod tests;

impl EditorHook {
    pub(crate) fn new(world_path: String, entries: impl Into<EntryList>) -> Self {
        let bookmarks = session_store::default_path()
            .and_then(|path| {
                session_store::load(&path)
                    .worlds
                    .get(&session_store::world_key(&world_path))
                    .map(|w| w.bookmarks)
            })
            .unwrap_or_default();
        // The three mirrors clone the keys along with the values, so a snapshot
        // restored by undo addresses the same entries the selection does.
        let entries = entries.into();
        Self {
            world_path_handle: WorldPathHandle::new(world_path.as_str()),
            world_path,
            history: History::default(),
            baseline: entries.clone(),
            saved: entries.clone(),
            world_entries: entries.clone(),
            entries,
            dirty: false,
            sim: sim::SimControl::default(),
            hud_visible: true,
            axes_visible: true,
            rebuild_preview: false,
            rebuild_required: false,
            world_shadows: None,
            templates: TemplatesState::default(),
            lighting: LightingState::default(),
            shape: ShapeState::default(),
            story: StoryState::default(),
            shaders: ShadersState::default(),
            text_clipboard: InternalClipboard::default(),
            clock: std::time::Instant::now(),
            import: ImportState::default(),
            console: ConsoleState::default(),
            console_sink: ConsoleSink::default(),
            console_build_running: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
            notifier: notify::Notifier::default(),
            toasts_hidden: true,
            behavior: BehaviorState::default(),
            map: MapState::default(),
            variables: VariablesState::default(),
            trace_seen: 0,
            live_vars: Vec::new(),
            live_locals: Vec::new(),
            ctrl_held: false,
            hidden_assets: std::collections::BTreeSet::new(),
            locked_assets: std::collections::BTreeSet::new(),
            isolate: None,
            shift_held: false,
            viewport: [0.0, 0.0],
            top_inset: 0.0,
            assets: AssetsState::default(),
            content: ContentState::default(),
            create_menu: None,
            modal: None,
            worlds: WorldsState::default(),
            untitled: false,
            start_mode: false,
            start_preview: None,
            start_drawn: 0,
            cinematic: None,
            cinematic_ticking: false,
            cinematic_restore: None,
            palette: PaletteState::default(),
            health: HealthState::new(),
            display_menu_open: false,
            view_mode: view_menu::ViewMode::default(),
            show_flags: view_menu::ShowFlags::default(),
            published_view: ViewOverrides::default(),
            show_billboards: true,
            extent_show: outlines::CategorySet::default(),
            shutdown: None,
            form: FormState::default(),
            template_index: None,
            selection: Selection::default(),
            pick_last: None,
            marquee: None,
            orbit: None,
            gizmo_mode: gizmo::GizmoMode::default(),
            gizmo_drag: None,
            snap: snap::SnapSettings::default(),
            align_to_surface: false,
            fly: false,
            glide: None,
            bookmarks,
            open: initial_open(),
            positions: PerPanel::splat(None),
            sizes: PerPanel::splat(None),
            drag: None,
            resize: None,
            // Back-to-front, matching the injected draw order (registry order:
            // the Template detail panel frontmost, over the Templates list it
            // spawns from).
            panel_order: PanelKey::ALL.to_vec(),
            rebuild_op: None,
            rebuild_countdown: 0,
            last_rebuild_secs: 0.0,
        }
    }
}

impl EditorHook {
    // Replace the standalone sink defaulted by `new` with the shared one the
    // tracing mirror was installed on (see `run_editor`).
    pub(crate) fn with_console_sink(mut self, sink: ConsoleSink) -> Self {
        self.console_sink = sink;
        self
    }

    // Open on the start screen: a session started without a world named on the
    // command line picks one there before it edits anything (see `run_editor`).
    // `picked` is the project's most recent world, preselected so the user
    // lands on their last project rather than on a void -- but it is not
    // compiled yet. The window comes up on the listing alone and the pick is
    // previewed from there, behind the loading cover, so a world that takes
    // seconds to compile does not hold the window closed for them.
    pub(crate) fn with_start_screen(mut self, picked: Option<String>) -> Self {
        self.start_mode = true;
        self.open[PanelKey::Worlds] = true;
        self.worlds.selected = picked.clone();
        self.start_preview = picked;
        self.refresh_worlds();
        self
    }

    // A clone of the toast queue handle, for the sibling hooks (the debug
    // server's hot-reload passes report through it).
    pub(crate) fn notifier(&self) -> notify::Notifier {
        self.notifier.clone()
    }

    // A clone of the world-path handle, for the hot-reload driver's watcher.
    pub(crate) fn world_path_handle(&self) -> WorldPathHandle {
        self.world_path_handle.clone()
    }

    // Whether any editor text control holds keyboard focus this frame: the
    // Assets panel's search field (or the type picker typing into it), an open
    // edit form (its name / arg inputs always own focus while it shows), or a
    // focused Lighting / Story / Import / Console field. Undo/redo shortcuts
    // stand down while typing.
    // Read the palette's filter off its field. Mirrored onto the hook because
    // the data a press and a draw resolve against is built without world access.
    fn sample_behavior_filter(&mut self, world: &World) {
        let typed = match self.behavior.picking {
            true => widget::field_text(world, behavior::panel::FILTER_INPUT),
            false => String::new(),
        };
        if typed != self.behavior.filter {
            // A narrowed palette is a different list, so the highlight starts
            // again at its best answer rather than keeping a place that may no
            // longer be in it.
            self.behavior.pick = 0;
            self.behavior.pick_scroll = 0;
            self.behavior.filter = typed;
        }
    }

    // The frontmost open floating panel, if any: the keyboard target for
    // per-frame editing keys and the arbiter for shortcuts a panel claims.
    fn frontmost_open_panel(&self) -> Option<PanelKey> {
        self.panel_order
            .iter()
            .rev()
            .copied()
            .find(|&k| self.panel_shown(k))
    }

    fn text_focus_active(&self) -> bool {
        self.non_console_text_focus() || self.console.focus
    }

    // The same, excluding the console's own command line: the backtick toggle
    // must keep working while the console is being typed into, but stand down
    // while any other field is (a backtick there is just a character).
    fn non_console_text_focus(&self) -> bool {
        self.assets.search_focus
            || self.content.search_focus
            || self.assets.picker_open
            || self.form.selected_type.is_some()
            || self.lighting.focus.is_some()
            || self.story_typing()
            || self.shader_typing()
            || self.import.focus
            || self.behavior.focus
            || self.behavior.name_focus
            || self.behavior.picking
            || self.variables.name_focus
            || self.variables.value_focus
            || self.prompting()
            || self.open[PanelKey::Palette]
    }
}

impl FrameHook for EditorHook {
    fn attach_shutdown(&mut self, shutdown: ShutdownToken) {
        self.shutdown = Some(shutdown);
    }

    fn tick(&mut self, world: &mut World) {
        // Before anything this frame reads the panel state: a choice made in
        // the macOS menu bar landed between frames and is applied here, so the
        // rest of the frame sees one settled state.
        self.drive_app_menu(world);
        // Bring the Assets tree up to date before anything reads it, so this
        // frame's hit test and draw agree on the rows.
        self.refresh_tree_if_needed();
        // The Shader panels take in reload outcomes, on-disk changes, and
        // edits to the declared Shaders before anything draws them.
        self.drive_shader_source();
        self.shaders
            .retry_missing(self.clock.elapsed().as_secs_f64());
        if self.open[PanelKey::Shaders] {
            self.shader_rows();
        }
        // Accumulate the Health panel's per-frame counters and, on its throttled
        // boundary, resample. Unconditional: the rates measure a continuous
        // window, so gating this on the panel being open would make the first
        // window after opening report a partial one.
        self.health.sample(world);
        // Seed Transforms onto the billboard-backed entities before any of
        // this frame's picking or gizmo work resolves them.
        self.seed_billboard_transforms(world);
        // Sampled before anything routes, so this frame's hit tests and draw
        // narrow the palette by the same query.
        self.sample_behavior_filter(world);
        self.sample_palette_query(world);
        self.sample_shape_rows(world);
        let input = world.query::<FrameInput>().last().cloned();
        if let Some(input) = &input {
            // Sampled for the panel presses that resolve without direct input
            // access (the Assets tree's additive select, the chart's
            // Ctrl+click breakpoint toggle).
            self.shift_held = input.shift;
            self.ctrl_held = input.ctrl;
            self.viewport = input.viewport;
            self.top_inset = input.top_inset;
            // Typing into a batching panel's focused field marks its
            // unapplied-edit state (the heading's "*"). Frontmost-gated,
            // because only the frontmost panel's field owns the keyboard.
            if input.typed_any() {
                match self.frontmost_open_panel() {
                    Some(PanelKey::Edit) => self.form.touched = true,
                    Some(PanelKey::Lighting) if self.lighting.focus.is_some() => {
                        self.lighting.touched = true;
                    }
                    _ => {}
                }
            }
            // Escape hands the cursor back to the editor: a running world
            // pauses mid-state, the fly camera exits, and the create menu
            // dismisses.
            if input.escape {
                self.sim.pause();
                self.fly = false;
                self.glide = None;
                self.orbit = None;
                self.create_menu = None;
                self.display_menu_open = false;
                self.close_palette();
            }
            // The fly camera integrates before any routing: while it is on
            // the cursor is captured, so no click or HUD press can arrive.
            // An in-flight glide owns the camera instead; deliberate fly
            // input cancels it (see `drive_glide`).
            if self.glide.is_some() {
                self.drive_glide(input, world);
            } else {
                self.drive_fly(input, world);
            }
            // F1 (an edge pulse) toggles the whole HUD. The start screen
            // stands outside it: hiding the only panel on screen would leave
            // the session with nothing to click.
            if input.hud_toggle && !self.start_mode {
                self.hud_visible = !self.hud_visible;
            }
            let vp = input.viewport;
            if self.hud_visible && vp[0] > 0.0 {
                // The start screen owns the whole window while it is up: its
                // panel is the only thing to route to, and the editor's
                // shortcuts, menus, and overlays stand down until a world is
                // open (`hook/worlds_start.rs`).
                if self.start_mode {
                    self.drive_start_input(input, vp, world);
                } else {
                    self.drive_session_input(input, vp, world);
                }
            }
        }

        // The pick the screen opened on, once the screen itself has been drawn:
        // the compile it costs is spent behind a window that is already up.
        self.drive_start_preview();
        // The start screen's attract camera, after the frame's routing: a click
        // that picked another world has already restarted the cycle, so the
        // pose written here frames the world the sidebar is now previewing.
        self.drive_cinematic(world);

        // Drive the world's cursor / freeze state from the transport: Stopped /
        // Paused (`Some(true)`) free the cursor and freeze the world; Playing
        // (`Some(false)`) runs it -- as does the one frame a queued Step takes.
        // The fly flag layers on top: navigation input + cursor capture stay
        // live while the frozen world is flown through.
        self.drive_sim(world);
        // Exchange execution-trace state with the behavior system: publish the
        // request while a live-debug panel is open, ingest what last frame's
        // simulated tick reported (pulses, live values, breakpoint hits).
        self.drive_trace(world);
        world.insert_resource(FlyCam(self.fly && !self.sim.playing()));
        // Publish the editor-session hidden set (manual hides composed with an
        // active isolate, resolved to this world's ids) so the renderer
        // collapses those objects this frame.
        world.insert_resource(HiddenAssets(self.effective_hidden_ids()));
        // Publish the viewport view mode + show flags for this frame's draw.
        let view = view_menu::resolve_view(
            self.published_view,
            world.resource::<ViewOverrides>().copied(),
            ViewOverrides {
                mode: self.view_mode,
                show: self.show_flags,
            },
        );
        self.view_mode = view.mode;
        self.show_flags = view.show;
        self.published_view = view;
        world.insert_resource(view);

        // Re-anchor + recolor the top bar, then lay out (or hide) the panels.
        hud::apply_layout(world, self.hud_state());
        let vp = input.as_ref().map(|i| i.viewport).unwrap_or([0.0, 0.0]);
        let mouse = input
            .as_ref()
            .map(|i| [i.mouse_x, i.mouse_y])
            .unwrap_or([0.0, 0.0]);
        // The panels lay out only once the HUD is shown and a real viewport exists
        // (frame 0 keeps the injected-hidden placeholders).
        let shown = self.hud_visible && vp[0] > 0.0;
        // Publish the world-space editor lines (origin axes + extent outlines)
        // for the renderer's line pass, refilling last frame's buffer.
        // Republished every frame (the renderer expands whatever it finds), and
        // empty while everything is toggled off, the HUD is hidden, or the
        // Lines show flag is cleared (which would mask the pass anyway; the
        // empty buffer also skips the CPU generation and ribbon expansion).
        let mut lines = world
            .remove_resource::<WorldLines>()
            .map(|l| l.0)
            .unwrap_or_default();
        lines.clear();
        if self.show_flags.contains(view_menu::ShowFlags::LINES) && !self.start_mode {
            self.push_axis_lines(world, &mut lines);
            self.push_extent_lines(world, vp, &mut lines);
        }
        world.insert_resource(WorldLines(lines));
        // Drive the editor's in-engine cursor. It shows while the editor owns the
        // pointer (edit mode); a captured camera (play / fly) owns the pointer
        // instead, so the sprite hides and no stray arrow lingers over the frozen
        // pointer. Its shape becomes a resize cursor over a resizable panel edge.
        let owns_cursor = vp[0] > 0.0 && !self.sim.playing() && !self.fly;
        cursor::set_visible(world, owns_cursor);
        let shape = if !owns_cursor || !shown {
            CursorShape::Default
        } else if let Some(r) = &self.resize {
            // Keep the resize cursor for the whole drag, even if the pointer
            // drifts off the edge as the panel grows.
            resize::cursor_shape(r.edges)
        } else {
            self.hover_cursor(vp, mouse)
        };
        world.insert_resource(DesiredCursor(shape));
        // Publish the panels' draw layers (focus stack) so the renderer occludes
        // overlaps by focus this frame. Empty while the HUD is hidden, so the
        // renderer skips the overlay sort entirely.
        if shown {
            self.publish_layers(world);
        } else {
            world.insert_resource(HudLayers::default());
        }
        // Lay out every open panel (hiding keeps its state, so toggling back
        // restores the same view). Compound gates live on each panel's
        // `is_open` -- e.g. the edit form shows only while the assets UI is on.
        for p in registry::all() {
            if shown && self.panel_shown(p.key()) {
                let o = self.origin(p.key(), vp);
                p.draw(self, world, o, mouse);
            } else {
                p.hide(world);
            }
        }
        // The billboards sit at the bottom of the editor overlays; the
        // selection rings ride the picked assets' projected bounds above
        // them, under the panels (their ids take the default draw layer);
        // the gizmo and the marquee rect draw over both.
        // The viewport overlays belong to a session editing a world: the start
        // screen shows the previewed world plainly, with nothing over it but
        // the panel, its dialog, and its toasts.
        let overlays = shown && !self.start_mode;
        // The start screen's shot fade sits under all of them, covering the
        // previewed world alone; the loading cover stands over the same area
        // instead while the world behind it is being compiled.
        self.drive_cinematic_draw(world, vp, shown);
        self.drive_loading_draw(world, shown);
        if shown && self.start_mode {
            self.start_drawn = self.start_drawn.saturating_add(1);
        }
        self.drive_billboards(world, vp, overlays && self.show_billboards);
        self.drive_highlight(world, vp, overlays);
        self.drive_gizmo_draw(world, vp, overlays);
        self.drive_marquee_draw(world, overlays);
        self.drive_create_menu_draw(world, overlays, mouse);
        self.drive_display_menu_draw(world, vp, overlays, mouse);
        self.drive_toasts(world, vp, shown, mouse);
        self.drive_modal_draw(world, vp, shown, mouse);
    }

    // Bring the live preview world back in line with the in-memory entries, so
    // any authored change (add / edit / delete / template apply) shows
    // immediately without touching disk (SAVE owns persistence). Run once per
    // frame by the run loop right after `tick`, whenever an edit flagged
    // `rebuild_preview`.
    //
    // An edit that only changed component data is written straight into the
    // running world (`try_live_apply`), which is what most editing is: the
    // renderer draws that data every frame, so it is already the shortest path
    // from the edit to the picture. Everything else recompiles and swaps a
    // fresh world under the running backend, below.
    //
    // The recompiled world is built FIRST, in a throwaway runtime; only once that
    // succeeds is the backend transplanted out of the live world. So a rebuild
    // failure leaves the live world -- and its window -- fully intact; the next
    // edit retries. The backend is never dropped on an error path.
    fn apply_world_swap(&mut self, runtime: &mut Runtime) {
        if !self.refresh_preview(runtime.world_mut()) {
            return;
        }
        // Whatever the user waits behind needs a drawn-and-presented frame
        // before the stall, so the rebuild waits out a countdown (tick draws on
        // the frames between). A session announces itself with a card once a
        // rebuild has measured slow; the start screen sets its own countdown
        // when it stages a preview, since the loading cover is already up and
        // no card belongs over it. Fast session rebuilds (the common case) show
        // nothing and run immediately.
        if !self.start_mode
            && self.last_rebuild_secs > SLOW_REBUILD_SECS
            && self.rebuild_op.is_none()
        {
            self.rebuild_op = Some(self.notifier.begin_op("Rebuilding preview"));
            self.rebuild_countdown = 2;
        }
        if self.rebuild_countdown > 0 {
            self.rebuild_countdown -= 1;
            return;
        }
        self.rebuild_preview = false;
        self.rebuild_required = false;
        let started = std::time::Instant::now();
        self.swap_preview_world(runtime);
        self.last_rebuild_secs = started.elapsed().as_secs_f32();
        if let Some(op) = self.rebuild_op.take() {
            op.finish();
        }
    }
}

// A preview rebuild slower than this earns the announce card above.
const SLOW_REBUILD_SECS: f32 = 0.15;

impl EditorHook {
    // Bring the live preview back in line with the entries, writing the edit
    // into the running world where that expresses it. `true` when a rebuild is
    // still owed, which is what `apply_world_swap` goes on to do.
    fn refresh_preview(&mut self, world: &mut World) -> bool {
        if !self.rebuild_preview {
            return false;
        }
        if self.try_live_apply(world) {
            self.rebuild_preview = false;
            return false;
        }
        // The rebuild discards a running simulation's state, so the transport
        // honestly drops to Stopped. An edit written into the running world
        // leaves the simulation alone, which is why this belongs here rather
        // than with the edit that recorded it.
        self.sim.on_edit();
        true
    }

    // Write an edit that only changed component data into the running world,
    // instead of rebuilding it. `true` when the whole edit landed; `false`
    // leaves the world untouched for the rebuild to handle.
    //
    // The diff is taken against the entries the running world was built from,
    // not the pre-edit list, so a burst of edits that each declined still
    // applies as one once one of them can.
    fn try_live_apply(&mut self, world: &mut World) -> bool {
        if self.rebuild_required {
            return false;
        }
        if !live::same_assets(&self.world_entries, &self.entries) || !self.seed_world_shadows() {
            return false;
        }
        let shadows = self.world_shadows.as_ref().expect("seeded above");
        let Some(changes) = live::args_changes(&self.world_entries, &self.entries, shadows) else {
            return false;
        };
        let Some(plan) = live::plan(world, &self.entries, &changes) else {
            return false;
        };
        tracing::debug!("editor: {} edit(s) applied live, no rebuild", plan.len());
        live::commit(world, plan);
        self.world_entries = self.entries.clone();
        true
    }

    // The template baselines for the running world, expanding its entry list
    // once to find them if the session has not needed them yet. Every edit that
    // could move a baseline rebuilds, and a rebuild re-seeds these, so the one
    // expansion holds for the rest of the session. `false` when the list does
    // not expand, which sends the edit to the rebuild that will report why.
    fn seed_world_shadows(&mut self) -> bool {
        if self.world_shadows.is_some() {
            return true;
        }
        let Ok(loaded) = Self::cook_entries(&self.world_entries) else {
            return false;
        };
        self.world_shadows = Some(
            loaded
                .shadowed
                .into_iter()
                .map(|s| (s.name, s.args))
                .collect(),
        );
        true
    }

    // The rebuild + backend transplant itself (see `apply_world_swap` for the
    // timing shell around it).
    fn swap_preview_world(&mut self, runtime: &mut Runtime) {
        let (world, shadows) = match self.build_preview_world() {
            Ok(built) => built,
            Err(e) => {
                tracing::error!("editor: live preview rebuild failed, keeping current world: {e}");
                match self.start_mode {
                    true => self.preview_failed(&e.to_string()),
                    false => self.notifier.error_with(
                        &format!("Preview rebuild failed: {e}"),
                        notify::Action::OpenConsole,
                    ),
                }
                return;
            }
        };
        self.world_entries = self.entries.clone();
        self.world_shadows = Some(shadows);
        let mut staged = Runtime::new();
        staged.load_world(world);
        // Carry the editor's typed text (an open form's name + fields, the combo
        // filter) across the fresh HUD injection so it is not blanked.
        let fields = Self::field_snapshot(runtime.world());
        super::inject::editor_hud(staged.world_mut());
        Self::restore_fields(staged.world_mut(), &fields);
        staged
            .world_mut()
            .insert_resource(MenuOverride(Some(!self.sim.playing())));

        let Some(backend) = concinnity_engine::live_edit::take_render_backend(runtime.world_mut())
        else {
            return;
        };
        staged.world_mut().insert_resource(PendingBackend(backend));
        let new_world = std::mem::replace(staged.world_mut(), World::new());
        runtime.load_world(new_world);
        if let Err(e) = runtime.start() {
            tracing::error!("editor: live preview start failed: {e:?}");
            self.notifier.error_with(
                &format!("Preview start failed: {e:?}"),
                notify::Action::OpenConsole,
            );
        }
    }
}