// Action dispatch policy: `DefaultPolicy` decides user actions as pure
 // snapshot → command mappings. The camera actions (zoom, pan, viewport
 // jumps, overview) live here, moved verbatim from the compositor's
 // execute_action arms; an action this policy doesn't claim returns an empty
 // vec and the mechanism's remaining legacy arms handle it.
 
 use crate::api::{Action, ActionCtx, Command, OverlaySide, Policy, WindowId};
 use crate::camera::{self, Camera};
 use crate::focus;
 use crate::pan;
 use crate::tiling::TilingMode;
 
 pub struct DefaultPolicy;
 
 impl Policy for DefaultPolicy {
     fn action(&mut self, ctx: &ActionCtx, action: Action, arg: Option<&str>) -> Vec<Command> {
         match action {
             Action::Toggle => toggle(ctx, arg),
             Action::ZoomIn | Action::ZoomOut | Action::ZoomReset => zoom(ctx, action),
             Action::PanLeft | Action::PanRight | Action::PanUp | Action::PanDown => {
                 pan_step(ctx, action)
             }
             Action::Overview => toggle_overview(ctx),
             // The one-way halves of Overview, for a key per direction
             // instead of one key that toggles. Asking for the mode you are
             // already in is a no-op: the empty list falls through to the
             // mechanism's legacy match, which has no arm for either action,
             // so nothing happens — which is the intent, not an oversight.
             Action::OverviewEnter => {
                 if ctx.overview { Vec::new() } else { enter_overview(ctx) }
             }
             Action::OverviewExit => {
                 if ctx.overview { exit_overview_keyed(ctx) } else { Vec::new() }
             }
             Action::Close => close(ctx),
             Action::Minimize => minimize(ctx),
             Action::FocusNext | Action::FocusPrev => focus_cycle(ctx, action),
             Action::FocusUp | Action::FocusDown | Action::FocusLeft | Action::FocusRight => {
                 focus_directional(ctx, action)
             }
             Action::MoveWindowLeft
             | Action::MoveWindowRight
             | Action::MoveWindowUp
             | Action::MoveWindowDown => move_window(ctx, action),
             Action::Fullscreen => fullscreen(ctx),
             Action::ModeNext => mode_next(ctx),
             Action::ModeNextShared => mode_next_shared(ctx),
             Action::OverlayLeft => {
                 vec![Command::SetOverlayPosition(OverlaySide::Left), Command::Relayout]
             }
             Action::OverlayRight => {
                 vec![Command::SetOverlayPosition(OverlaySide::Right), Command::Relayout]
             }
             Action::VolumeUp
             | Action::VolumeDown
             | Action::VolumeMute
             | Action::MicMute
             | Action::BrightnessUp
             | Action::BrightnessDown => {
                 vec![Command::Spawn(arg.unwrap_or(media_command(action)).to_string())]
             }
             _ => Vec::new(),
         }
     }
 }
 
 fn window(ctx: &ActionCtx, id: WindowId) -> Option<&crate::api::ActionWindow> {
     ctx.windows.iter().find(|w| w.id == id)
 }
 
 /// Keyed zooms pivot about the viewport center.
 fn zoom(ctx: &ActionCtx, action: Action) -> Vec<Command> {
     let dir = match action {
         Action::ZoomIn => 1.0,
         Action::ZoomOut => -1.0,
         _ => 0.0,
     };
     let new_zoom = camera::keyed_zoom(ctx.camera.zoom, dir);
     let cam = camera::zoom_about_anchor(
         ctx.camera,
         ctx.viewport_w / 2.0,
         ctx.viewport_h / 2.0,
         new_zoom,
     );
     vec![
         Command::SetCamera { camera: cam, overview: Some(camera::is_overview(cam.zoom)), animate: false },
         Command::Relayout,
     ]
 }
 
 /// Keyed pans move cell-by-cell and ease to an aligned viewport. Stepping
 /// from the pending target (not the current offset) lets rapid presses queue
 /// one cell apiece.
 fn pan_step(ctx: &ActionCtx, action: Action) -> Vec<Command> {
     let (dx, dy) = match action {
         Action::PanLeft => (-1.0, 0.0),
         Action::PanRight => (1.0, 0.0),
         Action::PanUp => (0.0, -1.0),
         _ => (0.0, 1.0),
     };
     let mut x = None;
     let mut y = None;
     if dx != 0.0 {
         let base = ctx.pan_target_x.unwrap_or(ctx.camera.pan_x);
         x = Some(pan::aligned_step(base, ctx.grid_period_x, dx));
     }
     if dy != 0.0 {
         let base = ctx.pan_target_y.unwrap_or(ctx.camera.pan_y);
         y = Some(pan::aligned_step(base, ctx.grid_period_y, dy));
     }
     vec![Command::PanTo { x, y }]
 }
 
 /// Toggle overview: whichever of `enter_overview` / `exit_overview` the
 /// current mode calls for.
 fn toggle_overview(ctx: &ActionCtx) -> Vec<Command> {
     if ctx.overview {
         exit_overview(ctx)
     } else {
         enter_overview(ctx)
     }
 }
 
 /// Leave overview, re-centering at zoom 1 — on the hovered window (focusing
 /// it) when there is one, else on the virtual point under the cursor — in
 /// the cursor's output.
 ///
 /// This is the cursor-driven exit: the toggle, and what the keyed exit falls
 /// back to when nothing is focused. Callers have already established that
 /// the mechanism is in overview; this assumes it.
 fn exit_overview(ctx: &ActionCtx) -> Vec<Command> {
     let out = ctx.cursor_viewport;
     let (ow, oh) = (out.width as f64, out.height as f64);
     if !ctx.has_cursor {
         // No seat: fall back to the origin at zoom 1.
         return vec![
             Command::StopPanAnimation,
             Command::SetCamera {
                 camera: Camera { pan_x: 0.0, pan_y: 0.0, zoom: 1.0 },
                 overview: Some(false),
                 animate: true,
             },
             Command::RefreshCamera,
         ];
     }
     if let Some(win) = ctx.hovered.and_then(|id| window(ctx, id)) {
         return exit_onto_window(ctx, win);
     }
     let vx = ctx.camera.pan_x + (ctx.cursor_x - out.x as f64) / ctx.camera.zoom;
     let vy = ctx.camera.pan_y + (ctx.cursor_y - out.y as f64) / ctx.camera.zoom;
     let cam = camera::center_on(vx, vy, ow, oh, 1.0);
     vec![
         Command::StopPanAnimation,
         Command::SetCamera { camera: cam, overview: Some(false), animate: true },
         Command::RefreshCamera,
     ]
 }
 
 /// The keyed exit (`Action::OverviewExit`). A key press carries no cursor
 /// position, so the focused window — not whatever the pointer was left
 /// hovering — is what says where you meant to land. Falls back to the
 /// cursor-driven exit when nothing is focused.
 fn exit_overview_keyed(ctx: &ActionCtx) -> Vec<Command> {
     match ctx.focused.and_then(|id| window(ctx, id)) {
         Some(win) => exit_onto_window(ctx, win),
         None => exit_overview(ctx),
     }
 }
 
 /// Leave overview centered on one window at zoom 1 — the shared tail of both
 /// exits, which differ only in how they choose the window. Focusing it is
 /// redundant on the keyed path (it is already focused) and the point of the
 /// hovered one; it is idempotent either way.
 fn exit_onto_window(ctx: &ActionCtx, win: &crate::api::ActionWindow) -> Vec<Command> {
     let out = ctx.cursor_viewport;
     let cam = camera::center_on(
         win.x + win.w / 2.0,
         win.y + win.h / 2.0,
         out.width as f64,
         out.height as f64,
         1.0,
     );
     vec![
         Command::Focus(win.id),
         Command::StopPanAnimation,
         Command::SetCamera { camera: cam, overview: Some(false), animate: true },
         Command::RefreshCamera,
     ]
 }
 
 /// Enter overview, fitting the bounding box of all eligible windows into the
 /// viewport. An empty desktop yields no commands at all — see the note on
 /// `Action::OverviewEnter` about what the mechanism does with that.
 fn enter_overview(ctx: &ActionCtx) -> Vec<Command> {
     let mut bounds: Option<(f64, f64, f64, f64)> = None;
     for w in ctx.windows.iter().filter(|w| w.overview_eligible) {
         let (min_x, min_y, max_x, max_y) =
             bounds.unwrap_or((f64::MAX, f64::MAX, f64::MIN, f64::MIN));
         bounds = Some((
             min_x.min(w.x),
             min_y.min(w.y),
             max_x.max(w.x + w.w),
             max_y.max(w.y + w.h),
         ));
     }
     let Some((min_x, min_y, max_x, max_y)) = bounds else { return Vec::new() };
     let cam = camera::fit_bounds(min_x, min_y, max_x, max_y, ctx.viewport_w, ctx.viewport_h);
     // Overview by fiat even when the fit lands at zoom 1 (a desktop
     // smaller than the screen): the next Overview must exit, not re-enter.
     vec![
         Command::SetCamera { camera: cam, overview: Some(true), animate: true },
         Command::RefreshCamera,
     ]
 }
 
 /// Do two virtual-space boxes share any area? Strictly — adjacent tiled
 /// windows merely touch (they are separated by the gap and two insets, and
 /// by nothing at all when both are zero), and touching is not occupying.
 fn boxes_overlap(ax: f64, ay: f64, aw: f64, ah: f64, b: &crate::api::ActionWindow) -> bool {
     const EPS: f64 = 0.5;
     ax < b.x + b.w - EPS && b.x < ax + aw - EPS && ay < b.y + b.h - EPS && b.y < ay + ah - EPS
 }
 
 /// Step the focused window one grid period in the direction of `action`.
 ///
 /// One period is what separates adjacent cells, so a tiled window that
 /// started cell-aligned stays cell-aligned and no snapping is needed. The
 /// same step serves a floating window: it has no cell, but a period is the
 /// one distance the grid already defines, and stepping the two kinds of
 /// window by the same amount keeps the four keys feeling like one motion.
 ///
 /// The two kinds differ only in what happens at the destination — see
 /// `move_tiled` and `move_floating`. Both decline (no commands, which the
 /// mechanism treats as "not mine" and, having no legacy arm for these
 /// actions, turns into the wanted no-op) when nothing is focused, or the
 /// grid is degenerate so a period is zero and the step goes nowhere. Any
 /// other mode — Fullscreen, and the compositor's own Popup / Overlay /
 /// Status / Utility roles — has no position of its own to step and declines
 /// too.
 fn move_window(ctx: &ActionCtx, action: Action) -> Vec<Command> {
     let Some(win) = ctx.focused.and_then(|id| window(ctx, id)) else {
         return Vec::new();
     };
     let (dx, dy) = match action {
         Action::MoveWindowLeft => (-ctx.grid_period_x, 0.0),
         Action::MoveWindowRight => (ctx.grid_period_x, 0.0),
         Action::MoveWindowUp => (0.0, -ctx.grid_period_y),
         _ => (0.0, ctx.grid_period_y),
     };
     if dx == 0.0 && dy == 0.0 {
         return Vec::new();
     }
     match win.resolved_mode {
         TilingMode::Tiled => move_tiled(ctx, win, dx, dy),
         TilingMode::Floating => move_floating(win, dx, dy),
         _ => Vec::new(),
     }
 }
 
 /// A floating window just moves. Floating windows overlap freely, so there
 /// is no occupant to swap with and nothing to decline: whatever is at the
 /// destination — tiled or floating — is simply covered, exactly as a pointer
 /// drag would leave it. This is also the only keyboard route a floating
 /// window has back on screen after a restore parks it off the viewport.
 fn move_floating(win: &crate::api::ActionWindow, dx: f64, dy: f64) -> Vec<Command> {
     vec![Command::MoveWindow { id: win.id, x: win.x + dx, y: win.y + dy }, Command::Relayout]
 }
 
 /// A tiled window steps one cell, swapping with whatever tiled window
 /// already holds the destination.
 ///
 /// Occupancy is decided by overlapping the DESTINATION box against the
 /// other tiled windows rather than by comparing cell indices: the two agree,
 /// and a rect test needs nothing from the snapshot that is not already
 /// there. Declines when MORE than one tiled window is in the destination,
 /// where "swap positions with it" names no particular window. Better to
 /// refuse than to pick.
 fn move_tiled(ctx: &ActionCtx, win: &crate::api::ActionWindow, dx: f64, dy: f64) -> Vec<Command> {
     let (nx, ny) = (win.x + dx, win.y + dy);
 
     let mut occupants = ctx.windows.iter().filter(|w| {
         w.id != win.id
             && w.visible
             && w.resolved_mode == TilingMode::Tiled
             && boxes_overlap(nx, ny, win.w, win.h, w)
     });
     let Some(other) = occupants.next() else {
         return vec![Command::MoveWindow { id: win.id, x: nx, y: ny }, Command::Relayout];
     };
     if occupants.next().is_some() {
         return Vec::new();
     }
     // Swap origins, not boxes: each window keeps its own size, so a step onto
     // a differently-shaped neighbour stays a swap rather than a resize.
     vec![
         Command::MoveWindow { id: win.id, x: other.x, y: other.y },
         Command::MoveWindow { id: other.id, x: win.x, y: win.y },
         Command::Relayout,
     ]
 }
 
 /// The bare program name of a command line: first token, basename only.
 pub fn program_name(cmd: &str) -> String {
     let first_token = cmd.trim().split_whitespace().next().unwrap_or("");
     match first_token.rfind('/') {
         Some(pos) => first_token[pos + 1..].to_string(),
         None => first_token.to_string(),
     }
 }
 
 /// Toggle a program: if a mapped window matches its name, close it (and
 /// refocus if it was the focused one); otherwise spawn the command. Matching
 /// is case-insensitive — app_id equal to or containing (either way) the
 /// program name; a window with NO app_id falls back to a title-contains
 /// match. First match in window order wins.
 fn toggle(ctx: &ActionCtx, arg: Option<&str>) -> Vec<Command> {
     let Some(cmd) = arg else { return Vec::new() };
     let prog = program_name(cmd).to_lowercase();
     let matched = ctx.windows.iter().find(|w| {
         if !w.mapped {
             return false;
         }
         if let Some(aid) = &w.app_id {
             let aid = aid.to_lowercase();
             aid == prog || aid.contains(&prog) || prog.contains(&aid)
         } else if let Some(title) = &w.title {
             title.to_lowercase().contains(&prog)
         } else {
             false
         }
     });
     match matched {
         Some(w) => {
             let mut cmds = vec![Command::CloseWindow(w.id)];
             if ctx.focused == Some(w.id) {
                 cmds.push(Command::FocusNextVisible);
             }
             cmds.push(Command::Relayout);
             cmds
         }
         None => vec![Command::Spawn(cmd.to_string())],
     }
 }
 
 /// Close the focused window, then refocus by the mechanism's next-visible
 /// rule.
 fn close(ctx: &ActionCtx) -> Vec<Command> {
     let Some(id) = ctx.focused else { return Vec::new() };
     vec![Command::CloseWindow(id), Command::FocusNextVisible, Command::Relayout]
 }
 
 /// Minimize the focused window, then refocus.
 fn minimize(ctx: &ActionCtx) -> Vec<Command> {
     let Some(id) = ctx.focused else { return Vec::new() };
     vec![
         Command::SetMinimized { id, minimized: true },
         Command::FocusNextVisible,
         Command::Relayout,
     ]
 }
 
 /// The focus-cycling ring: cyclable windows in stable id order.
 fn focus_ring(ctx: &ActionCtx) -> Vec<&crate::api::ActionWindow> {
     let mut ring: Vec<_> = ctx.windows.iter().filter(|w| w.focus_cyclable).collect();
     ring.sort_by_key(|w| w.id.0.index);
     ring
 }
 
 /// FocusNext/FocusPrev walk the ring; with nothing focused they start at
 /// its first/last entry.
 fn focus_cycle(ctx: &ActionCtx, action: Action) -> Vec<Command> {
     let ring = focus_ring(ctx);
     let n = ring.len();
     if n == 0 {
         return Vec::new();
     }
     let forward = action == Action::FocusNext;
     let current = ctx.focused.and_then(|f| ring.iter().position(|w| w.id == f));
     let target = match current {
         Some(idx) => {
             if forward {
                 (idx + 1) % n
             } else {
                 (idx + n - 1) % n
             }
         }
         None => {
             if forward {
                 0
             } else {
                 n - 1
             }
         }
     };
     let id = ring[target].id;
     vec![Command::Focus(id), Command::Raise(id), Command::Relayout]
 }
 
 /// Directional focus over the ring's window footprints on the virtual surface.
 fn focus_directional(ctx: &ActionCtx, action: Action) -> Vec<Command> {
     let ring = focus_ring(ctx);
     let rects: Vec<focus::Rect> = ring
         .iter()
         .map(|w| focus::Rect::new(w.x, w.y, w.w * w.scale, w.h * w.scale))
         .collect();
     let focused_idx = ctx.focused.and_then(|f| ring.iter().position(|w| w.id == f));
     let dir = focus::Direction::from_action(action)
         .expect("arm only matches directional focus actions");
     let Some(target) = focus::directional_focus(&rects, focused_idx, dir) else {
         return Vec::new();
     };
     let id = ring[target].id;
     vec![Command::Focus(id), Command::Raise(id), Command::Relayout]
 }
 
 /// Focus toward a free direction `v` (virtual units, y down) — the
 /// three-finger swipe's path, where the fingers give a vector rather than
 /// one of four directions. See `focus::vector_focus`; `cone_deg` is how far
 /// off the ray a window center may lie. Empty when there is no ray (nothing
 /// focused) or nothing within the cone, which the caller reads as "no
 /// focus change" — or, with nothing focused, falls back to the four-way
 /// action for its entry rule.
 pub fn focus_toward(ctx: &ActionCtx, v: (f64, f64), cone_deg: f64) -> Vec<Command> {
     let ring = focus_ring(ctx);
     let rects: Vec<focus::Rect> = ring
         .iter()
         .map(|w| focus::Rect::new(w.x, w.y, w.w * w.scale, w.h * w.scale))
         .collect();
     let focused_idx = ctx.focused.and_then(|f| ring.iter().position(|w| w.id == f));
     let Some(target) = focus::vector_focus(&rects, focused_idx, v, cone_deg) else {
         return Vec::new();
     };
     let id = ring[target].id;
     vec![Command::Focus(id), Command::Raise(id), Command::Relayout]
 }
 
 /// Toggle fullscreen on the focused window. Leaving fullscreen puts the
 /// window back the way the toggle found it — mode AND lock, so a window
 /// tiled by hand stays tiled (the mechanism records both when it applies
 /// the Fullscreen `SetWindowMode`). Without that record it unlocks to the
 /// viewport-resolved mode (Floating if that resolution is itself
 /// Fullscreen). Restoring matters beyond the mode itself: Tiled tells the
 /// client it is maximized, and Chromium-family clients drop their
 /// client-side shadow band only then.
 fn fullscreen(ctx: &ActionCtx) -> Vec<Command> {
     let Some(id) = ctx.focused else { return Vec::new() };
     let Some(win) = window(ctx, id) else { return Vec::new() };
     let cmd = if win.mode == TilingMode::Fullscreen {
         let (mode, locked) = match win.pre_fullscreen {
             Some((mode, locked)) if mode != TilingMode::Fullscreen => (mode, locked),
             _ => {
                 let target = if win.resolved_mode == TilingMode::Fullscreen {
                     TilingMode::Floating
                 } else {
                     win.resolved_mode
                 };
                 (target, false)
             }
         };
         Command::SetWindowMode { id, mode, locked }
     } else {
         Command::SetWindowMode { id, mode: TilingMode::Fullscreen, locked: true }
     };
     vec![cmd, Command::Relayout]
 }
 
 /// The keyed mode cycle.
 fn next_mode(current: TilingMode) -> TilingMode {
     let cycle = [TilingMode::Floating, TilingMode::Fullscreen];
     cycle
         .iter()
         .position(|m| *m == current)
         .map(|i| cycle[(i + 1) % cycle.len()])
         .unwrap_or(TilingMode::Floating)
 }
 
 /// Cycle the focused window's mode.
 fn mode_next(ctx: &ActionCtx) -> Vec<Command> {
     let Some(id) = ctx.focused else { return Vec::new() };
     let Some(win) = window(ctx, id) else { return Vec::new() };
     vec![
         Command::SetWindowMode { id, mode: next_mode(win.mode), locked: true },
         Command::Relayout,
     ]
 }
 
 /// Cycle every visible window that shares the focused window's mode.
 fn mode_next_shared(ctx: &ActionCtx) -> Vec<Command> {
     let Some(id) = ctx.focused else { return Vec::new() };
     let Some(win) = window(ctx, id) else { return Vec::new() };
     let current = win.mode;
     let next = next_mode(current);
     let mut cmds: Vec<Command> = ctx
         .windows
         .iter()
         .filter(|w| w.visible && w.mode == current)
         .map(|w| Command::SetWindowMode { id: w.id, mode: next, locked: true })
         .collect();
     cmds.push(Command::Relayout);
     cmds
 }
 
 /// Stock command line for a media-key action (PipeWire's wpctl for audio,
 /// brightnessctl for the backlight). A binding's `command="..."` property
 /// overrides this wholesale — that's where a custom step size or a different
 /// mixer goes.
 fn media_command(action: Action) -> &'static str {
     match action {
         Action::VolumeUp => "wpctl set-volume -l 1.0 @DEFAULT_AUDIO_SINK@ 5%+",
         Action::VolumeDown => "wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-",
         Action::VolumeMute => "wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle",
         Action::MicMute => "wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle",
         Action::BrightnessUp => "brightnessctl set 5%+",
         Action::BrightnessDown => "brightnessctl set 5%-",
         _ => "",
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::api::{ActionWindow, Rect};
     use crate::slotmap::Key;
 
     fn wid(index: u32) -> WindowId {
         WindowId(Key { generation: 0, index })
     }
 
     /// A plain visible, cyclable, overview-eligible Floating window.
     fn win(index: u32, x: f64, y: f64, w: f64, h: f64) -> ActionWindow {
         ActionWindow {
             id: wid(index),
             app_id: None,
             title: None,
             mapped: true,
             x,
             y,
             w,
             h,
             scale: 1.0,
             mode: TilingMode::Floating,
             resolved_mode: TilingMode::Floating,
             pre_fullscreen: None,
             visible: true,
             focus_cyclable: true,
             overview_eligible: true,
         }
     }
 
     fn ctx() -> ActionCtx {
         ActionCtx {
             camera: Camera { pan_x: 0.0, pan_y: 0.0, zoom: 1.0 },
             overview: false,
             pan_target_x: None,
             pan_target_y: None,
             viewport_w: 1920.0,
             viewport_h: 1080.0,
             cursor_viewport: Rect { x: 0, y: 0, width: 1920, height: 1080 },
             has_cursor: true,
             cursor_x: 960.0,
             cursor_y: 540.0,
             hovered: None,
             focused: None,
             grid_period_x: 512.0,
             grid_period_y: 512.0,
             windows: Vec::new(),
         }
     }
 
     fn dispatch(ctx: &ActionCtx, action: Action) -> Vec<Command> {
         DefaultPolicy.action(ctx, action, None)
     }
 
     #[test]
     fn toggle_spawns_or_closes_by_program_match() {
         let mut c = ctx();
         // No arg: not claimed. No match: spawn.
         assert!(dispatch(&c, Action::Toggle).is_empty());
         assert_eq!(
             DefaultPolicy.action(&c, Action::Toggle, Some("firefox --new-window")),
             vec![Command::Spawn("firefox --new-window".to_string())]
         );
         // App-id containment match (either direction, case-insensitive)
         // closes; the focused match also refocuses.
         let mut w = win(1, 0.0, 0.0, 100.0, 100.0);
         w.app_id = Some("org.mozilla.Firefox".to_string());
         c.windows.push(w);
         assert_eq!(
             DefaultPolicy.action(&c, Action::Toggle, Some("/usr/bin/firefox -P")),
             vec![Command::CloseWindow(wid(1)), Command::Relayout]
         );
         c.focused = Some(wid(1));
         assert_eq!(
             DefaultPolicy.action(&c, Action::Toggle, Some("firefox")),
             vec![Command::CloseWindow(wid(1)), Command::FocusNextVisible, Command::Relayout]
         );
         // A window without an app_id falls back to title-contains; an
         // unmapped window never matches.
         let mut t = win(2, 0.0, 0.0, 100.0, 100.0);
         t.title = Some("Alacritty scratchpad".to_string());
         c.windows.push(t);
         assert_eq!(
             DefaultPolicy.action(&c, Action::Toggle, Some("alacritty")),
             vec![Command::CloseWindow(wid(2)), Command::Relayout]
         );
         c.windows[1].mapped = false;
         assert_eq!(
             DefaultPolicy.action(&c, Action::Toggle, Some("alacritty")),
             vec![Command::Spawn("alacritty".to_string())]
         );
     }
 
     #[test]
     fn program_name_takes_first_token_basename() {
         assert_eq!(program_name("/usr/bin/firefox --new-window"), "firefox");
         assert_eq!(program_name("  alacritty -e htop "), "alacritty");
         assert_eq!(program_name(""), "");
     }
 
     #[test]
     fn unclaimed_actions_return_empty() {
         assert!(dispatch(&ctx(), Action::Spawn).is_empty());
         assert!(dispatch(&ctx(), Action::Reload).is_empty());
         assert!(dispatch(&ctx(), Action::Exit).is_empty());
     }
 
     #[test]
     fn close_and_minimize_need_focus_and_refocus() {
         assert!(dispatch(&ctx(), Action::Close).is_empty());
         let mut c = ctx();
         c.focused = Some(wid(4));
         assert_eq!(
             dispatch(&c, Action::Close),
             vec![Command::CloseWindow(wid(4)), Command::FocusNextVisible, Command::Relayout]
         );
         assert_eq!(
             dispatch(&c, Action::Minimize),
             vec![
                 Command::SetMinimized { id: wid(4), minimized: true },
                 Command::FocusNextVisible,
                 Command::Relayout
             ]
         );
     }
 
     #[test]
     fn focus_cycle_walks_id_order_and_wraps() {
         let mut c = ctx();
         // Inserted out of id order; the ring sorts by id: 1, 5, 9.
         c.windows.push(win(9, 0.0, 0.0, 100.0, 100.0));
         c.windows.push(win(1, 200.0, 0.0, 100.0, 100.0));
         c.windows.push(win(5, 400.0, 0.0, 100.0, 100.0));
         c.focused = Some(wid(9));
         // Next from the last entry wraps to the first.
         assert_eq!(dispatch(&c, Action::FocusNext)[0], Command::Focus(wid(1)));
         // Prev from 9 goes to 5.
         assert_eq!(dispatch(&c, Action::FocusPrev)[0], Command::Focus(wid(5)));
         // No focus: Next starts at the ring's first entry.
         c.focused = None;
         assert_eq!(dispatch(&c, Action::FocusNext)[0], Command::Focus(wid(1)));
         // Non-cyclable windows are not in the ring.
         for w in c.windows.iter_mut() {
             w.focus_cyclable = false;
         }
         assert!(dispatch(&c, Action::FocusNext).is_empty());
     }
 
     #[test]
     fn focus_directional_picks_by_footprint() {
         let mut c = ctx();
         c.windows.push(win(1, 0.0, 0.0, 100.0, 100.0));
         c.windows.push(win(2, 500.0, 0.0, 100.0, 100.0));
         c.focused = Some(wid(1));
         let cmds = dispatch(&c, Action::FocusRight);
         assert_eq!(cmds[0], Command::Focus(wid(2)));
         assert_eq!(cmds[1], Command::Raise(wid(2)));
         // Nothing to the left of window 1.
         assert!(dispatch(&c, Action::FocusLeft).is_empty());
         // The footprint is the scaled extent. A window starting at 80 is
         // past window 1's midpoint (50) at scale 1 and wins as the nearer
         // edge; at scale 2 window 1 spans 0..200, so it is stacked, not
         // ahead, and window 2 wins again.
         c.windows.push(win(3, 80.0, 0.0, 100.0, 100.0));
         assert_eq!(dispatch(&c, Action::FocusRight)[0], Command::Focus(wid(3)));
         c.windows[0].scale = 2.0;
         assert_eq!(dispatch(&c, Action::FocusRight)[0], Command::Focus(wid(2)));
     }
 
     #[test]
     fn fullscreen_toggles_and_unlocks_to_resolved_mode() {
         let mut c = ctx();
         c.focused = Some(wid(1));
         c.windows.push(win(1, 0.0, 0.0, 100.0, 100.0));
         // Enter: lock to Fullscreen.
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Fullscreen, locked: true }
         );
         // Exit: unlock back to the resolved mode.
         c.windows[0].mode = TilingMode::Fullscreen;
         c.windows[0].resolved_mode = TilingMode::Tiled;
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Tiled, locked: false }
         );
         // Exit when the viewport itself resolves Fullscreen: fall to Floating.
         c.windows[0].resolved_mode = TilingMode::Fullscreen;
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Floating, locked: false }
         );
     }
 
     #[test]
     fn fullscreen_exit_restores_the_recorded_mode_and_lock() {
         let mut c = ctx();
         c.focused = Some(wid(1));
         c.windows.push(win(1, 0.0, 0.0, 100.0, 100.0));
         c.windows[0].mode = TilingMode::Fullscreen;
         // A hand-tiled (locked) window comes back Tiled and locked, whatever
         // the viewport would resolve it to.
         c.windows[0].resolved_mode = TilingMode::Floating;
         c.windows[0].pre_fullscreen = Some((TilingMode::Tiled, true));
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Tiled, locked: true }
         );
         // An unlocked Floating window comes back unlocked.
         c.windows[0].pre_fullscreen = Some((TilingMode::Floating, false));
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Floating, locked: false }
         );
         // A record that itself says Fullscreen is useless: resolved-mode fallback.
         c.windows[0].resolved_mode = TilingMode::Tiled;
         c.windows[0].pre_fullscreen = Some((TilingMode::Fullscreen, true));
         assert_eq!(
             dispatch(&c, Action::Fullscreen)[0],
             Command::SetWindowMode { id: wid(1), mode: TilingMode::Tiled, locked: false }
         );
     }
 
     #[test]
     fn mode_next_cycles_and_shared_hits_all_matching() {
         let mut c = ctx();
         c.focused = Some(wid(1));
         c.windows.push(win(1, 0.0, 0.0, 100.0, 100.0));
         c.windows.push(win(2, 200.0, 0.0, 100.0, 100.0));
         let mut hidden = win(3, 400.0, 0.0, 100.0, 100.0);
         hidden.visible = false;
         c.windows.push(hidden);
         // Floating -> Fullscreen on the focused window only.
         assert_eq!(
             dispatch(&c, Action::ModeNext),
             vec![
                 Command::SetWindowMode { id: wid(1), mode: TilingMode::Fullscreen, locked: true },
                 Command::Relayout
             ]
         );
         // Shared: every visible window in the focused window's mode cycles;
         // the invisible one is untouched.
         assert_eq!(
             dispatch(&c, Action::ModeNextShared),
             vec![
                 Command::SetWindowMode { id: wid(1), mode: TilingMode::Fullscreen, locked: true },
                 Command::SetWindowMode { id: wid(2), mode: TilingMode::Fullscreen, locked: true },
                 Command::Relayout
             ]
         );
     }
 
     #[test]
     fn zoom_in_sets_overview_and_relayouts() {
         let cmds = dispatch(&ctx(), Action::ZoomIn);
         assert_eq!(cmds.len(), 2);
         let Command::SetCamera { camera, overview, .. } = cmds[0] else { panic!() };
         assert!((camera.zoom - 1.1).abs() < 1e-9);
         assert_eq!(overview, Some(true));
         assert_eq!(cmds[1], Command::Relayout);
         // Reset from zoomed goes back to normal.
         let mut c = ctx();
         c.camera.zoom = 2.0;
         let Command::SetCamera { camera, overview, .. } = dispatch(&c, Action::ZoomReset)[0] else { panic!() };
         assert_eq!(camera.zoom, 1.0);
         assert_eq!(overview, Some(false));
     }
 
     #[test]
     fn pan_steps_one_aligned_cell_from_pending_target() {
         let Command::PanTo { x, y } = dispatch(&ctx(), Action::PanRight)[0] else { panic!() };
         assert_eq!((x, y), (Some(512.0), None));
         // A pending target queues the next cell from there.
         let mut c = ctx();
         c.pan_target_x = Some(512.0);
         let Command::PanTo { x, .. } = dispatch(&c, Action::PanRight)[0] else { panic!() };
         assert_eq!(x, Some(1024.0));
     }
 
     #[test]
     fn overview_enter_fits_eligible_windows_only() {
         let mut c = ctx();
         c.windows.push(win(1, 0.0, 0.0, 400.0, 300.0));
         let mut ineligible = win(2, 5000.0, 0.0, 400.0, 300.0);
         ineligible.overview_eligible = false;
         c.windows.push(ineligible);
         let cmds = dispatch(&c, Action::Overview);
         let Command::SetCamera { camera, overview, .. } = cmds[0] else { panic!() };
         assert_eq!(overview, Some(true));
         // Only window 1 counts: 400x300 fits without zooming out.
         assert_eq!(camera.zoom, 1.0);
         assert_eq!(cmds[1], Command::RefreshCamera);
         // No eligible windows: not claimed, nothing happens.
         c.windows.clear();
         assert!(dispatch(&c, Action::Overview).is_empty());
     }
 
     #[test]
     fn overview_exit_prefers_the_hovered_window() {
         let mut c = ctx();
         c.overview = true;
         c.camera.zoom = 0.5;
         c.windows.push(win(3, 1000.0, 2000.0, 400.0, 300.0));
         c.hovered = Some(wid(3));
         let cmds = dispatch(&c, Action::Overview);
         assert_eq!(cmds[0], Command::Focus(wid(3)));
         assert_eq!(cmds[1], Command::StopPanAnimation);
         let Command::SetCamera { camera, overview, .. } = cmds[2] else { panic!() };
         assert_eq!(overview, Some(false));
         assert_eq!(camera.zoom, 1.0);
         // Centered on the window's center (1200, 2150).
         assert_eq!(camera.pan_x, 1200.0 - 960.0);
         assert_eq!(camera.pan_y, 2150.0 - 540.0);
         // Without a hovered window, exit centers the point under the cursor.
         c.hovered = None;
         c.camera.pan_x = 100.0;
         let Command::SetCamera { camera, .. } = dispatch(&c, Action::Overview)[1] else { panic!() };
         // Virtual point under (960, 540) at zoom 0.5: 100 + 960/0.5 = 2020.
         assert_eq!(camera.pan_x, 2020.0 - 960.0);
     }
 
     #[test]
     fn one_way_overview_actions_only_fire_in_the_other_mode() {
         let mut c = ctx();
         c.windows.push(win(1, 0.0, 0.0, 400.0, 300.0));
 
         // Normal mode: Enter does the same thing the toggle would, Exit is
         // a no-op (you are already where it would take you).
         assert_eq!(dispatch(&c, Action::OverviewEnter), dispatch(&c, Action::Overview));
         let Command::SetCamera { overview, .. } = dispatch(&c, Action::OverviewEnter)[0] else {
             panic!()
         };
         assert_eq!(overview, Some(true));
         assert!(dispatch(&c, Action::OverviewExit).is_empty());
 
         // Overview mode: exactly the reverse.
         c.overview = true;
         c.camera.zoom = 0.5;
         assert_eq!(dispatch(&c, Action::OverviewExit), dispatch(&c, Action::Overview));
         let Command::SetCamera { overview, .. } = dispatch(&c, Action::OverviewExit)[1] else {
             panic!()
         };
         assert_eq!(overview, Some(false));
         assert!(dispatch(&c, Action::OverviewEnter).is_empty());
     }
 
     #[test]
     fn the_keyed_exit_lands_on_the_focused_window_not_the_hovered_one() {
         let mut c = ctx();
         c.overview = true;
         c.camera.zoom = 0.5;
         c.windows.push(win(1, 1000.0, 2000.0, 400.0, 300.0)); // focused
         c.windows.push(win(2, 5000.0, 6000.0, 400.0, 300.0)); // under the pointer
         c.focused = Some(wid(1));
         c.hovered = Some(wid(2));
 
         // The pointer is over window 2, but a key press said nothing about
         // the pointer: window 1 wins, and gets (re)focused.
         let cmds = dispatch(&c, Action::OverviewExit);
         assert_eq!(cmds[0], Command::Focus(wid(1)));
         let Command::SetCamera { camera, overview, .. } = cmds[2] else { panic!() };
         assert_eq!(overview, Some(false));
         assert_eq!(camera.zoom, 1.0);
         // Centered on window 1's center (1200, 2150).
         assert_eq!(camera.pan_x, 1200.0 - 960.0);
         assert_eq!(camera.pan_y, 2150.0 - 540.0);
 
         // The toggle is the cursor-driven path and still prefers the hover.
         assert_eq!(dispatch(&c, Action::Overview)[0], Command::Focus(wid(2)));
     }
 
     #[test]
     fn the_keyed_exit_falls_back_to_the_cursor_with_nothing_focused() {
         let mut c = ctx();
         c.overview = true;
         c.camera.zoom = 0.5;
         c.windows.push(win(2, 5000.0, 6000.0, 400.0, 300.0));
         c.focused = None;
         c.hovered = Some(wid(2));
         assert_eq!(dispatch(&c, Action::OverviewExit), dispatch(&c, Action::Overview));
 
         // ...and with neither, onto the virtual point under the cursor.
         c.hovered = None;
         c.camera.pan_x = 100.0;
         let Command::SetCamera { camera, .. } = dispatch(&c, Action::OverviewExit)[1] else {
             panic!()
         };
         // Virtual point under (960, 540) at zoom 0.5: 100 + 960/0.5 = 2020.
         assert_eq!(camera.pan_x, 2020.0 - 960.0);
     }
 
     #[test]
     fn overview_enter_on_an_empty_desktop_is_not_claimed() {
         // Nothing to fit, so no camera to compute — same empty list the
         // toggle returns, and for the same reason.
         let c = ctx();
         assert!(c.windows.is_empty());
         assert!(dispatch(&c, Action::OverviewEnter).is_empty());
     }
 
     /// A ctx on a 100px grid period, so cell (col,row) sits at (col*100,
     /// row*100) and the arithmetic in these tests reads directly.
     fn grid_ctx() -> ActionCtx {
         let mut c = ctx();
         c.grid_period_x = 100.0;
         c.grid_period_y = 100.0;
         c
     }
 
     /// A tiled window one cell wide/high at cell (col,row) on `grid_ctx`.
     fn tiled_at(index: u32, col: f64, row: f64) -> ActionWindow {
         let mut w = win(index, col * 100.0, row * 100.0, 90.0, 90.0);
         w.mode = TilingMode::Tiled;
         w.resolved_mode = TilingMode::Tiled;
         w
     }
 
     #[test]
     fn a_tiled_window_steps_one_cell_into_empty_space() {
         let mut c = grid_ctx();
         c.windows.push(tiled_at(1, 2.0, 3.0));
         c.focused = Some(wid(1));
 
         for (action, x, y) in [
             (Action::MoveWindowRight, 300.0, 300.0),
             (Action::MoveWindowLeft, 100.0, 300.0),
             (Action::MoveWindowDown, 200.0, 400.0),
             (Action::MoveWindowUp, 200.0, 200.0),
         ] {
             let cmds = dispatch(&c, action);
             assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x, y }, "{:?}", action);
             assert_eq!(cmds[1], Command::Relayout);
         }
     }
 
     #[test]
     fn stepping_onto_a_tiled_neighbour_swaps_the_two() {
         let mut c = grid_ctx();
         c.windows.push(tiled_at(1, 2.0, 3.0));
         c.windows.push(tiled_at(2, 3.0, 3.0)); // directly to the right
         c.focused = Some(wid(1));
 
         // Right: lands on window 2, so the two exchange origins.
         let cmds = dispatch(&c, Action::MoveWindowRight);
         assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x: 300.0, y: 300.0 });
         assert_eq!(cmds[1], Command::MoveWindow { id: wid(2), x: 200.0, y: 300.0 });
         assert_eq!(cmds[2], Command::Relayout);
 
         // Left is still empty, so that direction is an ordinary move.
         let cmds = dispatch(&c, Action::MoveWindowLeft);
         assert_eq!(cmds.len(), 2);
         assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x: 100.0, y: 300.0 });
     }
 
     #[test]
     fn a_swap_keeps_each_window_its_own_size() {
         let mut c = grid_ctx();
         c.windows.push(tiled_at(1, 2.0, 3.0));
         let mut wide = tiled_at(2, 3.0, 3.0);
         wide.w = 190.0; // two cells wide
         c.windows.push(wide);
         c.focused = Some(wid(1));
 
         // Only origins move; neither command carries a size.
         let cmds = dispatch(&c, Action::MoveWindowRight);
         assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x: 300.0, y: 300.0 });
         assert_eq!(cmds[1], Command::MoveWindow { id: wid(2), x: 200.0, y: 300.0 });
     }
 
     #[test]
     fn a_floating_window_steps_one_period_too() {
         let mut c = grid_ctx();
         // Floating, and deliberately NOT cell-aligned: the step is a plain
         // offset by one period, no snapping to the grid.
         c.windows.push(win(1, 230.0, 310.0, 700.0, 666.0));
         c.focused = Some(wid(1));
 
         for (action, x, y) in [
             (Action::MoveWindowRight, 330.0, 310.0),
             (Action::MoveWindowLeft, 130.0, 310.0),
             (Action::MoveWindowDown, 230.0, 410.0),
             (Action::MoveWindowUp, 230.0, 210.0),
         ] {
             let cmds = dispatch(&c, action);
             assert_eq!(cmds, vec![Command::MoveWindow { id: wid(1), x, y }, Command::Relayout], "{:?}", action);
         }
     }
 
     #[test]
     fn a_floating_window_covers_the_destination_instead_of_swapping() {
         let mut c = grid_ctx();
         c.windows.push(win(1, 200.0, 300.0, 90.0, 90.0)); // floating, focused
         c.windows.push(tiled_at(2, 3.0, 3.0)); // tiled, directly to the right
         c.windows.push(win(3, 300.0, 300.0, 90.0, 90.0)); // floating, same cell
         c.focused = Some(wid(1));
 
         // Floating windows overlap freely: only the focused one moves, and
         // neither occupant — tiled or floating — is displaced.
         let cmds = dispatch(&c, Action::MoveWindowRight);
         assert_eq!(cmds, vec![Command::MoveWindow { id: wid(1), x: 300.0, y: 300.0 }, Command::Relayout]);
     }
 
     #[test]
     fn only_tiled_and_floating_windows_step() {
         let mut c = grid_ctx();
         // Fullscreen (and the internal roles) have no position of their own.
         let mut fs = win(1, 200.0, 300.0, 90.0, 90.0);
         fs.mode = TilingMode::Fullscreen;
         fs.resolved_mode = TilingMode::Fullscreen;
         c.windows.push(fs);
         c.focused = Some(wid(1));
         assert!(dispatch(&c, Action::MoveWindowRight).is_empty());
 
         // Nothing focused at all.
         c.windows[0].mode = TilingMode::Tiled;
         c.windows[0].resolved_mode = TilingMode::Tiled;
         c.focused = None;
         assert!(dispatch(&c, Action::MoveWindowRight).is_empty());
 
         // A degenerate grid: the step goes nowhere, for either kind.
         c.focused = Some(wid(1));
         c.grid_period_x = 0.0;
         assert!(dispatch(&c, Action::MoveWindowRight).is_empty());
         c.windows[0].mode = TilingMode::Floating;
         c.windows[0].resolved_mode = TilingMode::Floating;
         assert!(dispatch(&c, Action::MoveWindowRight).is_empty());
     }
 
     #[test]
     fn a_floating_window_in_the_way_is_not_swapped_with() {
         let mut c = grid_ctx();
         c.windows.push(tiled_at(1, 2.0, 3.0));
         c.windows.push(win(2, 300.0, 300.0, 90.0, 90.0)); // floating, in the destination
         c.focused = Some(wid(1));
         // The step happens anyway: only tiled windows hold cells.
         let cmds = dispatch(&c, Action::MoveWindowRight);
         assert_eq!(cmds.len(), 2);
         assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x: 300.0, y: 300.0 });
     }
 
     #[test]
     fn an_ambiguous_swap_is_declined() {
         let mut c = grid_ctx();
         // A two-cell-tall window stepping right onto TWO stacked neighbours:
         // "swap with it" names neither, so nothing happens.
         let mut tall = tiled_at(1, 2.0, 3.0);
         tall.h = 190.0;
         c.windows.push(tall);
         c.windows.push(tiled_at(2, 3.0, 3.0));
         c.windows.push(tiled_at(3, 3.0, 4.0));
         c.focused = Some(wid(1));
         assert!(dispatch(&c, Action::MoveWindowRight).is_empty());
     }
 
     #[test]
     fn merely_touching_the_neighbour_is_not_occupying() {
         // Zero gap and zero inset: cells abut exactly, so a window's right
         // edge sits on its neighbour's left edge. Stepping AWAY from it must
         // not read that shared edge as an overlap.
         let mut c = grid_ctx();
         let mut a = tiled_at(1, 2.0, 3.0);
         a.w = 100.0;
         let mut b = tiled_at(2, 3.0, 3.0);
         b.w = 100.0;
         c.windows.push(a);
         c.windows.push(b);
         c.focused = Some(wid(1));
         let cmds = dispatch(&c, Action::MoveWindowLeft);
         assert_eq!(cmds.len(), 2, "stepping left should be a plain move");
         assert_eq!(cmds[0], Command::MoveWindow { id: wid(1), x: 100.0, y: 300.0 });
     }
 
     #[test]
     fn media_keys_spawn_stock_or_overridden_command() {
         let c = ctx();
         // Every media action is claimed and spawns its stock command.
         for action in [
             Action::VolumeUp, Action::VolumeDown, Action::VolumeMute,
             Action::MicMute, Action::BrightnessUp, Action::BrightnessDown,
         ] {
             assert_eq!(
                 dispatch(&c, action),
                 vec![Command::Spawn(media_command(action).to_string())],
                 "{}", action.name()
             );
         }
         assert_eq!(
             dispatch(&c, Action::VolumeMute),
             vec![Command::Spawn("wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle".to_string())]
         );
         // A binding's command= property replaces the stock command.
         assert_eq!(
             DefaultPolicy.action(&c, Action::BrightnessUp, Some("brightnessctl set 10%+")),
             vec![Command::Spawn("brightnessctl set 10%+".to_string())]
         );
     }
 }