Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

76.5 KB
Raw Blame
//! Edit → Keyboard Shortcuts: user overrides of tool and command shortcuts, conflict detection,
//! presets, import/export, and the dialog.
//!
//! Overrides live in [`UiState::shortcut_overrides`] (persisted, [`crate::keymap::stored`]) keyed
//! by command id, `tool:<id>` or `panel:<id>`; an empty string removes a shortcut. A process-wide
//! mirror (synced every frame by [`sync`]) holds the keymap with them, so `menus::shortcut_of`, the
//! dispatcher, the native menu and tooltips consult them without threading the app state through.

use std::borrow::Cow;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, OnceLock};

use craft_keymap::{AssignError, Binding, ConflictKind, Keymap, Overrides, Policy, Trigger};
use egui::{Key, KeyboardShortcut, Modifiers};
use serde_json::{Value, json};

use crate::keymap::{command_of, effective_with, entry_key, entry_of_stored, keymap_with, stored, vc_chord, vc_format};

use crate::state::{Dialog, UiState};
use crate::theme::{self, Tokens};
use crate::{VectorcraftApp, menus, widgets};

pub const PRESETS: &[&str] = &["VectorCraft Defaults", "Classic Defaults"];
pub const CUSTOM: &str = "Custom";
/// Set names earlier versions saved: (old name, current name).
pub const LEGACY_PRESETS: &[(&str, &str)] = &[("Illustrator Defaults", "Classic Defaults")]; // brand-ok: legacy preference value

/// The current name of a shortcut set: names earlier versions saved map to today's.
pub fn set_name(name: &str) -> &str {
    LEGACY_PRESETS.iter().find(|(old, _)| *old == name).map_or(name, |(_, new)| new)
}

/// Serde reader for a saved set name (UI preferences written by earlier versions).
pub fn deserialize_set_name<'de, D: serde::Deserializer<'de>>(d: D) -> Result<String, D::Error> {
    <String as serde::Deserialize>::deserialize(d).map(|s| set_name(&s).to_string())
}

/// Bumped whenever overrides or the workspace list change (the native menu rebuilds on it).
pub static GENERATION: AtomicU64 = AtomicU64::new(0);

/// Declares `fn $name() -> &'static RwLock<$t>`: a mirror of UI state for code without app access
/// (menus, the shortcut dispatcher). One per process in the app; one per thread in unit tests,
/// which run in parallel threads, each driving its own app whose every frame syncs the mirror: a
/// shared one would let a test's frames overwrite another test's state mid-assertion.
macro_rules! ui_mirror {
    ($(#[$meta:meta])* $vis:vis fn $name:ident() -> $t:ty) => {
        $(#[$meta])*
        $vis fn $name() -> &'static std::sync::RwLock<$t> {
            #[cfg(not(test))]
            {
                static S: std::sync::OnceLock<std::sync::RwLock<$t>> = std::sync::OnceLock::new();
                S.get_or_init(Default::default)
            }
            #[cfg(test)]
            {
                thread_local!(static S: &'static std::sync::RwLock<$t> = Box::leak(Box::default()));
                S.with(|s| *s)
            }
        }
    };
}
pub(crate) use ui_mirror;

/// The keymap with the user's overrides, and the effective text of every entry they change.
pub(crate) struct Mirror {
    pub keymap: Keymap,
    text: HashMap<String, Option<&'static str>>,
}

impl Mirror {
    fn new(overrides: Overrides) -> Mirror {
        let keymap = crate::keymap::template().clone().with_overrides(overrides);
        let text = keymap
            .overrides()
            .iter()
            .map(|(k, _)| {
                let key = entry_of_stored(k);
                let t = effective_with(&keymap, &key).map(|t| intern(&t));
                (key, t)
            })
            .collect();
        Mirror { keymap, text }
    }
}

ui_mirror!(fn store() -> Option<Arc<Mirror>>);

/// The mirror: the keymap in effect.
pub(crate) fn current() -> Arc<Mirror> {
    static DEFAULTS: [OnceLock<Arc<Mirror>>; 3] = [OnceLock::new(), OnceLock::new(), OnceLock::new()];
    store()
        .read()
        .ok()
        .and_then(|m| m.clone())
        .unwrap_or_else(|| crate::keymap::per_platform(&DEFAULTS, crate::keymap::platform(), || Arc::new(Mirror::new(Overrides::new()))).clone())
}

/// Leak-once interning for override strings (bounded by the chords a user ever assigns).
pub fn intern(s: &str) -> &'static str {
    static SET: OnceLock<Mutex<HashSet<&'static str>>> = OnceLock::new();
    let mut set = SET.get_or_init(Default::default).lock().unwrap_or_else(|e| e.into_inner());
    if let Some(v) = set.get(s) {
        return v;
    }
    let v: &'static str = Box::leak(s.to_string().into_boxed_str());
    set.insert(v);
    v
}

/// Mirror `ui.shortcut_overrides` into the global store (cheap when unchanged).
pub fn sync(ui: &UiState) {
    let same = store()
        .read()
        .map(|m| match &*m {
            Some(m) => *m.keymap.overrides() == ui.shortcut_overrides && m.keymap.platform() == crate::keymap::platform(),
            None => ui.shortcut_overrides.is_empty(),
        })
        .unwrap_or(false);
    if !same {
        if let Ok(mut m) = store().write() {
            *m = Some(Arc::new(Mirror::new(ui.shortcut_overrides.clone())));
        }
        GENERATION.fetch_add(1, Ordering::Relaxed);
    }
    crate::workspaces::sync(ui);
    crate::custom_toolbars::sync(ui);
}

/// Registry default shortcut of a command (engine or UI command).
pub fn default_command_shortcut(id: &str) -> Option<&'static str> {
    if let Some(c) = vectorcraft_engine::find_command(id) {
        return c.shortcut;
    }
    menus::UI_COMMANDS.iter().find(|c| c.0 == id).map(|c| c.2).filter(|s| !s.is_empty())
}

/// Window menu items that show a panel (`window.panel {panel}`) with a default shortcut: (panel
/// id, shortcut). Every panel can be given one in the editor (entry key `panel:<id>`).
pub const PANEL_SHORTCUTS: &[(&str, &str)] = &[
    ("brushes", "F5"),
    ("color", "F6"),
    ("layers", "F7"),
    ("colorGuide", "Shift+F3"),
    ("graphicStyles", "Shift+F5"),
    ("appearance", "Shift+F6"),
    ("align", "Shift+F7"),
    ("transform", "Shift+F8"),
    ("info", "Cmd+F8"),
    ("gradient", "Cmd+F9"),
    ("pathfinder", "Cmd+Shift+F9"),
    ("stroke", "Cmd+F10"),
    ("transparency", "Cmd+Shift+F10"),
    ("attributes", "Cmd+F11"),
    ("symbols", "Cmd+Shift+F11"),
    ("character", "Cmd+T"),
    ("paragraph", "Cmd+Alt+T"),
    ("tabs", "Cmd+Shift+T"),
    ("openType", "Cmd+Alt+Shift+T"),
];

/// Default shortcut of an entry key (`tool:<id>`, `panel:<id>` or a command id).
pub fn default_of(key: &str) -> Option<&'static str> {
    if let Some(t) = key.strip_prefix("tool:") {
        return vectorcraft_tools::tool_info(t).and_then(|t| t.shortcut);
    }
    if let Some(p) = key.strip_prefix("panel:") {
        return PANEL_SHORTCUTS.iter().find(|(id, _)| *id == p).map(|(_, sc)| *sc);
    }
    default_command_shortcut(key)
}

/// Effective shortcut of an entry key, honouring the user's overrides.
fn effective(key: &str) -> Option<&'static str> {
    let m = current();
    match m.text.get(key) {
        Some(t) => *t,
        None => default_of(key),
    }
}

/// Effective shortcut of `key` under explicit overrides: override > default.
pub fn effective_in(overrides: &Overrides, key: &str) -> Option<String> {
    effective_with(&keymap_with(overrides), key)
}

/// Effective shortcut of a command, honouring the user's overrides.
pub fn command_shortcut(id: &str) -> Option<&'static str> {
    effective(id)
}

/// Effective shortcut of a tool.
pub fn tool_shortcut(tool: &str) -> Option<&'static str> {
    effective(&format!("tool:{tool}"))
}

/// Effective shortcut of the Window menu item showing `panel` (`window.panel {panel}`).
pub fn panel_shortcut(panel: &str) -> Option<&'static str> {
    effective(&format!("panel:{panel}"))
}

/// Tool whose (effective) shortcut is `key` ("V", "Shift+M").
pub fn tool_for_key(key: &str) -> Option<&'static str> {
    let c = crate::keymap::lookup(&current().keymap, &vc_chord(key)?)?;
    c.id.strip_prefix("tool:").and_then(vectorcraft_tools::tool_info).map(|t| t.id)
}

/// Command (not a tool or a panel) whose effective shortcut is exactly `key`.
pub fn command_for_key(key: &str) -> Option<&'static str> {
    let c = crate::keymap::lookup(&current().keymap, &vc_chord(key)?)?;
    vectorcraft_engine::command_specs()
        .iter()
        .map(|c| c.id)
        .chain(menus::UI_COMMANDS.iter().map(|c| c.0))
        .find(|id| *id == c.id && c.params.is_null())
}

// ---------- chords ----------

/// Canonical text of a chord: `Cmd+Ctrl+Alt+Shift+Key`.
pub fn format(sc: &KeyboardShortcut) -> String {
    let m = sc.modifiers;
    let mut s = String::new();
    if m.command || m.mac_cmd {
        s.push_str("Cmd+");
    }
    if m.ctrl && (cfg!(target_os = "macos") || !m.command) {
        s.push_str("Ctrl+");
    }
    if m.alt {
        s.push_str("Alt+");
    }
    if m.shift {
        s.push_str("Shift+");
    }
    let k = sc.logical_key;
    let name = match k {
        // A shifted punctuation key is recorded as the key, not the character it types.
        Key::CloseCurlyBracket if m.shift => "]",
        Key::OpenCurlyBracket if m.shift => "[",
        Key::Questionmark if m.shift => "/",
        Key::Colon if m.shift => ";",
        Key::Pipe if m.shift => "\\",
        Key::CloseBracket => "]",
        Key::OpenBracket => "[",
        Key::Semicolon => ";",
        Key::Quote => "'",
        Key::Slash => "/",
        Key::Backslash => "\\",
        Key::Equals | Key::Plus => "=",
        Key::Minus => "-",
        Key::Backtick => "~",
        Key::Comma => "Comma",
        Key::Period => "Period",
        k => k.name(),
    };
    s.push_str(name);
    s
}

/// Canonical form of a shortcut string (None if it doesn't parse).
pub fn normalize(s: &str) -> Option<String> {
    vc_chord(s).map(|c| vc_format(&c))
}

/// A recorded key press → shortcut text (None for keys that can't be shortcuts).
pub fn chord_from_event(key: Key, m: Modifiers) -> Option<String> {
    if matches!(key, Key::Escape) {
        return None;
    }
    let s = format(&KeyboardShortcut::new(m, key));
    crate::shortcuts::parse(&s).map(|_| s)
}

ui_mirror!(fn backtick_store() -> Option<String>);

/// Notes what the backtick key (left of 1) typed in `events`: the one-character text whose key, a
/// press of it without modifiers, comes right before it (egui-winit) or, when no press comes
/// before, right after it (eframe's web build with no text field focused). egui reports that key
/// as [`Key::Backtick`] on layouts where it types a character egui has no key for, such as `"` on
/// Turkish Q.
pub(crate) fn note_backtick_text(events: &[egui::Event]) {
    let is_press = |e: Option<&egui::Event>| matches!(e, Some(egui::Event::Key { pressed: true, .. }));
    let is_backtick =
        |e: Option<&egui::Event>| matches!(e, Some(egui::Event::Key { key: Key::Backtick, pressed: true, modifiers, .. }) if modifiers.is_none());
    let typed = events.iter().enumerate().rev().find_map(|(j, e)| match e {
        egui::Event::Text(t) if t.chars().count() == 1 && !t.chars().any(char::is_whitespace) => {
            let before = j.checked_sub(1).and_then(|j| events.get(j));
            (is_backtick(before) || (!is_press(before) && is_backtick(events.get(j + 1)))).then(|| t.clone())
        }
        _ => None,
    });
    if let Some(t) = typed
        && let Ok(mut store) = backtick_store().write()
        && store.as_deref() != Some(t.as_str())
    {
        *store = Some(t);
    }
}

/// The character the backtick key types on the layout in use, once a press of it has been seen,
/// when it is neither `` ` `` nor `~`.
pub(crate) fn backtick_text() -> Option<String> {
    backtick_store().read().ok().and_then(|t| t.clone()).filter(|t| t != "`" && t != "~")
}

/// `text` as the editor shows it: an unshifted backtick key shows the character it types on the
/// layout in use (`"` on Turkish Q), so it reads as the key the user pressed.
fn on_layout(text: String, typed: Option<&str>) -> String {
    let Some(typed) = typed else { return text };
    match vc_chord(&text) {
        Some(c) if c.key == craft_keymap::Key::Backtick && !c.mods.shift => match text.strip_suffix('~') {
            Some(mods) => format!("{mods}{typed}"),
            None => text,
        },
        _ => text,
    }
}

/// `text` with the backtick key shown as the character it types on the layout in use
/// ([`backtick_text`]), as the editor shows it.
pub(crate) fn as_typed(text: &str) -> String {
    on_layout(text.to_string(), backtick_text().as_deref())
}

// ---------- entries & conflicts ----------

#[derive(Clone, Debug)]
pub struct Entry {
    /// `tool:<id>` or a command id.
    pub key: String,
    pub label: String,
    /// Menu path ("Object › Arrange") or "Tools".
    pub group: String,
    pub is_tool: bool,
}

/// Every tool, command and panel the editor can give a shortcut; [`listed`] says which it lists.
pub fn entries() -> &'static [Entry] {
    static E: OnceLock<Vec<Entry>> = OnceLock::new();
    E.get_or_init(|| {
        let mut v: Vec<Entry> = vectorcraft_tools::catalog::all_tools()
            .map(|t| Entry { key: format!("tool:{}", t.id), label: t.label.to_string(), group: "Tools".into(), is_tool: true })
            .collect();
        let mut seen = HashSet::new();
        for c in vectorcraft_engine::command_specs() {
            // Commands outside the menus (panel menu items) are
            // listed when a key alone can run them; queries and aliases never are.
            let listed = if c.menu.is_empty() {
                c.shortcut.is_some() || (c.journal && !vectorcraft_engine::cmd::is_alias(c.id) && runs_without_params(c.params))
            } else {
                true
            };
            if !listed || !seen.insert(c.id) {
                continue;
            }
            let group = if c.menu.is_empty() { id_group(c.id) } else { c.menu.join(" › ") };
            v.push(Entry { key: c.id.into(), label: c.label.into(), group, is_tool: false });
        }
        v.extend(crate::state::all_panels().map(|(id, label)| Entry {
            key: format!("panel:{id}"),
            label: label.to_string(),
            group: "Window".into(),
            is_tool: false,
        }));
        // Each effect of the Effect menu, by its own key: they all run `effect.dialog` (#3296).
        v.extend(effect_items().iter().map(|e| Entry {
            key: format!("effect:{}", e.effect),
            label: e.label.clone(),
            group: e.group.clone(),
            is_tool: false,
        }));
        for (id, label, sc, params) in menus::UI_COMMANDS {
            if !seen.insert(id) || (sc.is_empty() && !params.starts_with("{}") && !params.starts_with("{path")) {
                continue;
            }
            v.push(Entry { key: id.to_string(), label: label.to_string(), group: id_group(id), is_tool: false });
        }
        v
    })
}

/// One Effect menu item a shortcut can be given (#3296): the effect's id, the command its item runs
/// (`effect.dialog`, or `effect.apply` for an effect without options), its label and its menu path.
#[derive(Clone, Debug)]
pub struct EffectItem {
    pub effect: String,
    pub command: &'static str,
    pub label: String,
    pub group: String,
}

/// The Effect menu's effect items, in menu order, each once.
pub fn effect_items() -> &'static [EffectItem] {
    static E: OnceLock<Vec<EffectItem>> = OnceLock::new();
    E.get_or_init(|| {
        fn walk(items: &[menus::Item], path: &mut Vec<String>, seen: &mut HashSet<String>, out: &mut Vec<EffectItem>) {
            for it in items {
                match it {
                    menus::Item::Cmd(label, id @ ("effect.dialog" | "effect.apply"), p) => {
                        if let Some(effect) = p.get("effect").and_then(serde_json::Value::as_str)
                            && seen.insert(effect.to_string())
                        {
                            out.push(EffectItem { effect: effect.to_string(), command: id, label: label.to_string(), group: path.join(" › ") });
                        }
                    }
                    menus::Item::Sub(name, children) => {
                        path.push(name.to_string());
                        walk(children, path, seen, out);
                        path.pop();
                    }
                    _ => {}
                }
            }
        }
        let mut out = vec![];
        let mut seen = HashSet::new();
        for (name, items) in menus::menu_tree() {
            if name == "Effect" {
                walk(&items, &mut vec![name.to_string()], &mut seen, &mut out);
            }
        }
        out
    })
}

/// Effective shortcut of the Effect menu item of `effect` (`effect:<id>`).
pub fn effect_shortcut(effect: &str) -> Option<&'static str> {
    effective(&format!("effect:{effect}"))
}

/// The group of a command no menu holds: the first part of its id, capitalised (`edit.x` → "Edit").
fn id_group(id: &str) -> String {
    let mut c = id.split('.').next().unwrap_or_default().chars();
    c.next().map(|f| f.to_uppercase().collect::<String>() + c.as_str()).unwrap_or_default()
}

/// Does a command's params doc (`{a?, b?} …`) say it runs with no params, as a shortcut runs it?
fn runs_without_params(params: &str) -> bool {
    params
        .strip_prefix('{')
        .and_then(|r| r.split_once('}'))
        .is_some_and(|(fields, _)| fields.split(',').all(|f| f.trim().is_empty() || f.trim_end().ends_with('?')))
}

/// Does the editor list `e` under `overrides`? An entry that [`needs_a_value`] is listed only while
/// the user has given it a shortcut.
fn listed(overrides: &Overrides, e: &Entry) -> bool {
    !needs_a_value(&e.key) || overrides.get(&crate::keymap::stored_key(&e.key)).is_some_and(|t| !t.is_empty())
}

/// Commands whose params are all optional that do nothing, or fail, when a key press runs them
/// with none, and that no item of the menu bar runs: Transparency and Opacity Mask Options need
/// a value to set, Align and Distribute a direction, Delete Swatch and Move Swatch a swatch name,
/// and the library and data set loaders a file, which their panel menu items ask for.
const NEEDS_A_PARAM: [&str; 16] = [
    "transparency.set",
    "transparency.setOpacityMask",
    "stroke.set",
    "layer.setProps",
    "object.align",
    "object.distribute",
    "swatch.delete",
    "swatch.move",
    "swatch.spotOptions",
    "edit.colors.adjustBalance",
    "swatch.library.load",
    "graphicStyle.loadLibrary",
    "symbol.loadLibrary",
    "brush.loadLibrary",
    "dataset.import",
    "variable.loadLibrary",
];

/// The (label, params) of each menu bar item, by command id.
fn menu_bar_items() -> &'static HashMap<&'static str, Vec<(&'static str, Value)>> {
    fn walk(items: &[menus::Item], out: &mut HashMap<&'static str, Vec<(&'static str, Value)>>) {
        for it in items {
            match it {
                menus::Item::Cmd(label, id, p) => out.entry(*id).or_default().push((*label, p.clone())),
                menus::Item::Sub(_, children) => walk(children, out),
                _ => {}
            }
        }
    }
    static ITEMS: OnceLock<HashMap<&'static str, Vec<(&'static str, Value)>>> = OnceLock::new();
    ITEMS.get_or_init(|| {
        let mut out = HashMap::new();
        for (_, items) in menus::menu_tree() {
            walk(&items, &mut out);
        }
        out
    })
}

fn is_bare(p: &Value) -> bool {
    p.as_object().is_none_or(|o| o.is_empty())
}

/// What a shortcut without params for command `id` runs when no menu bar item runs `id` without
/// params and every item that runs it gives the same params: what a click on that item runs
/// ([`menus::click_target`]), so Print Ink Fixes runs with its menu item's params and Clean Up…
/// opens its dialog.
pub(crate) fn menu_target(id: &str) -> Option<(String, Value)> {
    let items = menu_bar_items().get(id)?;
    let (label, p) = items.first().filter(|(_, p)| !is_bare(p))?;
    items.iter().all(|(_, q)| q == p).then(|| menus::click_target(label, id, p))
}

/// Is `key` a command with no default shortcut that a key press can't run: no item of the menu
/// bar runs it without params or with one set of params ([`menu_target`]), it opens no dialog when
/// run without them (as the Variables panel's commands do), and it is a query, whose answer a key
/// press drops (Select All Unused), a command of [`NEEDS_A_PARAM`], or a menu command whose params
/// doc names a field a call must give (File › Document Setup › Units, `{units}`)?
fn needs_a_value(key: &str) -> bool {
    static KEYS: OnceLock<HashSet<&'static str>> = OnceLock::new();
    KEYS.get_or_init(|| {
        // A menu item that runs the command itself with params of its own counts only when the
        // params doc names no required field: Edit › Find Next gives `find` empty, which it rejects.
        let runs = |c: &vectorcraft_engine::CommandSpec| {
            menu_bar_items().get(c.id).is_some_and(|ps| ps.iter().any(|(_, p)| is_bare(p)))
                || menu_target(c.id).is_some_and(|(id, _)| id != c.id || !names_a_required_field(c.params))
        };
        vectorcraft_engine::command_specs()
            .iter()
            .filter(|c| {
                c.shortcut.is_none()
                    && !runs(c)
                    && !crate::dialogs::variables::opens(c.id)
                    && (!c.journal || NEEDS_A_PARAM.contains(&c.id) || (!c.menu.is_empty() && names_a_required_field(c.params)))
            })
            .map(|c| c.id)
            .collect()
    })
    .contains(key)
}

/// Does a params doc name a field a call must give? Its fields are the top-level parts of its
/// first `{…}`. A field is optional when it is empty, starts with `…`, gives a default (`rows=10`)
/// or each of its names ends with `?` (`id?|ids?: [id…]`); `{index | indices}` names a required
/// field. A doc that does not start with `{` names none.
fn names_a_required_field(params: &str) -> bool {
    let required = |f: &str| {
        let f = f.trim();
        let end = f.find([':', '=', '(']).unwrap_or(f.len());
        !(f.is_empty() || f.starts_with('…') || f[end..].starts_with('=') || f[..end].split('|').all(|n| n.trim().ends_with('?')))
    };
    let Some(rest) = params.strip_prefix('{') else { return false };
    let (mut depth, mut quoted, mut start) = (0usize, false, 0);
    for (i, ch) in rest.char_indices() {
        match ch {
            '"' => quoted = !quoted,
            _ if quoted => {}
            '{' | '[' | '(' => depth += 1,
            '}' if depth == 0 => return required(&rest[start..i]),
            '}' | ']' | ')' => depth = depth.saturating_sub(1),
            ',' if depth == 0 => {
                if required(&rest[start..i]) {
                    return true;
                }
                start = i + 1;
            }
            _ => {}
        }
    }
    false
}

pub fn entry(key: &str) -> Option<&'static Entry> {
    entries().iter().find(|e| e.key == key)
}

/// Entries (other than `except`) whose effective shortcut equals `chord`.
pub fn conflicts_with(overrides: &Overrides, chord: &str, except: &str) -> Vec<String> {
    let Some(c) = vc_chord(chord) else { return vec![] };
    let km = keymap_with(overrides);
    let p = km.platform();
    let want = Trigger::single(c).effective(p);
    entries()
        .iter()
        .filter(|e| e.key != except)
        .filter(|e| km.bindings(&command_of(&e.key)).iter().any(|b| b.trigger.effective(p) == want))
        .map(|e| e.key.clone())
        .collect()
}

/// All chords used by more than one entry: (chord, keys).
pub fn all_conflicts(overrides: &Overrides) -> Vec<(String, Vec<String>)> {
    conflicts_in(&keymap_with(overrides))
}

/// [`all_conflicts`] of a keymap.
pub fn conflicts_in(km: &Keymap) -> Vec<(String, Vec<String>)> {
    let mut by: BTreeMap<String, Vec<String>> = BTreeMap::new();
    for c in km.conflicts().into_iter().filter(|c| c.kind == ConflictKind::Clash) {
        let keys = by.entry(crate::keymap::binding_text(&Binding::new(c.chord))).or_default();
        for k in [entry_key(&c.a.0), entry_key(&c.b.0)] {
            if !keys.contains(&k) {
                keys.push(k);
            }
        }
    }
    by.into_iter().collect()
}

/// Assign `chord` (None = remove, "default" handled by callers via [`reset_one`]) to `key` in
/// `overrides`. Conflicting entries lose the chord when `force`, otherwise it's an error.
pub fn assign(overrides: &mut Overrides, key: &str, chord: Option<&str>, force: bool) -> Result<Vec<String>, String> {
    let mut km = keymap_with(overrides);
    let removed = assign_in(&mut km, key, chord, force)?;
    *overrides = km.overrides().clone();
    Ok(removed)
}

/// [`assign`] on a keymap.
pub fn assign_in(km: &mut Keymap, key: &str, chord: Option<&str>, force: bool) -> Result<Vec<String>, String> {
    let command = command_of(key);
    if km.bindable(&command).is_none() {
        return Err(format!("unknown tool or command `{key}`"));
    }
    let c = match chord {
        None | Some("") => {
            // Fails only when the overrides hold the most entries they can.
            if !km.clear(&command) {
                return Err("too many changed shortcuts".into());
            }
            return Ok(vec![]);
        }
        Some(c) => c,
    };
    let chord = vc_chord(c).ok_or_else(|| format!("can't parse shortcut `{c}`"))?;
    if key.starts_with("tool:") && (chord.mods.cmd || chord.mods.ctrl || chord.mods.alt) {
        return Err("tool shortcuts must be a single key (optionally with Shift)".into());
    }
    let policy = if force { Policy::Steal } else { Policy::Refuse };
    match km.set_bindings(&command, vec![Binding::new(chord)], policy) {
        Ok(done) => {
            let mut removed: Vec<String> = vec![];
            for h in done.taken_from {
                let k = entry_key(&h.command);
                if !removed.contains(&k) {
                    removed.push(k);
                }
            }
            Ok(removed)
        }
        Err(AssignError::Taken(holders)) => {
            let names: Vec<String> = holders
                .iter()
                .map(|h| {
                    let k = entry_key(&h.command);
                    entry(&k).map_or(k, |e| e.label.clone())
                })
                .collect();
            Err(format!("{} is already used by {}", menus::pretty_shortcut(&vc_format(&chord)), names.join(", ")))
        }
        Err(AssignError::Reserved(_)) => Err(format!("{} is reserved by the system", menus::pretty_shortcut(&vc_format(&chord)))),
        Err(e) => Err(e.to_string()),
    }
}

pub fn reset_one(overrides: &mut Overrides, key: &str) {
    overrides.remove(&crate::keymap::stored_key(key));
}

/// Text shown for all active chords in a dialog row, with the backtick key shown as `typed`
/// ([`backtick_text`]).
fn dialog_shortcuts_with(km: &Keymap, key: &str, typed: Option<&str>) -> Option<String> {
    let shown = |s: String| menus::pretty_shortcut(&on_layout(s, typed));
    let bindings = km.bindings(&command_of(key));
    if bindings.len() > 1 {
        let primary = effective_with(km, key).map(shown)?;
        let additional = bindings.iter().skip(1).map(|b| shown(crate::keymap::binding_text(b)));
        return Some(std::iter::once(primary).chain(additional).collect::<Vec<_>>().join(" · "));
    }
    effective_with(km, key).map(shown)
}

/// Overrides of a preset (both presets are the registry defaults for now).
pub fn preset(name: &str) -> Option<Overrides> {
    PRESETS.contains(&set_name(name)).then(Overrides::new)
}

/// Export format: `{"format": "vectorcraft-shortcuts", "set": name, "overrides": {...}}`.
pub fn export_json(set: &str, overrides: &Overrides) -> Value {
    json!({"format": "vectorcraft-shortcuts", "version": 1, "set": set, "overrides": stored::to_value(overrides)})
}

pub fn import_json(v: &Value) -> Result<(String, Overrides), String> {
    let o = v.get("overrides").and_then(Value::as_object).ok_or("not a VectorCraft shortcut set (missing `overrides`)")?;
    let mut out = Overrides::new();
    for (k, v) in o {
        let s = v.as_str().ok_or_else(|| format!("shortcut for `{k}` must be a string"))?;
        if !s.is_empty() && normalize(s).is_none() {
            return Err(format!("can't parse shortcut `{s}` for `{k}`"));
        }
        crate::keymap::set_override(&mut out, k, &normalize(s).unwrap_or_default());
    }
    Ok((v.get("set").and_then(Value::as_str).map_or(CUSTOM, set_name).to_string(), out))
}

// ---------- UI commands ----------

pub fn open(app: &mut VectorcraftApp) {
    let ov = stored::to_value(&app.ui.shortcut_overrides);
    app.ui.dialog = Some(Dialog::new(
        "shortcuts",
        json!({"tab": "tools", "query": "", "set": app.ui.shortcut_set, "overrides": ov, "__recording": "", "__selected": "", "__message": "", "__conflict": ""}),
    ));
}

fn dialog_overrides(d: &Dialog) -> Overrides {
    d.fields.get("overrides").map(|v| stored::from_value(v.clone())).unwrap_or_default()
}

/// OK: commit the working set.
pub fn confirm(app: &mut VectorcraftApp) -> Result<Value, String> {
    let Some(d) = app.ui.dialog.clone() else { return Err("no dialog open".into()) };
    app.ui.shortcut_overrides = dialog_overrides(&d);
    app.ui.shortcut_set = d.str("set");
    app.ui.dialog = None;
    sync(&app.ui);
    Ok(json!({"overrides": app.ui.shortcut_overrides.len()}))
}

/// `shortcuts.*` UI commands. `None` = not ours.
pub fn run_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<Value, String>> {
    let s = |k: &str| p.get(k).and_then(Value::as_str).map(str::to_string);
    let r = match id {
        "edit.keyboardShortcuts" => {
            open(app);
            Ok(Value::Null)
        }
        "shortcuts.set" => {
            let key = s("id").unwrap_or_default();
            let mut ov = app.ui.shortcut_overrides.clone();
            let r = if p.get("shortcut").is_some_and(Value::is_null) {
                reset_one(&mut ov, &key);
                Ok(vec![])
            } else {
                assign(&mut ov, &key, s("shortcut").as_deref(), p.get("force").and_then(Value::as_bool).unwrap_or(false))
            };
            r.map(|removed| {
                app.ui.shortcut_overrides = ov;
                app.ui.shortcut_set = CUSTOM.into();
                sync(&app.ui);
                json!({"id": key, "shortcut": effective_in(&app.ui.shortcut_overrides, &key), "removedFrom": removed})
            })
        }
        "shortcuts.list" => {
            let q = s("query").unwrap_or_default().to_lowercase();
            let km = keymap_with(&app.ui.shortcut_overrides);
            let ov = km.overrides();
            Ok(Value::Array(
                entries()
                    .iter()
                    .filter(|e| listed(ov, e))
                    .filter(|e| q.is_empty() || e.label.to_lowercase().contains(&q) || e.key.to_lowercase().contains(&q))
                    .map(|e| json!({"id": e.key, "label": e.label, "group": e.group, "shortcut": effective_with(&km, &e.key), "default": default_of(&e.key), "overridden": crate::keymap::has_override(ov, &e.key)}))
                    .collect(),
            ))
        }
        "shortcuts.conflicts" => {
            Ok(json!(all_conflicts(&app.ui.shortcut_overrides).into_iter().map(|(c, k)| json!({"shortcut": c, "ids": k})).collect::<Vec<_>>()))
        }
        "shortcuts.reset" => {
            app.ui.shortcut_overrides.clear();
            app.ui.shortcut_set = PRESETS[0].into();
            sync(&app.ui);
            Ok(Value::Null)
        }
        "shortcuts.preset" => match s("name").as_deref().map(set_name).and_then(|n| preset(n).map(|p| (n.to_string(), p))) {
            Some((n, p)) => {
                app.ui.shortcut_overrides = p;
                app.ui.shortcut_set = n;
                sync(&app.ui);
                Ok(Value::Null)
            }
            None => Err(format!("unknown preset (one of {})", PRESETS.join(", "))),
        },
        "shortcuts.export" => {
            let v = export_json(&app.ui.shortcut_set, &app.ui.shortcut_overrides);
            let bytes = serde_json::to_vec_pretty(&v).unwrap_or_default();
            let pick = crate::FilePick {
                filters: vec![crate::FilePick::filter("Shortcut sets", &["json"])],
                ..crate::FilePick::named("VectorCraft Shortcuts.json")
            };
            let path = s("path").or_else(|| crate::picks::save(app, &pick));
            match path {
                Some(path) => match app.services.write.as_mut() {
                    Some(w) => w(&path, &bytes).map(|_| json!({"path": path})),
                    None => Err("no file writer".into()),
                },
                // Its save dialog is open: the file is written when it answers.
                None if app.file_dialog_open() => Err("cancelled".into()),
                None => match app.services.download.as_mut() {
                    Some(dl) => dl("VectorCraft Shortcuts.json", &bytes).map(|()| Value::Null),
                    None => Ok(v),
                },
            }
        }
        "shortcuts.import" => {
            let data = if let Some(v) = p.get("data") {
                Ok(v.clone())
            } else {
                let pick = crate::FilePick {
                    filters: vec![crate::FilePick::filter("Shortcut sets", crate::dialogs::shortcut_import::IMPORT_EXTS)],
                    ..Default::default()
                };
                let path = s("path").or_else(|| crate::picks::open(app, &pick));
                // A `.kys` file is read by Import Shortcut Set, up to its reader's cap.
                if let Some(path) = path.as_deref().filter(|p| crate::dialogs::shortcut_import::is_kys(p)) {
                    return Some(crate::dialogs::shortcut_import::command(app, &json!({ "path": path })));
                }
                match (path, app.services.read.as_ref()) {
                    (Some(path), Some(r)) => match r(&path) {
                        // A set another app saved as text opens Import Shortcut Set.
                        Ok(b) if crate::dialogs::shortcut_import::is_text_set(&path, &b) => {
                            return Some(crate::dialogs::shortcut_import::open(app, &path, &b));
                        }
                        b => b.and_then(|b| serde_json::from_slice(&b).map_err(|e| e.to_string())),
                    },
                    (None, _) => Err("cancelled".into()),
                    (_, None) => Err("no file reader".into()),
                }
            };
            data.and_then(|v| import_json(&v)).map(|(set, ov)| {
                let n = ov.len();
                app.ui.shortcut_overrides = ov;
                app.ui.shortcut_set = set;
                sync(&app.ui);
                if let Some(d) = app.ui.dialog.as_mut().filter(|d| d.kind == "shortcuts") {
                    d.fields.insert("overrides".into(), stored::to_value(&app.ui.shortcut_overrides));
                    d.fields.insert("set".into(), json!(app.ui.shortcut_set));
                }
                json!({"overrides": n})
            })
        }
        _ => return None,
    };
    Some(r)
}

/// While recording (here or in Import Shortcut Set), Escape cancels the recording instead of closing
/// the dialog.
pub fn is_recording(app: &VectorcraftApp) -> bool {
    app.ui
        .dialog
        .as_ref()
        .is_some_and(|d| (d.kind == "shortcuts" || d.kind == crate::dialogs::shortcut_import::KIND) && !d.str("__recording").is_empty())
}

// ---------- dialog ----------

/// The dialog's working set as a keymap, with each entry's shortcut text (in [`entries`] order)
/// and the number of conflicts, kept between frames while the set is unchanged.
struct DialogView {
    /// The dialog's `overrides` field this was built from.
    source: Value,
    /// The [`backtick_text`] the texts show.
    backtick: Option<String>,
    keymap: Keymap,
    texts: Vec<Option<String>>,
    conflicts: usize,
}

impl DialogView {
    fn new(overrides: Overrides) -> DialogView {
        let keymap = keymap_with(&overrides);
        let backtick = backtick_text();
        let texts = entries().iter().map(|e| dialog_shortcuts_with(&keymap, &e.key, backtick.as_deref())).collect();
        let conflicts = conflicts_in(&keymap).len();
        DialogView { source: stored::to_value(keymap.overrides()), backtick, keymap, texts, conflicts }
    }

    /// The view of `d`'s working set, from the cache unless the set or the backtick key's
    /// character changed. The dialog's `overrides` field is left in its stored form.
    fn of(ctx: &egui::Context, d: &mut Dialog) -> Arc<DialogView> {
        let id = egui::Id::unique("dialog-shortcuts-view");
        let source = d.fields.get("overrides").unwrap_or(&Value::Null);
        let backtick = backtick_text();
        if let Some(v) = ctx.data(|m| m.get_temp::<Arc<DialogView>>(id)).filter(|v| v.source == *source && v.backtick == backtick) {
            return v;
        }
        let v = Arc::new(DialogView::new(dialog_overrides(d)));
        d.fields.insert("overrides".into(), v.source.clone());
        ctx.data_mut(|m| m.insert_temp(id, v.clone()));
        v
    }
}

pub fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
    let Some(mut d) = app.ui.dialog.clone() else { return };
    let t = Tokens::get(ctx);
    ctx.input(|i| note_backtick_text(&i.events));
    // The working set, as a keymap: copied only by an edit this frame.
    let view = DialogView::of(ctx, &mut d);
    let mut km = Cow::Borrowed(&view.keymap);
    let mut ok = false;
    let mut cancel = false;
    drop_hidden(&mut d, km.overrides());
    let recording = d.str("__recording");
    // Record a chord (before widgets see the keys). Modifiers held down are part of the next key's
    // chord, not a chord of their own.
    if !recording.is_empty() {
        let ev = ctx.input(|i| {
            i.events.iter().find_map(|e| match e {
                egui::Event::Key { key, pressed: true, modifiers, .. } if !crate::shortcuts::is_modifier(*key) => Some((*key, *modifiers)),
                _ => None,
            })
        });
        if let Some((key, m)) = ev {
            ctx.input_mut(|i| i.events.clear());
            if key == Key::Escape {
                d.fields.insert("__recording".into(), json!(""));
            } else if let Some(chord) = chord_from_event(key, m) {
                record(&mut d, km.to_mut(), &recording, &chord);
            }
        }
    }
    crate::dialogs::modal::show(ctx, tl!("Keyboard Shortcuts"), egui::Id::unique("dialog-shortcuts"), -20.0, 20, |ui| {
        ui.set_width(640.0);
        crate::dialogs::modal::heading(ui, tl!("Keyboard Shortcuts"));
        ui.add_space(10.0);
        // Set row.
        ui.horizontal(|ui| {
            ui.label(egui::RichText::new(tl!("Set:")).color(t.text_dim));
            let cur = d.str("set");
            let mut opts: Vec<&str> = PRESETS.to_vec();
            if !PRESETS.contains(&cur.as_str()) {
                opts.push(CUSTOM);
            }
            // The sets listed are ours (translated); a set read from an imported file shows
            // its name as it is.
            if let Some(&name) = crate::dialogs::mixed_dropdown(ui, "kbset", &cur, &opts, 200.0, |_| true).and_then(|i| opts.get(i))
                && let Some(p) = preset(name)
            {
                km.to_mut().set_overrides(p);
                d.fields.insert("set".into(), json!(name));
                d.fields.insert("__message".into(), json!(""));
            }
            ui.add_space(12.0);
            if ui.button(tl!("Import…")).clicked() {
                d.fields.insert("__import".into(), json!(true));
            }
            if ui.button(tl!("Export…")).clicked() {
                d.fields.insert("__export".into(), json!(true));
            }
            if ui.button(tl!("Reset to Defaults")).clicked() {
                km.to_mut().reset_all();
                d.fields.insert("set".into(), json!(PRESETS[0]));
                d.fields.insert("__message".into(), json!(tl!("All shortcuts reset to defaults.")));
            }
        });
        ui.add_space(8.0);
        // Tabs + search.
        ui.horizontal(|ui| {
            let tab = d.str("tab");
            for (id, label) in [("tools", "Tools"), ("menu", "Menu Commands")] {
                if ui.selectable_label(tab == id, egui::RichText::new(tl!(label)).font(theme::semibold(12.5))).clicked() {
                    d.fields.insert("tab".into(), json!(id));
                }
            }
            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                let mut q = d.str("query");
                if ui.add(egui::TextEdit::singleline(&mut q).align(egui::Align2::LEFT_CENTER).hint_text(tl!("Search")).desired_width(200.0)).changed()
                {
                    d.fields.insert("query".into(), json!(q));
                }
            });
        });
        ui.add_space(6.0);
        let tools = d.str("tab") != "menu";
        let q = d.str("query").to_lowercase();
        let selected = d.str("__selected");
        let rec = d.str("__recording");
        let scroll_to = d.fields.remove("__scrollTo").and_then(|v| v.as_str().map(str::to_string));
        egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(egui::Margin::same(4)).show(ui, |ui| {
            ui.horizontal(|ui| {
                ui.allocate_ui_with_layout(egui::vec2(360.0, 16.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
                    ui.set_min_width(360.0);
                    ui.label(egui::RichText::new(if tools { tl!("Tool") } else { tl!("Command") }).color(t.text_dim).size(11.0));
                });
                ui.label(egui::RichText::new(tl!("Shortcut")).color(t.text_dim).size(11.0));
            });
            egui::ScrollArea::vertical().max_height(360.0).auto_shrink([false, false]).show(ui, |ui| {
                for (i, e) in entries().iter().enumerate().filter(|(_, e)| e.is_tool == tools && listed(km.overrides(), e)) {
                    let sc = match &km {
                        Cow::Borrowed(_) => view.texts.get(i).cloned().flatten(),
                        Cow::Owned(km) => dialog_shortcuts_with(km, &e.key, view.backtick.as_deref()),
                    };
                    let matches = e.label.to_lowercase().contains(&q)
                        || tl!(&e.label).to_lowercase().contains(&q)
                        || e.group.to_lowercase().contains(&q)
                        || tl!(&e.group).to_lowercase().contains(&q)
                        || sc.as_deref().is_some_and(|s| s.to_lowercase().contains(&q));
                    if !q.is_empty() && !matches {
                        continue;
                    }
                    let row = ui.horizontal(|ui| {
                        let name = if e.is_tool || e.group.is_empty() {
                            tl!(&e.label).to_string()
                        } else {
                            format!("{} › {}", tl!(&e.group), tl!(&e.label))
                        };
                        let r = ui
                            .allocate_ui_with_layout(egui::vec2(360.0, 20.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
                                ui.set_min_width(360.0);
                                ui.add(egui::Button::selectable(selected == e.key, egui::RichText::new(name).color(t.text)).truncate())
                            })
                            .inner;
                        if r.clicked() {
                            d.fields.insert("__selected".into(), json!(e.key));
                        }
                        let label = if rec == e.key { tl!("Press keys…").to_string() } else { sc.unwrap_or_else(|| "—".into()) };
                        let changed = crate::keymap::has_override(km.overrides(), &e.key);
                        let txt = egui::RichText::new(label).color(if changed { t.accent } else { t.text });
                        let b = ui
                            .add_sized([150.0, 20.0], egui::Button::new(txt).selected(rec == e.key))
                            .on_hover_text(tl!("Click, then press the new shortcut (Esc cancels)"));
                        if b.clicked() {
                            d.fields.insert("__recording".into(), json!(e.key));
                            d.fields.insert("__selected".into(), json!(e.key));
                        }
                    });
                    if scroll_to.as_deref() == Some(e.key.as_str()) {
                        row.response.scroll_to_me(Some(egui::Align::Center));
                    }
                }
            });
        });
        ui.add_space(6.0);
        // Selected-row actions + message.
        ui.horizontal(|ui| {
            let sel = d.str("__selected");
            ui.add_enabled_ui(!sel.is_empty(), |ui| {
                if ui.button(tl!("Clear")).on_hover_text(tl!("Remove the shortcut")).clicked() {
                    if let Err(e) = assign_in(km.to_mut(), &sel, None, true) {
                        d.fields.insert("__message".into(), json!(e));
                    }
                    d.fields.insert("set".into(), json!(CUSTOM));
                }
                if ui.button(tl!("Use Default")).clicked() {
                    km.to_mut().reset(&command_of(&sel));
                }
            });
            let conflict = d.str("__conflict");
            if !conflict.is_empty() && ui.button(tl!("Go to Conflict")).clicked() {
                let tab = if conflict.starts_with("tool:") { "tools" } else { "menu" };
                d.fields.insert("tab".into(), json!(tab));
                d.fields.insert("query".into(), json!(""));
                d.fields.insert("__selected".into(), json!(conflict));
                d.fields.insert("__scrollTo".into(), json!(conflict));
                d.fields.insert("__conflict".into(), json!(""));
            }
        });
        let msg = d.str("__message");
        if !msg.is_empty() {
            ui.label(egui::RichText::new(msg).color(t.accent_strong).size(11.5));
        }
        let n = match &km {
            Cow::Borrowed(_) => view.conflicts,
            Cow::Owned(km) => conflicts_in(km).len(),
        };
        if n > 0 {
            ui.label(
                egui::RichText::new(crate::i18n::tn(
                    n as u64,
                    "{n} shortcut is assigned more than once",
                    "{n} shortcuts are assigned more than once",
                ))
                .color(t.text_dim)
                .size(11.0),
            );
        }
        ui.add_space(12.0);
        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
            if widgets::primary_button(ui, tl!("OK")).clicked() {
                ok = true;
            }
            ui.add_space(8.0);
            if widgets::secondary_button(ui, tl!("Cancel")).clicked() {
                cancel = true;
            }
        });
    });
    if let Cow::Owned(km) = &km {
        d.fields.insert("overrides".into(), stored::to_value(km.overrides()));
    }
    let import = d.fields.remove("__import").is_some();
    let export = d.fields.remove("__export").is_some();
    app.ui.dialog = Some(d);
    // Their file dialogs, shown off the UI thread, import into or export from the dialog as it is
    // when they answer.
    if import {
        crate::picks::button(app, import_into_dialog);
    }
    if export {
        crate::picks::button(app, export_from_dialog);
    }
    if cancel {
        app.ui.dialog = None;
    } else if ok && let Err(e) = confirm(app) {
        app.status(e);
    }
}

/// The Keyboard Shortcuts dialog, while it is open.
fn shortcuts_dialog(app: &VectorcraftApp) -> bool {
    app.ui.dialog.as_ref().is_some_and(|d| d.kind == "shortcuts")
}

/// The dialog's Import…: the imported set replaces its working set (committed on OK like other
/// edits).
fn import_into_dialog(app: &mut VectorcraftApp) {
    if !shortcuts_dialog(app) {
        app.status(crate::picks::dialog_gone());
        return;
    }
    let saved = (app.ui.shortcut_overrides.clone(), app.ui.shortcut_set.clone());
    match run_command(app, "shortcuts.import", &json!({})) {
        Some(Ok(_)) => {
            let (o, s) = (app.ui.shortcut_overrides.clone(), app.ui.shortcut_set.clone());
            (app.ui.shortcut_overrides, app.ui.shortcut_set) = saved;
            sync(&app.ui);
            if let Some(d) = app.ui.dialog.as_mut().filter(|d| d.kind == "shortcuts") {
                d.fields.insert("overrides".into(), stored::to_value(&o));
                d.fields.insert("set".into(), json!(s));
                d.fields.insert("__message".into(), json!(tl!("Imported. Press OK to keep the imported set.")));
            }
        }
        Some(Err(e)) if e != "cancelled" => app.status(e),
        _ => {}
    }
}

/// The dialog's Export…: its working set, as edited so far.
fn export_from_dialog(app: &mut VectorcraftApp) {
    if !shortcuts_dialog(app) {
        app.status(crate::picks::dialog_gone());
        return;
    }
    let (ov, set) = app.ui.dialog.as_ref().map(|d| (dialog_overrides(d), d.str("set"))).unwrap_or_default();
    let saved = std::mem::replace(&mut app.ui.shortcut_overrides, ov);
    let saved_set = std::mem::replace(&mut app.ui.shortcut_set, set);
    if let Some(Err(e)) = run_command(app, "shortcuts.export", &json!({})) {
        app.status(e);
    }
    app.ui.shortcut_overrides = saved;
    app.ui.shortcut_set = saved_set;
}

/// A row that left the list (Clear, Use Default, Reset to Defaults or another set took the
/// shortcut from a command that needs a value) is no longer recorded, selected or offered by Go to
/// Conflict, so the next key press does not give the hidden command a shortcut.
fn drop_hidden(d: &mut Dialog, overrides: &Overrides) {
    for field in ["__recording", "__selected", "__conflict"] {
        let key = d.str(field);
        if !key.is_empty() && entry(&key).is_none_or(|e| !listed(overrides, e)) {
            d.fields.insert(field.into(), json!(""));
        }
    }
}

/// Apply a recorded chord to `key` in the working set, warning about (and resolving) conflicts.
fn record(d: &mut Dialog, km: &mut Keymap, key: &str, chord: &str) {
    d.fields.insert("__recording".into(), json!(""));
    match assign_in(km, key, Some(chord), true) {
        Ok(removed) => {
            d.fields.insert("set".into(), json!(CUSTOM));
            if let Some(first) = removed.first() {
                let names: Vec<String> = removed.iter().map(|k| entry(k).map(|e| e.label.clone()).unwrap_or(k.clone())).collect();
                d.fields.insert(
                    "__message".into(),
                    json!(crate::i18n::fmt(
                        tl!("⚠ {chord} was already used by {names} — it has been removed there."),
                        &[
                            ("chord", &menus::pretty_shortcut(&on_layout(chord.to_string(), backtick_text().as_deref()))),
                            ("names", &names.join(", "))
                        ]
                    )),
                );
                d.fields.insert("__conflict".into(), json!(first));
            } else {
                d.fields.insert("__message".into(), json!(""));
                d.fields.insert("__conflict".into(), json!(""));
            }
        }
        Err(e) => {
            d.fields.insert("__message".into(), json!(e));
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn format_parse_round_trip_for_every_default() {
        for e in entries() {
            if let Some(s) = default_of(&e.key)
                && let Some(sc) = crate::shortcuts::parse(s)
            {
                let f = format(&sc);
                assert_eq!(crate::shortcuts::parse(&f), Some(sc), "{} `{s}` → `{f}`", e.key);
                assert_eq!(normalize(&f).as_deref(), Some(f.as_str()));
            }
        }
    }

    #[test]
    fn normalize_is_order_insensitive() {
        assert_eq!(normalize("Shift+Cmd+Alt+K"), normalize("Cmd+Alt+Shift+K"));
        assert_eq!(normalize("Cmd+Shift+]").as_deref(), Some("Cmd+Shift+]"));
        assert_eq!(normalize("Cmd+="), Some("Cmd+=".into()));
        assert!(normalize("Hyper+K").is_none());
    }

    #[test]
    fn chord_from_recorded_event() {
        assert_eq!(chord_from_event(Key::K, Modifiers::COMMAND | Modifiers::SHIFT).as_deref(), Some("Cmd+Shift+K"));
        assert_eq!(chord_from_event(Key::P, Modifiers::NONE).as_deref(), Some("P"));
        assert_eq!(chord_from_event(Key::Escape, Modifiers::NONE), None);
        // A modifier's own key press is no chord (#487).
        assert_eq!(chord_from_event(Key::ShiftLeft, Modifiers::SHIFT), None);
        assert!(normalize("ShiftLeft").is_none() && normalize("Cmd+ControlRight").is_none());
    }

    #[test]
    fn clearing_a_row_that_leaves_the_list_stops_its_recording() {
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        crate::keymap::set_override(&mut app.ui.shortcut_overrides, "document.setUnits", "Cmd+Alt+Shift+F12");
        crate::keymap::set_override(&mut app.ui.shortcut_overrides, "edit.duplicate", "Cmd+Alt+Shift+F11");
        open(&mut app);
        let mut d = app.ui.dialog.clone().unwrap();
        let start = keymap_with(&dialog_overrides(&d));
        let set = |d: &mut Dialog, key: &str| {
            d.fields.insert("__recording".into(), json!(key));
            d.fields.insert("__selected".into(), json!(key));
        };
        let state = |d: &Dialog| (d.str("__recording"), d.str("__selected"));
        // Clear, and Use Default, take the row out of the list: its recording stops.
        let mut km = start.clone();
        set(&mut d, "document.setUnits");
        assign_in(&mut km, "document.setUnits", None, true).unwrap();
        drop_hidden(&mut d, km.overrides());
        assert_eq!(state(&d), (String::new(), String::new()));
        let mut km = start.clone();
        set(&mut d, "document.setUnits");
        km.reset(&command_of("document.setUnits"));
        drop_hidden(&mut d, km.overrides());
        assert_eq!(state(&d), (String::new(), String::new()));
        // A row that stays listed keeps its recording, and so does a tool's.
        let mut km = start.clone();
        set(&mut d, "edit.duplicate");
        assign_in(&mut km, "edit.duplicate", None, true).unwrap();
        drop_hidden(&mut d, km.overrides());
        assert_eq!(state(&d), ("edit.duplicate".to_string(), "edit.duplicate".to_string()));
        set(&mut d, "tool:groupSelection");
        drop_hidden(&mut d, km.overrides());
        assert_eq!(state(&d), ("tool:groupSelection".to_string(), "tool:groupSelection".to_string()));
        // A chord taken from a row that then leaves the list offers no Go to Conflict for it.
        let mut km = start.clone();
        record(&mut d, &mut km, "edit.duplicate", "Cmd+Alt+Shift+F12");
        assert_eq!(d.str("__conflict"), "document.setUnits");
        drop_hidden(&mut d, km.overrides());
        assert_eq!(d.str("__conflict"), "");
        // A conflict with a row that stays listed is kept.
        let mut km = start.clone();
        record(&mut d, &mut km, "document.setUnits", "Cmd+Alt+Shift+F11");
        drop_hidden(&mut d, km.overrides());
        assert_eq!(d.str("__conflict"), "edit.duplicate");
    }

    #[test]
    fn a_modifier_pressed_while_recording_waits_for_the_key() {
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        open(&mut app);
        app.ui.dialog.as_mut().unwrap().fields.insert("__recording".into(), json!("tool:groupSelection"));
        let ctx = egui::Context::default();
        theme::install_fonts(&ctx);
        let mut press = |key, modifiers| {
            let events = vec![egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }];
            let mut out = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| show(&mut app, ui.ctx()));
            out.textures_delta.clear();
            app.ui.dialog.clone().unwrap()
        };
        // egui reports Shift's own key press first (#487): the recording goes on.
        assert_eq!(press(Key::ShiftLeft, Modifiers::SHIFT).str("__recording"), "tool:groupSelection");
        let d = press(Key::A, Modifiers::SHIFT);
        assert_eq!(d.str("__recording"), "");
        assert_eq!(crate::keymap::override_text(&dialog_overrides(&d), "tool:groupSelection").as_deref(), Some("Shift+A"));
    }

    /// On Turkish Q the key left of 1 types `"`, which egui reports as the backtick key: the
    /// recorded shortcut is that key, saved as `~` as before, and its row shows `"`. On a US
    /// layout the row still shows `~`.
    #[test]
    fn the_backtick_key_shows_what_it_types() {
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        open(&mut app);
        let ctx = egui::Context::default();
        theme::install_fonts(&ctx);
        let at = entries().iter().position(|e| e.key == "edit.clear").unwrap();
        let press = |key| egui::Event::Key { key, physical_key: Some(key), pressed: true, repeat: false, modifiers: Modifiers::NONE };
        let text = |t: &str| egui::Event::Text(t.into());
        let mut record_with = |events: Vec<egui::Event>| {
            app.ui.dialog.as_mut().unwrap().fields.insert("__recording".into(), json!("edit.clear"));
            let mut out = ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| show(&mut app, ui.ctx()));
            out.textures_delta.clear();
            let d = app.ui.dialog.clone().unwrap();
            let shown = DialogView::new(dialog_overrides(&d)).texts[at].clone();
            (crate::keymap::override_text(&dialog_overrides(&d), "edit.clear"), shown)
        };
        assert_eq!(record_with(vec![press(Key::Backtick), text("\"")]), (Some("~".to_string()), Some("\"".to_string())));
        assert_eq!(record_with(vec![press(Key::Backtick), text("`")]), (Some("~".to_string()), Some("~".to_string())));
        // eframe's web build with no text field focused sends the text before its key.
        assert_eq!(record_with(vec![text("\""), press(Key::Backtick)]), (Some("~".to_string()), Some("\"".to_string())));
        // A text right after another key's press is that key's.
        note_backtick_text(&[press(Key::Num2), text("'"), press(Key::Backtick)]);
        assert_eq!(backtick_text().as_deref(), Some("\""));
        note_backtick_text(&[text("`"), press(Key::Backtick)]);
        assert_eq!(backtick_text(), None);
        // Only the unshifted key types that character.
        assert_eq!(on_layout("Shift+~".into(), Some("\"")), "Shift+~");
        assert_eq!(on_layout("Cmd+~".into(), Some("\"")), "Cmd+\"");
        assert_eq!(on_layout("Cmd+K".into(), Some("\"")), "Cmd+K");
    }

    #[test]
    fn menus_and_tooltips_show_the_backtick_key_as_it_types() {
        let mut ui = UiState::default();
        // Not Cmd+~: macOS reserves it, so the override would leave Edit › Clear on Delete there.
        crate::keymap::set_override(&mut ui.shortcut_overrides, "edit.clear", "Alt+~");
        crate::keymap::set_override(&mut ui.shortcut_overrides, "tool:measure", "~");
        sync(&ui);
        let measure = vectorcraft_tools::tool_info("measure").unwrap();
        let press = |key| egui::Event::Key { key, physical_key: Some(key), pressed: true, repeat: false, modifiers: Modifiers::NONE };
        let clear = || menus::shown_shortcut(menus::shortcut_of("edit.clear").unwrap());
        note_backtick_text(&[press(Key::Backtick), egui::Event::Text("`".into())]);
        assert_eq!(clear(), menus::pretty_shortcut("Alt+~"));
        assert!(crate::toolbar::tip(measure).ends_with("(~)"));
        note_backtick_text(&[press(Key::Backtick), egui::Event::Text("\"".into())]);
        assert_eq!(clear(), menus::pretty_shortcut("Alt+\""));
        assert!(crate::toolbar::tip(measure).ends_with("(\")"), "{}", crate::toolbar::tip(measure));
        assert_eq!(menus::shown_shortcut("Shift+~"), menus::pretty_shortcut("Shift+~"));
        sync(&UiState::default());
    }

    #[test]
    fn saved_modifier_only_overrides_give_the_default_back() {
        let mut ui = UiState::default();
        crate::keymap::set_override(&mut ui.shortcut_overrides, "tool:groupSelection", "Shift+ShiftLeft");
        crate::keymap::set_override(&mut ui.shortcut_overrides, "edit.preferences", "");
        let ui = ui.sanitized();
        assert!(!crate::keymap::has_override(&ui.shortcut_overrides, "tool:groupSelection"));
        assert_eq!(crate::keymap::override_text(&ui.shortcut_overrides, "edit.preferences").as_deref(), Some(""));
    }

    #[test]
    fn override_beats_default_and_empty_removes() {
        let mut ov = Overrides::new();
        assert_eq!(effective_in(&ov, "edit.preferences").as_deref(), Some("Cmd+K"));
        crate::keymap::set_override(&mut ov, "edit.preferences", "Cmd+Alt+Shift+9");
        assert_eq!(effective_in(&ov, "edit.preferences").as_deref(), Some("Cmd+Alt+Shift+9"));
        crate::keymap::set_override(&mut ov, "edit.preferences", "");
        assert_eq!(effective_in(&ov, "edit.preferences"), None);
        assert_eq!(effective_in(&Overrides::new(), "tool:pen").as_deref(), Some("P"));
    }

    #[test]
    fn global_override_reaches_shortcut_of_and_tools() {
        let mut ui = UiState::default();
        crate::keymap::set_override(&mut ui.shortcut_overrides, "test.nonexistent", "Cmd+Alt+Shift+F9");
        crate::keymap::set_override(&mut ui.shortcut_overrides, "tool:measure", "Shift+9");
        let g = GENERATION.load(Ordering::Relaxed);
        sync(&ui);
        assert!(GENERATION.load(Ordering::Relaxed) > g);
        assert_eq!(menus::shortcut_of("test.nonexistent"), Some("Cmd+Alt+Shift+F9"));
        assert_eq!(tool_shortcut("measure"), Some("Shift+9"));
        assert_eq!(tool_for_key("Shift+9"), Some("measure"));
        sync(&UiState::default());
        assert_eq!(menus::shortcut_of("test.nonexistent"), None);
    }

    #[test]
    fn another_tests_frames_leave_this_tests_mirror_alone() {
        let mut ui = UiState::default();
        crate::keymap::set_override(&mut ui.shortcut_overrides, "tool:measure", "Shift+8");
        crate::workspaces::save_as(&mut ui, "Mine").unwrap();
        sync(&ui);
        // What each frame of a test running in parallel does with its default state.
        std::thread::spawn(|| sync(&UiState::default())).join().unwrap();
        assert_eq!(tool_shortcut("measure"), Some("Shift+8"));
        assert!(crate::workspaces::menu_items().iter().any(|i| matches!(i, menus::Item::Cmd("Mine", ..))));
    }

    #[test]
    fn assign_detects_conflicts() {
        let mut ov = Overrides::new();
        // ⌘K is Preferences.
        let err = assign(&mut ov, "file.revert", Some("Cmd+K"), false).unwrap_err();
        assert!(err.contains("Preferences"), "{err}");
        assert!(ov.is_empty());
        assert_eq!(conflicts_with(&ov, "Cmd+K", "file.revert"), vec!["edit.preferences".to_string()]);
    }

    #[test]
    fn forced_assign_moves_the_chord() {
        let mut ov = Overrides::new();
        let removed = assign(&mut ov, "file.revert", Some("Cmd+K"), true).unwrap();
        assert_eq!(removed, vec!["edit.preferences".to_string()]);
        assert_eq!(effective_in(&ov, "file.revert").as_deref(), Some("Cmd+K"));
        assert_eq!(effective_in(&ov, "edit.preferences"), None);
        assert!(conflicts_with(&ov, "Cmd+K", "file.revert").is_empty());
    }

    #[test]
    fn assigning_the_default_drops_the_override() {
        let mut ov = Overrides::new();
        assign(&mut ov, "tool:pen", Some("Shift+9"), false).unwrap();
        assert_eq!(ov.len(), 1);
        assign(&mut ov, "tool:pen", Some("P"), false).unwrap();
        assert!(ov.is_empty());
    }

    #[test]
    fn tool_shortcuts_must_be_single_keys() {
        let mut ov = Overrides::new();
        assert!(assign(&mut ov, "tool:pen", Some("Cmd+Alt+Shift+F9"), true).is_err());
        assert!(assign(&mut ov, "tool:bogus", Some("Q"), true).is_err());
    }

    #[test]
    fn export_import_round_trip() {
        let mut ov = Overrides::new();
        crate::keymap::set_override(&mut ov, "tool:pen", "Shift+9");
        crate::keymap::set_override(&mut ov, "edit.preferences", "");
        let v = export_json("Mine", &ov);
        let (set, back) = import_json(&v).unwrap();
        assert_eq!(set, "Mine");
        assert_eq!(back, ov);
        assert!(import_json(&json!({"overrides": {"x": "Cmd+Nope+Q"}})).is_err());
        assert!(import_json(&json!({})).is_err());
    }

    /// The dialog's Import… leaves an action its function key when the imported set gives the key
    /// to a command, through both Cancel and OK.
    #[test]
    fn importing_into_the_dialog_preserves_action_keys_on_ok() {
        use crate::panels::actions::{Action, ActionSet, FunctionKey};
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        let f15 = FunctionKey { key: 15, cmd: false, shift: false };
        let mut nudge = Action::new("Nudge", vec![]);
        nudge.key = Some(f15);
        app.ui.action_sets.push(ActionSet::new("Mine", vec![nudge]));
        let mut ov = Overrides::new();
        crate::keymap::set_override(&mut ov, "edit.duplicate", "F15");
        let bytes = serde_json::to_vec(&export_json("Imported", &ov)).unwrap();
        app.services.pick_open = Some(Box::new(|_: &crate::FilePick| Some("/sets/Imported.json".to_string())));
        app.services.read = Some(Box::new(move |_: &str| Ok(bytes.clone())));
        let key = |app: &VectorcraftApp| app.ui.action_sets.last().and_then(|s| s.actions.first()).and_then(|a| a.key);
        open(&mut app);
        import_into_dialog(&mut app);
        assert_eq!(key(&app), Some(f15), "the import alone keeps the action's key");
        assert!(app.ui.shortcut_overrides.is_empty(), "the import is only in the dialog");
        app.ui.dialog = None;
        assert_eq!(key(&app), Some(f15), "Cancel keeps the action's key");
        open(&mut app);
        import_into_dialog(&mut app);
        assert_eq!(key(&app), Some(f15));
        confirm(&mut app).unwrap();
        assert_eq!(key(&app), Some(f15), "OK keeps the action's function key");
    }

    #[test]
    fn presets_are_the_defaults() {
        for p in PRESETS {
            assert_eq!(preset(p), Some(Overrides::new()));
        }
        assert!(preset("Nope").is_none());
    }

    #[test]
    fn paint_dialog_rows_show_both_default_keys() {
        let view = DialogView::new(Overrides::new());
        for (key, plain, shifted) in [("paint.lastColor", ",", "Shift+Comma"), ("paint.lastGradient", ".", "Shift+Period")] {
            let at = entries().iter().position(|e| e.key == key).unwrap();
            let shown = view.texts[at].as_deref().unwrap();
            let shifted = menus::pretty_shortcut(shifted);
            assert!(shown.contains(plain) && shown.contains(&shifted), "{key}: {shown}");
        }
        assert_eq!(view.conflicts, 0);
    }

    #[test]
    fn entries_cover_tools_and_menu_commands() {
        assert!(entries().iter().any(|e| e.key == "tool:selection"));
        assert!(entries().iter().any(|e| e.key == "edit.preferences"));
        assert!(entries().iter().any(|e| e.key == "edit.undo"));
        let mut seen = HashSet::new();
        assert!(entries().iter().all(|e| seen.insert(e.key.clone())), "duplicate entries");
    }

    #[test]
    fn duplicate_can_be_given_a_shortcut() {
        // Duplicate has no default chord (#1539): it must still be listed so one can be set.
        assert_eq!(entry("edit.duplicate").map(|e| e.group.as_str()), Some("Edit"));
        let mut ov = Overrides::new();
        assign(&mut ov, "edit.duplicate", Some("Cmd+Alt+Shift+F8"), false).unwrap();
        assert_eq!(effective_in(&ov, "edit.duplicate").as_deref(), Some("Cmd+Alt+Shift+F8"));
    }

    /// #1539: a command outside the menus that runs without params (a panel menu's Break Link to
    /// Symbol) can be given a shortcut; one that needs params, a query or an alias can't.
    #[test]
    fn menuless_commands_that_run_bare_are_listed() {
        let e = entry("symbol.breakLink").expect("listed");
        assert_eq!((e.label.as_str(), e.group.as_str()), ("Break Link to Symbol", "Symbol"));
        for id in ["brush.duplicate", "path.convertAnchors", "document.json", "prefs.list"] {
            assert!(entry(id).is_none(), "{id}");
        }
        for (doc, bare) in
            [("{}", true), ("{dx?, dy?} x", true), ("{id?|ids?, clip?}", true), ("{name, newName?}", false), ("{a?: {b}}", false), ("same as", false)]
        {
            assert_eq!(runs_without_params(doc), bare, "{doc}");
        }
        let mut ov = Overrides::new();
        assert!(assign(&mut ov, "symbol.breakLink", Some("Cmd+Alt+Shift+F9"), true).is_ok());
        assert_eq!(effective_in(&ov, "symbol.breakLink").as_deref(), Some("Cmd+Alt+Shift+F9"));
    }

    /// The Menu Commands rows the dialog draws for `query`.
    fn menu_rows(app: &mut VectorcraftApp, query: &str) -> Vec<String> {
        open(app);
        let d = app.ui.dialog.as_mut().unwrap();
        d.fields.insert("tab".into(), json!("menu"));
        d.fields.insert("query".into(), json!(query));
        let ctx = egui::Context::default();
        theme::install_fonts(&ctx);
        // The modal draws nothing in its first frame, which only sizes it.
        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui.ctx()));
        out.textures_delta.clear();
        let mut out = ctx.run_ui(egui::RawInput::default(), |ui| show(app, ui.ctx()));
        out.textures_delta.clear();
        app.ui.dialog = None;
        out.shapes
            .iter()
            .filter_map(|c| match &c.shape {
                egui::Shape::Text(t) if t.galley.text().contains(" › ") => Some(t.galley.text().to_string()),
                _ => None,
            })
            .collect()
    }

    /// A menu command whose params need a value (Units needs `{units}`) is not listed while it has
    /// no shortcut. A shortcut the user gave it keeps it listed, where it can be changed or cleared.
    #[test]
    fn commands_that_need_a_value_are_listed_only_with_the_users_shortcut() {
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        let list = run_command(&mut app, "shortcuts.list", &json!({"query": "document.setUnits"})).unwrap().unwrap();
        assert_eq!(list, json!([]));
        assert!(!menu_rows(&mut app, "units").iter().any(|r| r.ends_with(" › Units")));
        // A key saved for it before stays listed.
        crate::keymap::set_override(&mut app.ui.shortcut_overrides, "document.setUnits", "Cmd+Alt+Shift+F12");
        let list = run_command(&mut app, "shortcuts.list", &json!({"query": "document.setUnits"})).unwrap().unwrap();
        let e = &list[0];
        assert_eq!(
            (e["id"].as_str(), e["shortcut"].as_str(), e["overridden"].as_bool()),
            (Some("document.setUnits"), Some("Cmd+Alt+Shift+F12"), Some(true))
        );
        assert!(menu_rows(&mut app, "units").iter().any(|r| r == "File › Document Setup › Units"));
        // An empty saved shortcut (as an imported set can hold) gives it no key, so it is not listed.
        crate::keymap::set_override(&mut app.ui.shortcut_overrides, "document.setUnits", "");
        let list = run_command(&mut app, "shortcuts.list", &json!({"query": "document.setUnits"})).unwrap().unwrap();
        assert_eq!(list, json!([]));
        // Every entry with a default shortcut is listed, and so are commands a key press runs: one
        // whose params are all optional, one the menu bar runs without params (Rotate… opens its
        // dialog) and one that opens a dialog for its values (New Variable).
        let none = Overrides::new();
        let dropped: Vec<&str> = entries().iter().filter(|e| default_of(&e.key).is_some() && !listed(&none, e)).map(|e| e.key.as_str()).collect();
        assert!(dropped.is_empty(), "{dropped:?}");
        for id in ["edit.duplicate", "object.pathfinder.unite", "object.rotate", "variable.define", "object.distributeSpacing"] {
            assert!(entry(id).is_some_and(|e| listed(&none, e)), "{id}");
        }
        for (doc, required) in [
            ("{}", false),
            ("{units: \"Points\"|\"Picas\"} the units", true),
            ("{ids?: [id…] (selected first), dx?, dy?}", false),
            ("{name? (trimmed, as `to`), attrs?: {…}}", false),
            ("{columns=10, rows=10 (whole numbers)}", false),
            ("{index | indices: [index…]}", true),
            ("{index?: n | indices?: [n…]}", false),
            ("{…as document.save} {path?}", false),
            ("{find, replace?: \"\"}", true),
            ("same as file.save", false),
        ] {
            assert_eq!(names_a_required_field(doc), required, "{doc}");
        }
    }

    /// Commands whose params are all optional but that a key press can't run are not listed while
    /// they have no shortcut: Transparency and Opacity Mask Options set nothing without a value,
    /// Align needs a direction, Other Library… a file, and a query's answer (Select All Unused)
    /// is dropped. A key saved for one before keeps it listed, where it can be cleared.
    #[test]
    fn commands_a_key_press_cannot_run_are_not_listed() {
        let none = Overrides::new();
        // Edit › Find Next's menu item gives an empty `find`, which it rejects.
        let others = ["swatch.unused", "graphicStyle.unused", "document.info", "view.proofSetup", "magicWand.set", "edit.findNext"];
        for id in NEEDS_A_PARAM.iter().chain(&others) {
            let e = entry(id).unwrap_or_else(|| panic!("{id} has an entry"));
            assert!(!listed(&none, e), "{id}");
            assert_eq!(default_of(id), None, "{id}");
        }
        let mut ov = Overrides::new();
        crate::keymap::set_override(&mut ov, "transparency.set", "Cmd+Alt+Shift+F10");
        assert!(entry("transparency.set").is_some_and(|e| listed(&ov, e)));
        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
        for id in ["transparency.set", "transparency.setOpacityMask"] {
            let list = run_command(&mut app, "shortcuts.list", &json!({ "query": id })).unwrap().unwrap();
            assert_eq!(list, json!([]), "{id}");
        }
        // Commands that work without params stay listed: panel menu commands that act on the
        // selection, toggles, and a menu item that runs with params of its own (Clean Up…).
        for id in [
            "transparency.releaseOpacityMask",
            "transparency.toggleNewMasksClipping",
            "object.path.cleanUp",
            "addon.color.printFixes",
            "edit.findReplace",
        ] {
            assert!(entry(id).is_some_and(|e| listed(&none, e)), "{id}");
        }
        assert_eq!(menu_target("object.path.cleanUp").map(|(id, _)| id).as_deref(), Some("ui.paramDialog"));
        assert_eq!(
            menu_target("addon.color.printFixes").map(|(id, p)| (id, p["command"].clone(), p["params"]["inkLimit"].clone())),
            Some(("ui.paramDialog".into(), json!("addon.color.printFixes"), json!(300)))
        );
        assert_eq!(menu_target("edit.findReplace").map(|(id, _)| id).as_deref(), Some("ui.paramDialog"));
        assert_eq!(menu_target("object.align"), None, "seven items, each with its own params");
        assert_eq!(menu_target("edit.undo"), None, "runs without params");
    }

    /// Every command the editor lists, run as a key press runs it on a document with one or with
    /// several objects selected, reports no missing param.
    #[test]
    fn listed_commands_run_from_a_key_without_a_missing_param() {
        use vectorcraft_testkit::fixtures::Fixture;
        // These need a state the fixtures lack: text being edited, a pattern being edited, an
        // object linked to a graphic style, a plug-ins folder.
        let context = ["text.insertInline", "pattern.options", "graphicStyle.redefine", "plugin.reload"];
        let none = Overrides::new();
        let mut failures = vec![];
        for e in entries().iter().filter(|e| !e.is_tool && !e.key.starts_with("panel:") && listed(&none, e)) {
            if ["file.", "app.", "help."].iter().any(|p| e.key.starts_with(p)) || context.contains(&e.key.as_str()) {
                continue;
            }
            for fx in [Fixture::Single, Fixture::Multi] {
                let mut app = VectorcraftApp::new(fx.session(), Default::default());
                app.ui.status.clear();
                let (id, p) = menu_target(&e.key).unwrap_or_else(|| (e.key.clone(), json!({})));
                menus::invoke(&mut app, &id, p);
                let s = &app.ui.status;
                if s.starts_with("invalid parameters for") && (s.contains(": give ") || s.contains(": missing ")) {
                    failures.push(format!("{} [{fx:?}]: {s}", e.key));
                }
            }
        }
        assert!(failures.is_empty(), "{failures:#?}");
    }

    /// #2991: Enter Isolation Mode has no default key but runs on the selection, so it belongs in
    /// Edit › Keyboard Shortcuts.
    #[test]
    fn enter_isolation_mode_command_is_listed_and_assignable() {
        let e = entry("object.isolate").expect("listed");
        assert_eq!((e.label.as_str(), e.group.as_str(), e.is_tool), ("Enter Isolation Mode", "Object", false));
        assert_eq!(default_of("object.isolate"), None);
        let mut ov = Overrides::new();
        assign(&mut ov, "object.isolate", Some("Cmd+Alt+Shift+F11"), false).unwrap();
        assert_eq!(effective_in(&ov, "object.isolate").as_deref(), Some("Cmd+Alt+Shift+F11"));
    }
}