@inklu/keys 2.1.0 → 2.2.0

package/dist/{src-B76YvObL.mjs → src-TaZw4V61.mjs}

@@ -1,15 +1,10 @@
 //#region src/chord.ts
-/** The platform this code runs on, as `navigator` reports it. `"linux"` where there is none. */
+/** The platform, as `navigator` reports it. `"other"` where there is none. */
 function detectPlatform() {
-	if (typeof navigator === "undefined") return "linux";
-	const platform = `${navigator.platform} ${navigator.userAgent}`.toLowerCase();
-	if (platform.includes("mac")) return "mac";
-	return platform.includes("win") ? "windows" : "linux";
+	if (typeof navigator === "undefined") return "other";
+	return /mac/i.test(`${navigator.platform} ${navigator.userAgent}`) ? "mac" : "other";
 }
-/**
-* Named keys with a place in the `Key` type, as `KeyboardEvent.key` spells
-* them. Any other name still works as a key; `validateChord` only remarks on it.
-*/
+/** Named keys in the `Key` type, as `KeyboardEvent.key` spells them. Other names still work. */
 const NAMED_KEYS = [
 	"ArrowUp",
 	"ArrowDown",
@@ -65,7 +60,7 @@ function split(chord) {
 	return parts.map((part) => part.trim());
 }
 /** One spelling per key: letters upper-cased, the space bar by name. */
-function keyName(key) {
+function keyName$1(key) {
 	if (key === " ") return "Space";
 	if (!LETTER.test(key)) return key;
 	const upper = key.toUpperCase();
@@ -73,7 +68,7 @@ function keyName(key) {
 }
 /** The key a keypress produced. Empty for the keyless events browser autofill dispatches. */
 function pressedKey(event) {
-	return keyName(String(event.key ?? "").normalize("NFC"));
+	return keyName$1(String(event.key ?? "").normalize("NFC"));
 }
 function isOneCharacter(key) {
 	return Array.from(key).length === 1;
@@ -100,7 +95,7 @@ function read(chord, platform) {
 		alt: held.has("Alt"),
 		shift: held.has("Shift"),
 		meta: held.has("Meta"),
-		...code === void 0 ? { key: keyName(key) } : { code }
+		...code === void 0 ? { key: keyName$1(key) } : { code }
 	};
 }
 /** Parses a chord for a platform, or returns `null` for one that cannot be read. */
@@ -112,10 +107,7 @@ function parseChord(chord, platform) {
 function isChord(text) {
 	return parseChord(text, "mac") !== null;
 }
-/**
-* What is wrong with a chord (`errors`: it will never fire) and what merely
-* looks off (`warnings`: a key name this package does not know).
-*/
+/** A chord's `errors` (it will never fire) and `warnings` (a key name this package does not know). */
 function validateChord(chord) {
 	const result = read(chord, "mac");
 	if (typeof result === "string") return {
@@ -128,11 +120,7 @@ function validateChord(chord) {
 		warnings: key === void 0 || isOneCharacter(key) || FUNCTION_KEY.test(key) || NAMED_KEYS.some((name) => name === key) ? [] : [`Unknown key: '${key}'. Key names are KeyboardEvent.key values, such as Escape.`]
 	};
 }
-/**
-* Writes a parsed chord back as text, modifiers in canonical order. Given a
-* platform it prefers `Mod`, which is how a chord stays portable when it is
-* stored and read back on another machine.
-*/
+/** Writes a parsed chord as text. Given a platform, its primary modifier is written `Mod`. */
 function writeChord(chord, mod) {
 	const portable = mod !== void 0 && (mod === "mac" ? chord.meta && !chord.ctrl : chord.ctrl && !chord.meta);
 	const parts = portable ? ["Mod"] : [];
@@ -143,11 +131,7 @@ function writeChord(chord, mod) {
 	parts.push(chord.code === void 0 ? chord.key ?? "" : `[${chord.code}]`);
 	return parts.join("+");
 }
-/**
-* Whether a chord types a character when pressed: one character, or a letter,
-* digit or punctuation key by position, with no Control, Alt or Meta. Shift
-* does not count as a modifier here: `Shift+A` still types a character.
-*/
+/** Whether a chord types a character: a one-character key with no Control, Alt or Meta. */
 function typesCharacter(chord) {
 	if (chord.ctrl || chord.alt || chord.meta) return false;
 	return isOneCharacter(chord.key ?? keyAtCode(chord.code ?? "") ?? "");
@@ -165,10 +149,7 @@ const MODIFIER_KEYS = /* @__PURE__ */ new Set([
 function isModifierKey(key) {
 	return MODIFIER_KEYS.has(key);
 }
-/**
-* AltGr types a third character on many layouts, and Windows reports it as
-* Control+Alt. While it is down those two flags say nothing about intent.
-*/
+/** Whether AltGr is down. Windows reports it as Control+Alt, though a character is being typed. */
 function hasAltGraph(event, platform) {
 	return platform !== "mac" && event.getModifierState?.("AltGraph") === true;
 }
@@ -192,6 +173,15 @@ function keyAtCode(code) {
 	if (/^Digit[0-9]$/.test(code)) return code.slice(5);
 	return code === "Space" ? code : PUNCTUATION_CODES[code];
 }
+/** A chord with its key by name: a physical key becomes the key at its position, or its `code`. */
+function namedChord(chord) {
+	const key = chord.key ?? keyAtCode(chord.code ?? "") ?? chord.code ?? "";
+	return {
+		...chord,
+		key,
+		code: void 0
+	};
+}
 /** `KeyboardEvent.key` values that name neither a character nor a key. */
 const NO_KEY = /* @__PURE__ */ new Set([
 	"",
@@ -205,20 +195,14 @@ const isSymbol = (key) => isOneCharacter(key) && !LETTER.test(key);
 /** A key known by name rather than by a character, such as `Enter`. */
 const isNamed = (key) => !isOneCharacter(key) && !NO_KEY.has(key);
 /**
-* The key at a keypress's position on the conventional layout, when position
-* may stand in for what the layout produced. That is when the layout produced
-* nothing a chord would name:
+* The key at a keypress's position on the US layout, where position may stand
+* in for what the layout produced:
 *
-* - On the digit row, always: `Mod+1` is the first key of that row on AZERTY,
-*   which types `&` there, and `Shift+2` is `@` on a US keyboard.
-* - On a letter key, when it typed a character from another script (`ы` on a
-*   Russian keyboard still reaches `Mod+S`), or macOS Option turned the letter
-*   into something else.
-* - On a punctuation key, the same, and also while Shift or Alt is held, so
-*   `Shift+/` can be written by its base key.
+* - on the digit row, always (`Mod+1` on AZERTY, `Shift+2` on a US keyboard);
+* - on a letter key that typed another script, or that macOS Option altered;
+* - on a punctuation key likewise, and while Shift or Alt is held.
 *
-* Never when the layout typed a Latin letter or the key has a name (that is
-* the key pressed), nor under AltGr (the user is typing a character).
+* Never for a Latin letter, a named key, or under AltGr.
 */
 function positionKey(event, key, altGraph) {
 	if (altGraph || /^[A-Z]$/.test(key) || isNamed(key)) return void 0;
@@ -229,17 +213,12 @@ function positionKey(event, key, altGraph) {
 	return isAscii(key) && !event.shiftKey && !event.altKey ? void 0 : PUNCTUATION_CODES[code];
 }
 /**
-* Whether a keypress is this chord.
-*
-* A physical chord (`[KeyK]`) compares the key's position and nothing else.
-* A logical one names what the key produced, and matches in one of two ways:
-*
-* 1. The key produced is the chord's key. For a symbol, the modifiers that
-*    were only there to type it need not be named: `?` is Shift+/ on a US
-*    keyboard and unshifted elsewhere, and `[` is Option+5 on a German Mac.
-* 2. The key's position stands in for it, where `positionKey` allows.
+* Whether a keypress is this chord. A physical chord (`[KeyK]`) compares
+* position only. A logical one matches the key produced, where modifiers that
+* only typed a symbol need not be named (`?` is Shift+/ on a US keyboard), or
+* else the key's position where `positionKey` allows.
 *
-* The approach follows the matcher in TanStack Hotkeys (MIT).
+* Follows the matcher in TanStack Hotkeys (MIT).
 */
 function matchesChord(event, chord, platform) {
 	const altGraph = hasAltGraph(event, platform);
@@ -252,14 +231,10 @@ function matchesChord(event, chord, platform) {
 	return positionKey(event, key, altGraph) === chord.key && modifiersMatch(false);
 }
 /**
-* The chord a keypress expresses, for recording a new shortcut, or `null` for
-* a keypress that is not one: a modifier on its own, or a key with no name.
-*
-* It is the inverse of `matchesChord`: what it records, the same keypress
-* matches. It writes the character the layout typed where a chord can name it
-* (`?`, not `Shift+/`), the key's position otherwise (`Mod+S` for Ctrl+ы), and
-* `Mod` for the primary modifier, so the chord works on the user's other
-* machines too.
+* The chord a keypress expresses, for recording a shortcut, or `null` for a
+* modifier on its own or a key with no name. It records what `matchesChord`
+* then matches: the character typed (`?`, not `Shift+/`), else the key's
+* position, with the primary modifier written `Mod`.
 */
 function readChord(event, platform) {
 	if (isModifierKey(event.key)) return null;
@@ -301,12 +276,7 @@ function isSequence(binding) {
 function stepsOf(binding) {
 	return isSequence(binding) ? binding.sequence : [binding];
 }
-/**
-* Normalizes a binding input into an array of bindings. A one-step sequence
-* becomes a plain chord: it fires on exactly the same keypress, and keeping it
-* a sequence gave it a different signature from the chord, so the two were
-* neither arbitrated nor reported as conflicting — both ran.
-*/
+/** Normalizes a binding input into an array of bindings. A one-step sequence becomes a chord. */
 function toBindings(input) {
 	if (input == null) return [];
 	const candidates = isList(input) ? input : [input];
@@ -323,16 +293,20 @@ function toBindings(input) {
 function isList(input) {
 	return Array.isArray(input);
 }
+/** The side of `{ mac, other }` keys that applies on a platform. Keys that do not differ pass through. */
+function keysFor(keys, platform) {
+	if (keys == null || !isPerPlatform(keys)) return keys;
+	return platform === "mac" ? keys.mac : keys.other;
+}
+function isPerPlatform(keys) {
+	return typeof keys === "object" && !Array.isArray(keys) && !("sequence" in keys);
+}
 /** Generates a normalized signature for binding comparison and conflict detection. */
 function bindingSignature(binding, platform) {
 	const steps = canonicalSteps(binding, platform);
 	return isSequence(binding) ? `seq:${steps.join(" ")}` : `chord:${steps.join(" ")}`;
 }
-/**
-* Whether one binding is a strict prefix of the other — chord `G` against
-* `G then I`, or `G then G` against `G then G then I`. The shorter binding
-* fires on the way to the longer one, so both run for a single intent.
-*/
+/** Whether one binding is a strict prefix of the other, like chord `G` against `G then I`. */
 function isPrefixCollision(a, b, platform) {
 	const left = canonicalSteps(a, platform);
 	const right = canonicalSteps(b, platform);
@@ -358,53 +332,23 @@ function canonicalSteps(binding, platform = detectPlatform()) {
 	});
 }
 /**
-* Whether every step of a binding is a single printable character with no
-* Control, Alt or Meta — the "character key shortcuts" WCAG 2.1.4 lets users
-* turn off, since speech input and stray keypresses trigger them by accident.
+* Whether every step is a printable character with no Control, Alt or Meta:
+* the "character key shortcuts" WCAG 2.1.4 lets users turn off.
 */
 function isSingleKeyBinding(binding) {
 	return parseBinding(binding, "mac")?.every(typesCharacter) === true;
 }
-/** Converts a binding to a JSON-serializable format. */
-function serializeBinding(binding) {
-	return isSequence(binding) ? [...binding.sequence] : binding;
-}
-/** Deserializes a stored value into a valid binding, or `null` if invalid. */
-function deserializeBinding(value) {
-	if (typeof value === "string") {
-		const chord = value.trim();
-		return isChord(chord) ? chord : null;
-	}
-	if (!Array.isArray(value)) return null;
-	const steps = [];
-	for (const step of value) {
-		if (step === "") continue;
-		if (typeof step !== "string" || !isChord(step)) return null;
-		steps.push(step);
-	}
-	const [first, ...rest] = steps;
-	if (first === void 0) return null;
-	return rest.length === 0 ? first : { sequence: steps };
-}
-/** Validates a binding's syntax without logging warnings or errors. */
+/** A binding's syntax `errors` (it will never fire) and `warnings`, for the development audit. */
 function validateBinding(binding) {
-	const steps = stepsOf(binding);
-	if (steps.length === 0) return {
-		valid: false,
-		errors: ["Sequence has no steps"],
-		warnings: []
-	};
-	const results = steps.map(validateChord);
-	const errors = results.flatMap((result) => result.errors);
+	const results = stepsOf(binding).map(validateChord);
 	return {
-		valid: errors.length === 0,
-		errors,
-		warnings: results.flatMap((r) => r.warnings)
+		errors: results.flatMap((result) => result.errors),
+		warnings: results.flatMap((result) => result.warnings)
 	};
 }
 //#endregion
 //#region src/display.ts
-/** Platform-aware hotkey display formatting and accessibility attributes. */
+/** Writing a binding for people: on screen, in `aria-keyshortcuts`, and read aloud. */
 const MODIFIER_LABELS = {
 	symbols: [
 		"⌃",
@@ -418,32 +362,94 @@ const MODIFIER_LABELS = {
 		"Shift",
 		"Cmd"
 	],
-	windows: [
+	other: [
 		"Ctrl",
 		"Alt",
 		"Shift",
-		"Win"
-	],
-	linux: [
-		"Ctrl",
-		"Alt",
-		"Shift",
-		"Super"
+		"Meta"
 	]
 };
-const KEY_SYMBOLS = {
-	ArrowUp: "↑",
-	ArrowDown: "↓",
-	ArrowLeft: "←",
-	ArrowRight: "→",
-	Enter: "↵",
-	Escape: "Esc",
-	Backspace: "⌫",
-	Delete: "⌦",
-	Tab: "⇥",
-	Space: "␣"
+/** The abbreviated modifier labels, in full, for reading aloud. */
+const SPOKEN_MODIFIERS = {
+	Ctrl: "Control",
+	Cmd: "Command"
+};
+const KEY_LABELS = {
+	Enter: [
+		"↩",
+		"Enter",
+		"Return",
+		"Enter"
+	],
+	Backspace: [
+		"⌫",
+		"Backspace",
+		"Delete",
+		"Backspace"
+	],
+	Delete: [
+		"⌦",
+		"Del",
+		"Forward Delete",
+		"Delete"
+	],
+	Tab: [
+		"⇥",
+		"Tab",
+		"Tab"
+	],
+	Escape: [
+		"⎋",
+		"Esc",
+		"Escape"
+	],
+	ArrowUp: [
+		"↑",
+		"↑",
+		"Up Arrow"
+	],
+	ArrowDown: [
+		"↓",
+		"↓",
+		"Down Arrow"
+	],
+	ArrowLeft: [
+		"←",
+		"←",
+		"Left Arrow"
+	],
+	ArrowRight: [
+		"→",
+		"→",
+		"Right Arrow"
+	],
+	Home: [
+		"↖",
+		"Home",
+		"Home"
+	],
+	End: [
+		"↘",
+		"End",
+		"End"
+	],
+	PageUp: [
+		"⇞",
+		"PgUp",
+		"Page Up"
+	],
+	PageDown: [
+		"⇟",
+		"PgDn",
+		"Page Down"
+	],
+	"+": [
+		"+",
+		"Plus",
+		"Plus"
+	]
 };
-/** Names for the keys whose character is hard to tell apart in running text. */
+/** Names for the keys whose character is hard to tell apart in running text, or to hear. */
 const PUNCTUATION_NAMES = {
 	"`": "Backquote",
 	"\\": "Backslash",
@@ -453,21 +459,28 @@ const PUNCTUATION_NAMES = {
 	"=": "Equal",
 	"-": "Minus",
 	".": "Period",
-	";": "Semicolon"
+	";": "Semicolon",
+	"/": "Slash",
+	"?": "Question Mark"
 };
-/** Formats a binding for display on the target platform (e.g. `⌘ K` or `Ctrl+K`). */
+const spaced = (name) => name.replace(/([a-z])([A-Z])/g, "$1 $2");
+/**
+* Formats a binding the way its platform writes shortcuts: `⇧⌘S` on a Mac,
+* `Ctrl+Shift+S` elsewhere. The steps of a sequence are set apart by a space.
+*/
 function formatBinding(binding, options) {
-	if (isSequence(binding)) return binding.sequence.map((step) => formatChord(step, options)).join(" ");
-	return formatChord(binding, options);
+	return stepsOf(binding).map((step) => formatChord(step, options)).join(" ");
 }
-/** Splits a binding into display tokens for rendering `<kbd>` elements. */
+/**
+* Splits a binding into display tokens for rendering `<kbd>` elements: one
+* per key of a chord, one per step of a sequence.
+*/
 function bindingTokens(binding, options) {
 	if (isSequence(binding)) return binding.sequence.map((step) => formatChord(step, options));
 	return chordTokens(binding, options);
 }
 function formatChord(chord, options) {
-	const spaced = usesModifierSymbols(options);
-	return chordTokens(chord, options).join(spaced ? " " : "+");
+	return chordTokens(chord, options).join(usesModifierSymbols(options) ? "" : "+");
 }
 function usesModifierSymbols(options) {
 	return (options?.platform ?? detectPlatform()) === "mac" && options?.useSymbols !== false;
@@ -477,46 +490,308 @@ function chordTokens(chord, options) {
 	const parsed = parseChord(chord, platform);
 	if (!parsed) return [chord];
 	const labels = MODIFIER_LABELS[usesModifierSymbols(options) ? "symbols" : platform];
+	return [...heldLabels(parsed, labels), keyLabel(parsed, platform, options?.useSymbols !== false)];
+}
+function heldLabels(chord, labels) {
 	const held = [
-		parsed.ctrl,
-		parsed.alt,
-		parsed.shift,
-		parsed.meta
+		chord.ctrl,
+		chord.alt,
+		chord.shift,
+		chord.meta
 	];
-	return [...labels.filter((_, index) => held[index]), keyLabel(parsed, options)];
+	return labels.filter((_, index) => held[index]);
+}
+function keyLabel(chord, platform, symbols) {
+	const mac = platform === "mac";
+	const label = (key) => symbols ? KEY_LABELS[key]?.[mac ? 0 : 1] ?? key : keyName(key, mac);
+	if (chord.code?.startsWith("Numpad")) return `Numpad ${spaced(label(chord.code.slice(6)))}`;
+	return label(namedChord(chord).key);
 }
-function keyLabel(chord, options) {
-	const names = options?.useSymbols === false ? PUNCTUATION_NAMES : KEY_SYMBOLS;
-	const label = (key) => names[key] ?? key;
-	if (chord.code === void 0) return label(chord.key ?? "");
-	if (chord.code.startsWith("Numpad")) return `Numpad ${label(chord.code.slice(6)).replace(/([a-z])([A-Z])/g, "$1 $2")}`;
-	return label(keyAtCode(chord.code) ?? chord.code);
+/** A key in words: `"Return"`, `"Up Arrow"`, `"Comma"`, `"Caps Lock"`. */
+function keyName(key, mac) {
+	const label = KEY_LABELS[key];
+	if (label) return (mac ? void 0 : label[3]) ?? label[2];
+	return PUNCTUATION_NAMES[key] ?? spaced(key);
 }
 /**
-* Phrases a binding for a screen reader: `"Control+K"` for a chord,
-* `"G then I"` for a sequence. `aria-keyshortcuts` cannot express a sequence
-* (a space there means "or"), so this is how a sequence gets announced — put it
-* in visually hidden text or `aria-description`.
+* Phrases a binding for a screen reader: `"Command K"` for a chord,
+* `"G then I"` for a sequence, which `aria-keyshortcuts` cannot express.
 */
-function spokenBinding(binding, platform) {
-	return stepsOf(binding).map((step) => keyNames(step, platform) || step).join(" then ");
-}
-/** Generates an `aria-keyshortcuts` attribute string for a binding. */
-function ariaKeyShortcuts(binding, platform) {
-	return isSequence(binding) ? "" : keyNames(binding, platform);
+function spokenBinding(binding, platform = detectPlatform()) {
+	return stepsOf(binding).map((step) => {
+		const parsed = parseChord(step, platform);
+		if (!parsed) return step;
+		return [...heldLabels(parsed, MODIFIER_LABELS[platform]).map((label) => SPOKEN_MODIFIERS[label] ?? label), keyName(namedChord(parsed).key, platform === "mac")].join(" ");
+	}).join(" then ");
 }
-/** A chord in key names, `Mod` resolved: `"Meta+K"`. Empty for one that cannot be read. */
-function keyNames(chord, platform = detectPlatform()) {
-	const parsed = parseChord(chord, platform);
+/**
+* The `aria-keyshortcuts` value for a chord, as in `"Meta+K"`. Empty for a
+* sequence and for a chord that cannot be read.
+*/
+function ariaKeyShortcuts(binding, platform = detectPlatform()) {
+	const parsed = isSequence(binding) ? null : parseChord(binding, platform);
 	if (!parsed) return "";
-	const key = parsed.key ?? keyAtCode(parsed.code ?? "") ?? parsed.code;
-	return writeChord({
-		...parsed,
-		key,
-		code: void 0
+	const chord = namedChord(parsed);
+	return writeChord(chord.key === "+" ? {
+		...chord,
+		key: "Plus"
+	} : chord);
+}
+//#endregion
+//#region src/keymap.ts
+/** Keymap: default bindings, and the user's overrides on top of them. */
+/** A signature that holds on every platform, so `Mod+S` and `Control+S` stay distinct. */
+function portableSignature(binding) {
+	return `${bindingSignature(binding, "mac")} ${bindingSignature(binding, "other")}`;
+}
+var Keymap = class {
+	#defaults = /* @__PURE__ */ new Map();
+	#overrides = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Set();
+	#store;
+	#loaded = false;
+	constructor(store) {
+		this.#store = store;
+	}
+	/** Sets a command's default bindings. `null` leaves the command unbound. */
+	setDefault(id, input) {
+		const bindings = toBindings(input);
+		if (bindings.length === 0) this.#defaults.delete(id);
+		else this.#defaults.set(id, bindings);
+	}
+	/** Checks whether a command has an active user override. */
+	isOverridden(id) {
+		return this.#overrides.has(id);
+	}
+	/** The user's overrides, for a store or an export to write out. */
+	get overrides() {
+		return this.#overrides;
+	}
+	get(id) {
+		const defaults = this.#defaults.get(id) ?? [];
+		const override = this.#overrides.get(id);
+		if (!override) return defaults;
+		if (override.kind === "replace") return override.bindings;
+		return [...defaults, ...without(override.bindings, defaults)];
+	}
+	set(id, input) {
+		this.#load();
+		const bindings = input === null ? [] : toBindings(input);
+		if (sameBindings(bindings, this.#defaults.get(id) ?? [])) {
+			if (!this.#overrides.delete(id)) return;
+		} else this.#overrides.set(id, {
+			kind: "replace",
+			bindings
+		});
+		this.#changed();
+	}
+	add(id, input) {
+		this.#load();
+		const added = without(toBindings(input), this.get(id));
+		if (added.length === 0) return;
+		const override = this.#overrides.get(id);
+		this.#overrides.set(id, {
+			kind: override?.kind ?? "add",
+			bindings: [...override?.bindings ?? [], ...added]
+		});
+		this.#changed();
+	}
+	reset(id) {
+		this.#load();
+		if (id === void 0) {
+			if (this.#overrides.size === 0) return;
+			this.#overrides.clear();
+		} else if (!this.#overrides.delete(id)) return;
+		this.#changed();
+	}
+	/** Replaces every override and saves, as an import does. */
+	replace(overrides) {
+		this.#loaded = true;
+		this.#overrides = overrides;
+		this.#changed();
+	}
+	/**
+	* Takes the stored overrides, telling subscribers if they differ from the
+	* ones in memory, and returns whether they did. Each mount starts with it,
+	* which catches up on what other tabs stored while nothing was listening.
+	*/
+	sync() {
+		this.#loaded = true;
+		const stored = this.#store?.read();
+		if (!stored) return false;
+		const before = JSON.stringify([...this.#overrides]);
+		this.#overrides = stored;
+		if (JSON.stringify([...stored]) === before) return false;
+		this.#notify();
+		return true;
+	}
+	/** Follows edits other tabs make to the stored overrides. Returns a function that stops. */
+	watch() {
+		return this.#store?.watch(() => this.sync()) ?? (() => {});
+	}
+	/** Subscribes to keymap changes. Returns an unsubscribe function. */
+	subscribe(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	/** Before an edit: stored overrides load first, once, so the edit lands on top of them. */
+	#load() {
+		if (!this.#loaded) this.sync();
+	}
+	#changed() {
+		this.#store?.write(this.#overrides);
+		this.#notify();
+	}
+	#notify() {
+		for (const listener of this.#listeners) listener();
+	}
+};
+/** `bindings` minus any already in `existing` or repeated, compared across platforms. */
+function without(bindings, existing) {
+	const known = new Set(existing.map(portableSignature));
+	return bindings.filter((binding) => {
+		const signature = portableSignature(binding);
+		if (known.has(signature)) return false;
+		known.add(signature);
+		return true;
+	});
+}
+/** Same bindings in the same order; the first is the one shortcuts display. */
+function sameBindings(a, b) {
+	return a.length === b.length && a.every((binding, index) => {
+		const other = b[index];
+		return other !== void 0 && portableSignature(binding) === portableSignature(other);
 	});
 }
 //#endregion
+//#region src/persist.ts
+/** Keeping a keymap between visits: Web Storage, and export and import as JSON. */
+const VERSION = 1;
+/**
+* Keeps user overrides in Web Storage under `key`, and follows edits made in
+* other tabs. `storage` is only called in the browser; return
+* `sessionStorage` or an object of your own to keep them somewhere else.
+*
+* @example
+* ```ts
+* createCommands(definitions, { persist: webStorage("my-app.keys") });
+* ```
+*/
+function webStorage(key = "inklu.keys", storage = () => localStorage) {
+	const open = () => {
+		try {
+			return storage();
+		} catch {
+			return null;
+		}
+	};
+	return {
+		read() {
+			const area = open();
+			if (!area) return null;
+			try {
+				const raw = area.getItem(key);
+				return raw ? parseKeymap(JSON.parse(raw)) : /* @__PURE__ */ new Map();
+			} catch {
+				return null;
+			}
+		},
+		write(overrides) {
+			try {
+				if (overrides.size === 0) open()?.removeItem(key);
+				else open()?.setItem(key, JSON.stringify(serializeKeymap(overrides)));
+			} catch {}
+		},
+		watch(onChange) {
+			if (typeof window === "undefined") return () => {};
+			const onStorage = (event) => {
+				if (event.key === null || event.key === key) onChange();
+			};
+			window.addEventListener("storage", onStorage);
+			return () => window.removeEventListener("storage", onStorage);
+		}
+	};
+}
+/** A registry's user overrides as JSON-safe data, for your own storage or another device. */
+function exportKeymap(commands) {
+	return serializeKeymap(keymapOf(commands).overrides);
+}
+/**
+* Replaces a registry's user overrides with exported data, and saves them.
+* Data in another format changes nothing.
+*/
+function importKeymap(commands, data) {
+	const overrides = parseKeymap(data);
+	if (overrides) keymapOf(commands).replace(overrides);
+}
+function keymapOf({ keymap }) {
+	if (keymap instanceof Keymap) return keymap;
+	throw new TypeError("[@inklu/keys] not a registry made by createCommands");
+}
+function serializeKeymap(overrides) {
+	return {
+		version: VERSION,
+		overrides: Object.fromEntries(Array.from(overrides, ([id, { kind, bindings }]) => {
+			const list = bindings.map((binding) => isSequence(binding) ? [...binding.sequence] : binding);
+			return [id, kind === "replace" ? list : { add: list }];
+		}))
+	};
+}
+/** The overrides in stored data, or `null` for data in another format. */
+function parseKeymap(data) {
+	const stored = isObject(data) && data.version === VERSION ? data.overrides : void 0;
+	if (stored === void 0 || !isObject(stored)) return null;
+	const overrides = /* @__PURE__ */ new Map();
+	for (const [id, value] of Object.entries(stored)) {
+		const override = parseOverride(value);
+		if (override) overrides.set(id, override);
+	}
+	return overrides;
+}
+function parseOverride(value) {
+	if (Array.isArray(value)) {
+		const bindings = parseBindings(value);
+		return bindings && {
+			kind: "replace",
+			bindings
+		};
+	}
+	if (isObject(value) && Array.isArray(value.add)) {
+		const bindings = parseBindings(value.add);
+		return bindings && bindings.length > 0 ? {
+			kind: "add",
+			bindings
+		} : null;
+	}
+	return null;
+}
+/**
+* Reads a stored list. `[]` is an unbound command; a non-empty list with
+* nothing usable in it is damage, and reads as `null`.
+*/
+function parseBindings(values) {
+	const bindings = values.map(parseStoredBinding).filter((binding) => binding !== null);
+	return bindings.length === 0 && values.length > 0 ? null : bindings;
+}
+/** A stored chord (a string) or sequence (a list of them), or `null` if it cannot be read. */
+function parseStoredBinding(value) {
+	if (typeof value === "string") return isChord(value) ? value : null;
+	if (!Array.isArray(value)) return null;
+	const steps = [];
+	for (const step of value) {
+		if (typeof step !== "string" || !isChord(step)) return null;
+		steps.push(step);
+	}
+	const [first, ...rest] = steps;
+	if (first === void 0) return null;
+	return rest.length === 0 ? first : { sequence: steps };
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
 //#region src/keys.ts
 /** The one keyboard listener: matches a keypress to bindings and runs the command that wins it. */
 const DEFAULT_SEQUENCE_TIMEOUT = 1e3;
@@ -560,11 +835,7 @@ var KeyListener = class {
 	get captured() {
 		return this.#captures.length > 0;
 	}
-	/**
-	* Hands every keypress to `onKey` until released. See `Commands.capture`.
-	* A capture listens first, in the capture phase and on the whole document,
-	* and only for as long as there is one.
-	*/
+	/** Hands every keypress to `onKey` until released, in the capture phase on the document. */
 	capture(onKey) {
 		if (typeof document === "undefined") return () => {};
 		this.#captures.push(onKey);
@@ -583,12 +854,7 @@ var KeyListener = class {
 		this.#bound = null;
 		this.#publish();
 	}
-	/**
-	* Reachability changed. A sequence that became unreachable halfway through
-	* loses its progress: otherwise a scope that closed and reopened within
-	* the timeout would let the next key complete a sequence begun in a
-	* different context.
-	*/
+	/** Reachability changed: a half-typed sequence that is no longer reachable starts over. */
 	prune() {
 		let changed = false;
 		for (const bound of this.#bound ?? []) {
@@ -659,7 +925,7 @@ var KeyListener = class {
 			const definition = this.#host.definition(bound.id);
 			const first = bound.steps[0];
 			if (!definition || !first || !this.#host.reachable(bound.id)) continue;
-			if (typing && (definition.ignoreInputs ?? ignoresInputs(first))) continue;
+			if (typing && (definition.ignoreInputs ?? ignoresInputs(first, platform))) continue;
 			if (bound.steps.length === 1) {
 				if (matchesChord(event, first, platform)) chords.push(bound);
 				continue;
@@ -688,9 +954,14 @@ var KeyListener = class {
 		const candidates = sequences.length > 0 ? sequences : continued ? [] : chords;
 		let winner;
 		for (const bound of candidates) if (!winner || this.#outranks(bound, winner)) winner = bound;
-		if (winner && this.#host.definition(winner.id)?.preventDefault !== false) prevent = true;
-		if (prevent) event.preventDefault();
-		if (winner) this.#host.run(winner.id, event, winner.binding);
+		const definition = winner && this.#host.definition(winner.id);
+		if (!winner || !definition) {
+			if (prevent) event.preventDefault();
+			return;
+		}
+		if (prevent || definition.preventDefault !== false) event.preventDefault();
+		if (event.repeat && definition.repeat === false) return;
+		this.#host.run(winner.id, event, winner.binding);
 	};
 	#outranks(a, b) {
 		const depth = this.#host.depth(a.id) - this.#host.depth(b.id);
@@ -726,53 +997,71 @@ var KeyListener = class {
 	};
 };
 /**
-* A keydown mid-composition belongs to the IME — confirming a kana or pinyin
-* candidate must not also fire whatever the raw key is bound to. Older
-* engines report composition only as `keyCode` 229 or the key `Process`.
+* Whether a keydown belongs to an IME composition. Some engines report it
+* only as `keyCode` 229 or the key `Process`.
 */
 function isComposing(event) {
 	return event.isComposing || event.keyCode === 229 || event.key === "Process";
 }
 /**
-* Whether a binding stays quiet while the user is typing, when its command
-* does not say: chords holding Control or Meta and bare `Escape` still fire
-* inside a text field, everything else would hijack a typed character.
+* Whether a binding stays quiet in a text field when its command does not
+* say: everything but Control/Meta chords and bare `Escape`, and also the
+* chords a field edits its own text with.
 */
-function ignoresInputs(step) {
-	return !(step.ctrl || step.meta || step.key === "Escape" || step.code === "Escape");
+function ignoresInputs(step, platform) {
+	if (step.key === "Escape" || step.code === "Escape") return false;
+	return !(step.ctrl || step.meta) || editsText(step, platform);
 }
+/** Keys that, with the primary modifier, move the caret or delete by word or by line. */
+const CARET_KEYS = /^(Backspace|Delete|Home|End|Arrow\w+)$/;
 /**
-* Whether a keypress lands in a field that takes text. `host` is the element
-* the listener itself sits on, which never counts: keys bound on an editor
-* are meant for that editor.
+* Whether a text field acts on a chord itself, on the platform's primary
+* modifier: select all, copy, cut, paste, undo and redo, and moving or
+* deleting by word or line.
+*/
+function editsText(step, platform) {
+	const mac = platform === "mac";
+	if (step.alt || step.ctrl === mac || step.meta !== mac) return false;
+	const key = namedChord(step).key;
+	if (key.length > 1) return CARET_KEYS.test(key);
+	return (step.shift ? "VZ" : mac ? "ACVXZ" : "ACVXYZ").includes(key);
+}
+/**
+* Whether a keypress lands in a field that takes text. `host`, the element
+* the listener sits on, does not count.
 */
 function isTyping(event, host) {
 	return event.composedPath().some((node) => node !== host && isTextEntry(node));
 }
+/** ARIA roles of widgets that take typed keys the way their native counterparts do. */
+const TEXT_ENTRY_ROLES = /* @__PURE__ */ new Set([
+	"textbox",
+	"searchbox",
+	"combobox",
+	"spinbutton",
+	"slider"
+]);
 function isTextEntry(node) {
-	if (typeof HTMLElement === "undefined" || !(node instanceof HTMLElement)) return false;
+	if (!(node instanceof HTMLElement)) return false;
 	if (node instanceof HTMLInputElement) {
 		const type = node.type.toLowerCase();
 		return type !== "button" && type !== "submit" && type !== "reset";
 	}
-	return node instanceof HTMLTextAreaElement || node instanceof HTMLSelectElement || !["false", null].includes(node.getAttribute("contenteditable"));
+	return node instanceof HTMLTextAreaElement || node instanceof HTMLSelectElement || !["false", null].includes(node.getAttribute("contenteditable")) || TEXT_ENTRY_ROLES.has(node.getAttribute("role") ?? "");
 }
 //#endregion
 //#region src/rebind.ts
 /** Controller for recording and applying hotkey rebindings. */
 const NO_STEPS = [];
 /**
-* Creates a rebinder instance for capturing and remapping a command's keys.
-* While it records it holds the whole keyboard, so no command runs on the
-* keys being pressed. Escape cancels, Backspace removes the shortcut (or the
-* last step of a sequence), and Enter finishes a sequence.
+* Creates a rebinder for recording a command's keys. While it records, no
+* command runs. Escape cancels, Backspace removes the shortcut (or the last
+* step of a sequence), and Enter finishes a sequence.
 *
 * @example
 * ```ts
 * const rebinder = createRebinder(commands, "palette.open", {
-*   onRecord: (binding, conflicts) => {
-*     if (conflicts.length) console.warn("Conflict with", conflicts[0].id);
-*   },
+*   onRecord: (binding, conflicts) => showConflicts(conflicts),
 * });
 * rebinder.start();
 * ```
@@ -805,7 +1094,7 @@ function createRebinder(registry, id, options = {}) {
 			ignore: id,
 			scope: registry.get(id)?.scope
 		});
-		const blocked = options.rejectConflicts === true && conflicts.length > 0;
+		const blocked = conflicts.some((conflict) => conflict.kind === "reserved") || options.rejectConflicts === true && conflicts.length > 0;
 		if (options.apply !== false && !blocked) {
 			if (options.add) registry.keymap.add(id, binding);
 			else registry.keymap.set(id, binding);
@@ -908,11 +1197,25 @@ function createRebinder(registry, id, options = {}) {
 		}
 	};
 }
+//#endregion
+//#region src/reserved.ts
+/** Chords the browser or the operating system keeps for itself. */
+const chords = (list) => new Set(list.split(" "));
+const RESERVED = {
+	mac: chords("Meta+N Meta+T Meta+W Meta+Q Meta+H Meta+M Meta+Tab Meta+Space Shift+Meta+N Shift+Meta+T Shift+Meta+W Shift+Meta+Q Shift+Meta+Tab Shift+Meta+3 Shift+Meta+4 Shift+Meta+5 Control+Tab Control+Shift+Tab Control+Meta+Q"),
+	other: chords("Control+N Control+T Control+W Control+Shift+N Control+Shift+T Control+Shift+W Control+Tab Control+Shift+Tab Control+PageUp Control+PageDown Control+F4 Alt+F4 Alt+Tab Alt+Shift+Tab Alt+Space Control+Alt+Tab Control+Alt+Delete")
+};
+/** Whether any step of a binding is a chord the browser or OS reserves on a platform. */
+function isReserved(binding, platform) {
+	return (parseBinding(binding, platform) ?? []).some((chord) => {
+		const written = writeChord(namedChord(chord));
+		return platform === "mac" ? RESERVED.mac.has(written) : chord.meta || RESERVED.other.has(written);
+	});
+}
 /**
-* Whether commands in two scopes are live together whenever either is, so
-* their bindings can collide. A global or `"*"` command is live alongside
-* every scope; two different named scopes are separate surfaces, told apart
-* by which was opened last.
+* Whether commands in two scopes can be live together, so their bindings can
+* collide: a global or `"*"` command overlaps every scope, and two named
+* scopes only when they are the same.
 */
 function scopesOverlap(a, b) {
 	if (a === void 0 || b === void 0) return true;
@@ -948,17 +1251,11 @@ var ScopeStack = class {
 		if (barrier === -1) return this.isOpen(scope);
 		return scope !== void 0 && this.depth(scope) >= barrier;
 	}
-	/**
-	* Whether `scope` is open at all, barriers aside. This is what a direct
-	* `run()` checks: a barrier claims the keyboard, not the command.
-	*/
+	/** Whether `scope` is open at all, barriers aside. This is what a direct `run()` checks. */
 	isOpen(scope) {
 		return scope === void 0 || scope === "*" || this.depth(scope) !== -1;
 	}
-	/**
-	* How far up the stack `scope` was last opened, or `-1` for a global or
-	* closed one. The surface opened last sits highest, and wins a shared key.
-	*/
+	/** How far up the stack `scope` was last opened, or `-1` for a global or closed one. */
 	depth(scope) {
 		if (scope === void 0 || scope === "*") return -1;
 		for (let index = this.#entries.length - 1; index >= 0; index--) if (this.#entries[index]?.name === scope) return index;
@@ -987,26 +1284,58 @@ var ScopeStack = class {
 };
 //#endregion
 //#region src/audit.ts
-/** Development-only warnings about bindings that cannot work as written. */
+/** Development-only warnings about default bindings that cannot work as written. */
+const platformName = (platform) => platform === "mac" ? "macOS" : "Windows and Linux";
+/** A binding as the app wrote it, which is what there is to search the code for. */
+const written = (binding) => stepsOf(binding).join(" ");
 /**
-* Warns about every command: bad syntax, unknown overrides, collisions. The
-* registry calls this behind a `NODE_ENV` check, so a production build drops
-* this whole module.
+* Warns about bad syntax, keys the platform keeps or types with, unknown
+* overrides and collisions. Called behind a `NODE_ENV` check, so a production
+* build drops this module.
 */
 function auditRegistry(source) {
-	for (const id of source.ids) warnAboutBindings(source, id);
-	warnAboutUnknownOverrides(source);
-	warnAboutConflicts(source);
+	const said = /* @__PURE__ */ new Set();
+	const warn = (message) => {
+		if (said.has(message)) return;
+		said.add(message);
+		console.warn(`[@inklu/keys] ${message}`);
+	};
+	/** Reserved bindings, and the platforms each is reserved on. */
+	const reserved = /* @__PURE__ */ new Map();
+	for (const platform of source.platforms) {
+		for (const id of source.ids) for (const binding of source.bindings(id, platform)) {
+			warnAboutBinding(id, binding, platform, warn);
+			if (!isReserved(binding, platform)) continue;
+			const subject = `"${id}" binds "${written(binding)}"`;
+			reserved.set(subject, (reserved.get(subject) ?? /* @__PURE__ */ new Set()).add(platformName(platform)));
+		}
+		warnAboutConflicts(source, platform, warn);
+	}
+	for (const [subject, platforms] of reserved) warn(`${subject}, which the browser or operating system keeps for itself on ${[...platforms].join(" and ")}, so it may never reach the page.`);
+	warnAboutUnknownOverrides(source, warn);
+}
+function warnAboutBinding(id, binding, platform, warn) {
+	const { errors, warnings } = validateBinding(binding);
+	if (errors.length > 0) {
+		warn(`"${id}" has an unrecognized binding "${written(binding)}", so it never fires. ${errors.join("; ")}.`);
+		return;
+	}
+	if (warnings.length > 0) warn(`"${id}" binds "${written(binding)}". ${warnings.join(" ")}`);
+	const held = (parseBinding(binding, platform) ?? []).filter((step) => step.ctrl && step.alt);
+	if (held.length === 0) return;
+	if (platform === "mac") warn(`"${id}" binds "${written(binding)}". Control+Option is the VoiceOver modifier on macOS, so screen reader users cannot press it.`);
+	else if (held.some((step) => typesCharacter({
+		...namedChord(step),
+		ctrl: false,
+		alt: false
+	}))) warn(`"${id}" binds "${written(binding)}". Control+Alt is AltGr on many Windows and Linux keyboard layouts, where it types a character instead. Give those platforms other keys with { mac, other }.`);
 }
-function warnAboutConflicts(source) {
-	const { platform, display } = source;
+function warnAboutConflicts(source, platform, warn) {
 	const seen = /* @__PURE__ */ new Map();
-	const collisions = [];
-	const prefixes = [];
 	const visited = [];
 	for (const id of source.ids) {
 		const scope = source.scope(id);
-		for (const binding of source.bindings(id)) {
+		for (const binding of source.bindings(id, platform)) {
 			for (const other of visited) {
 				if (other.id === id || !scopesOverlap(other.scope, scope)) continue;
 				if (!isPrefixCollision(other.binding, binding, platform)) continue;
@@ -1017,7 +1346,7 @@ function warnAboutConflicts(source) {
 					id,
 					binding
 				}, other];
-				prefixes.push(`${formatBinding(short.binding, display)} ("${short.id}") is a prefix of ${formatBinding(long.binding, display)} ("${long.id}")`);
+				warn(`prefix collision: ${written(short.binding)} ("${short.id}") is a prefix of ${written(long.binding)} ("${long.id}"), so the shorter binding fires on the way to the longer one.`);
 			}
 			visited.push({
 				id,
@@ -1030,263 +1359,21 @@ function warnAboutConflicts(source) {
 				seen.set(key, id);
 				continue;
 			}
-			collisions.push(`${formatBinding(binding, display)} — "${id}" shadows "${owner}"`);
+			warn(`shadowed binding: "${id}" and "${owner}" share ${written(binding)} in the same scope, so "${id}" takes the key whenever both have a handler.`);
 		}
 	}
-	if (collisions.length > 0) console.warn(`[@inklu/keys] ${collisions.length} shadowed binding(s) — same chord, same scope, so the later command takes the key whenever both have a handler:\n  ${collisions.join("\n  ")}`);
-	if (prefixes.length > 0) console.warn(`[@inklu/keys] ${prefixes.length} prefix collision(s) — the shorter binding fires on the way to the longer one:\n  ${prefixes.join("\n  ")}`);
-}
-function warnAboutBindings(source, id) {
-	for (const binding of source.declared(id)) {
-		const { valid, errors, warnings } = validateBinding(binding);
-		if (!valid) console.warn(`[@inklu/keys] "${id}" has an unrecognized binding ${describeBinding(binding)}, so it never fires. ${errors.join("; ")}.`);
-		else if (warnings.length > 0) console.warn(`[@inklu/keys] "${id}" binds ${describeBinding(binding)}. ${warnings.join(" ")}`);
-	}
 }
 /** Catches ids in `options.bindings` that TypeScript could not, as in plain JS. */
-function warnAboutUnknownOverrides(source) {
+function warnAboutUnknownOverrides(source, warn) {
 	if (!source.overrides) return;
 	const known = new Set(source.ids);
 	const unknown = Object.keys(source.overrides).filter((id) => !known.has(id));
-	if (unknown.length > 0) console.warn(`[@inklu/keys] bindings override ${unknown.map((id) => `"${id}"`).join(", ")}, which ${unknown.length === 1 ? "is not a registered command" : "are not registered commands"}.`);
-}
-function describeBinding(binding) {
-	return isSequence(binding) ? `"${binding.sequence.join(" ")}"` : `"${binding}"`;
-}
-//#endregion
-//#region src/keymap.ts
-/** Keymap managing default bindings and user overrides. */
-const DEFAULT_STORAGE_KEY = "inklu.keys";
-const KEYMAP_VERSION = 1;
-/** Type guard narrowing a JSON value to a plain object (excludes arrays and `null`). */
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
-* Same keys on every platform. The keymap is user data that may travel
-* between machines, so `Mod+S` and `Control+S` stay distinct here even on
-* Windows, where they happen to coincide.
-*/
-function portableSignature(binding) {
-	return `${bindingSignature(binding, "mac")} ${bindingSignature(binding, "windows")}`;
-}
-var Keymap = class {
-	#defaults = /* @__PURE__ */ new Map();
-	#overrides = /* @__PURE__ */ new Map();
-	#listeners = /* @__PURE__ */ new Set();
-	#persistence;
-	#loaded = false;
-	constructor(persistence) {
-		this.#persistence = persistence;
-	}
-	/** Sets a command's default bindings. `null` leaves the command unbound. */
-	setDefault(id, input) {
-		const bindings = toBindings(input);
-		if (bindings.length === 0) this.#defaults.delete(id);
-		else this.#defaults.set(id, bindings);
-	}
-	/** Checks whether a command has an active user override. */
-	isOverridden(id) {
-		return this.#overrides.has(id);
-	}
-	get(id) {
-		const defaults = this.#defaults.get(id) ?? [];
-		const override = this.#overrides.get(id);
-		if (!override) return defaults;
-		if (override.kind === "replace") return override.bindings;
-		return [...defaults, ...without(override.bindings, defaults)];
-	}
-	/** Replaces a command's bindings. Passing `null` unbinds it. */
-	set(id, input) {
-		this.load();
-		const bindings = input === null ? [] : toBindings(input);
-		if (sameBindings(bindings, this.#defaults.get(id) ?? [])) {
-			if (!this.#overrides.delete(id)) return;
-		} else this.#overrides.set(id, {
-			kind: "replace",
-			bindings
-		});
-		this.#changed();
-	}
-	/** Adds an additional binding to a command. */
-	add(id, input) {
-		this.load();
-		const added = without(toBindings(input), this.get(id));
-		if (added.length === 0) return;
-		const override = this.#overrides.get(id);
-		this.#overrides.set(id, {
-			kind: override?.kind ?? "add",
-			bindings: [...override?.bindings ?? [], ...added]
-		});
-		this.#changed();
-	}
-	/** Resets user overrides to defaults for one command or all commands. */
-	reset(id) {
-		this.load();
-		if (id === void 0) {
-			if (this.#overrides.size === 0) return;
-			this.#overrides.clear();
-		} else if (!this.#overrides.delete(id)) return;
-		this.#changed();
-	}
-	/** Exports user overrides as a serialized keymap object. */
-	export() {
-		return {
-			version: KEYMAP_VERSION,
-			overrides: Object.fromEntries(Array.from(this.#overrides, ([id, override]) => [id, serializeOverride(override)]))
-		};
-	}
-	/** Imports serialized user overrides and saves to storage. */
-	import(data) {
-		if (!this.#read(data)) return;
-		this.#loaded = true;
-		this.#changed();
-	}
-	/**
-	* Loads persisted overrides from storage, once; returns whether that
-	* changed anything (subscribers have then been told). The registry calls
-	* this on its first mount. `set`, `add` and `reset` call it too, so an
-	* edit made before mount lands on top of the stored overrides instead of
-	* writing over them.
-	*/
-	load() {
-		return !this.#loaded && this.#sync();
-	}
-	/** Reads the stored overrides, telling subscribers if they differ from the ones in memory. */
-	#sync() {
-		this.#loaded = true;
-		const storage = this.#storage();
-		if (!storage) return false;
-		const before = JSON.stringify(this.export());
-		try {
-			const raw = storage.getItem(this.#storageKey());
-			if (raw) this.#read(JSON.parse(raw));
-			else this.#overrides.clear();
-		} catch {
-			return false;
-		}
-		if (JSON.stringify(this.export()) === before) return false;
-		this.#notify();
-		return true;
-	}
-	/**
-	* Follows edits other tabs make to the stored overrides, so rebinding a
-	* key in one tab reaches the rest instead of being overwritten by the next
-	* stale tab to save. Returns a function that stops watching.
-	*/
-	watch() {
-		if (!this.#persistence || typeof window === "undefined") return () => {};
-		const onStorage = (event) => {
-			if (event.key !== null && event.key !== this.#storageKey()) return;
-			this.#sync();
-		};
-		window.addEventListener("storage", onStorage);
-		return () => window.removeEventListener("storage", onStorage);
-	}
-	/** Subscribes to keymap changes. Returns an unsubscribe function. */
-	subscribe(listener) {
-		this.#listeners.add(listener);
-		return () => {
-			this.#listeners.delete(listener);
-		};
-	}
-	/** Replaces the overrides with stored ones. `false` for data this release cannot read. */
-	#read(data) {
-		const entries = storedOverrides(data);
-		if (!entries) return false;
-		this.#overrides.clear();
-		for (const [id, value] of Object.entries(entries)) {
-			const override = deserializeOverride(value);
-			if (override) this.#overrides.set(id, override);
-		}
-		return true;
-	}
-	#changed() {
-		this.#persist();
-		this.#notify();
-	}
-	#notify() {
-		for (const listener of this.#listeners) listener();
-	}
-	#persist() {
-		const storage = this.#storage();
-		if (!storage) return;
-		try {
-			if (this.#overrides.size === 0) storage.removeItem(this.#storageKey());
-			else storage.setItem(this.#storageKey(), JSON.stringify(this.export()));
-		} catch {}
-	}
-	#storageKey() {
-		return this.#persistence?.key ?? DEFAULT_STORAGE_KEY;
-	}
-	#storage() {
-		try {
-			return this.#persistence?.storage() ?? null;
-		} catch {
-			return null;
-		}
-	}
-};
-/** `bindings` minus any already in `existing` or repeated, compared across platforms. */
-function without(bindings, existing) {
-	const known = new Set(existing.map(portableSignature));
-	return bindings.filter((binding) => {
-		const signature = portableSignature(binding);
-		if (known.has(signature)) return false;
-		known.add(signature);
-		return true;
-	});
-}
-/** Same bindings in the same order; the first is the one shortcuts display. */
-function sameBindings(a, b) {
-	return a.length === b.length && a.every((binding, index) => {
-		const other = b[index];
-		return other !== void 0 && portableSignature(binding) === portableSignature(other);
-	});
-}
-/** The overrides in stored data, or `null` if this release cannot read it. */
-function storedOverrides(data) {
-	if (!isJsonObject(data)) return null;
-	if (typeof data.version !== "number") return data;
-	if (data.version !== KEYMAP_VERSION) return null;
-	const overrides = data.overrides;
-	return overrides !== void 0 && isJsonObject(overrides) ? overrides : null;
-}
-function serializeOverride(override) {
-	const bindings = override.bindings.map(serializeBinding);
-	return override.kind === "replace" ? bindings : { add: bindings };
-}
-function deserializeOverride(value) {
-	if (Array.isArray(value)) {
-		const bindings = deserializeBindings(value);
-		return bindings && {
-			kind: "replace",
-			bindings
-		};
-	}
-	if (isJsonObject(value) && Array.isArray(value.add)) {
-		const bindings = deserializeBindings(value.add);
-		return bindings && bindings.length > 0 ? {
-			kind: "add",
-			bindings
-		} : null;
-	}
-	return null;
-}
-/**
-* `[]` is how an unbound command is stored. A non-empty list with nothing
-* usable in it is damage — hand edits, another version's format — and
-* reading it as "unbound" would silently strip the command of its default
-* shortcut, so it reads as `null` instead.
-*/
-function deserializeBindings(values) {
-	const bindings = values.map(deserializeBinding).filter((binding) => binding !== null);
-	return bindings.length === 0 && values.length > 0 ? null : bindings;
+	if (unknown.length > 0) warn(`bindings override ${unknown.map((id) => `"${id}"`).join(", ")}, which ${unknown.length === 1 ? "is not a registered command" : "are not registered commands"}.`);
 }
 //#endregion
 //#region src/registry.ts
 /** Command registry: what an app can do, which keys do it, and where each is live. */
-const SSR_PLATFORM = "windows";
+const SSR_PLATFORM = "other";
 var CommandRegistry = class {
 	#definitions;
 	/** Handlers attached per command, the most recent last. */
@@ -1297,6 +1384,8 @@ var CommandRegistry = class {
 	#options;
 	#listeners = /* @__PURE__ */ new Set();
 	#snapshot = null;
+	/** What the snapshot is behind on: who is reachable, or the bindings too. */
+	#stale = "bindings";
 	#serverSnapshot = null;
 	#pending = null;
 	/** Stops following other tabs' keymap edits; set while mounted. */
@@ -1309,11 +1398,8 @@ var CommandRegistry = class {
 		this.#singleKeys = options.singleKeyShortcuts !== false;
 		this.#keymap = new Keymap(options.persist);
 		this.#definitions = /* @__PURE__ */ new Map();
-		for (const id in definitions) {
-			const definition = definitions[id];
-			this.#definitions.set(id, definition);
-			this.#keymap.setDefault(id, this.#defaultKeys(id, definition));
-		}
+		for (const id in definitions) this.#definitions.set(id, definitions[id]);
+		this.#setDefaults();
 		this.#keys = new KeyListener({
 			ids: () => [...this.#definitions.keys()],
 			definition: (id) => this.#definitions.get(id),
@@ -1332,11 +1418,9 @@ var CommandRegistry = class {
 		if (process.env.NODE_ENV !== "production") auditRegistry({
 			ids: [...this.#definitions.keys()],
 			scope: (id) => this.#definitions.get(id)?.scope,
-			bindings: (id) => this.#bindings(id),
-			declared: (id) => this.#keymap.get(id),
-			overrides: options.bindings,
-			platform: this.#platform(),
-			display: this.#displayOptions()
+			bindings: (id, platform) => this.#defaultBindings(id, platform),
+			platforms: options.platform ? [options.platform] : ["mac", "other"],
+			overrides: options.bindings
 		});
 	}
 	get keymap() {
@@ -1357,7 +1441,7 @@ var CommandRegistry = class {
 		};
 		const singleKeys = this.#options.singleKeyShortcuts !== false;
 		this.#serverSnapshot = Array.from(this.#definitions, ([id, definition]) => {
-			const bindings = toBindings(this.#defaultKeys(id, definition)).filter((binding) => singleKeys || !isSingleKeyBinding(binding));
+			const bindings = this.#defaultBindings(id, platform).filter((binding) => singleKeys || !isSingleKeyBinding(binding));
 			const global = definition.scope === void 0 || definition.scope === "*";
 			return describeCommand(id, definition, bindings, platform, options, {
 				reachable: definition.run !== void 0 && global,
@@ -1418,20 +1502,28 @@ var CommandRegistry = class {
 	}
 	conflicts(binding, options = {}) {
 		const platform = this.#platform();
+		const display = (entry) => formatBinding(entry, this.#displayOptions());
 		const candidates = toBindings(binding);
 		const signatures = new Set(candidates.map((entry) => bindingSignature(entry, platform)));
 		const conflicts = [];
+		for (const candidate of candidates) {
+			if (!isReserved(candidate, platform)) continue;
+			conflicts.push({
+				kind: "reserved",
+				binding: candidate,
+				display: display(candidate)
+			});
+		}
 		for (const [id, { scope }] of this.#definitions) {
 			if (id === options.ignore || !scopesOverlap(scope, options.scope)) continue;
 			for (const existing of this.#bindings(id)) {
 				const kind = signatures.has(bindingSignature(existing, platform)) ? "exact" : candidates.some((candidate) => isPrefixCollision(candidate, existing, platform)) ? "prefix" : null;
 				if (kind === null) continue;
-				const display = formatBinding(existing, this.#displayOptions());
 				conflicts.push({
+					kind,
 					id,
 					binding: existing,
-					kind,
-					display,
+					display: display(existing),
 					scope
 				});
 			}
@@ -1469,10 +1561,13 @@ var CommandRegistry = class {
 	mount() {
 		this.#mounts++;
 		if (this.#mounts === 1) {
+			const rendered = this.#platform();
 			this.#hydrated = true;
+			const moved = this.#platform() !== rendered;
+			if (moved) this.#setDefaults();
 			this.#unwatch = this.#keymap.watch();
 			this.#keys.attach();
-			if (!this.#keymap.load()) this.#bindingsChanged();
+			if (!this.#keymap.sync() && moved) this.#bindingsChanged();
 		}
 		let released = false;
 		return () => {
@@ -1497,7 +1592,7 @@ var CommandRegistry = class {
 		this.#definitions.clear();
 		this.#handlers.clear();
 		this.#serverSnapshot = null;
-		this.#invalidate();
+		this.#invalidate("bindings");
 		this.#listeners.clear();
 		this.#scopes.clear();
 	}
@@ -1514,25 +1609,24 @@ var CommandRegistry = class {
 		if (this.#keys.captured || !this.#handler(id)) return false;
 		return this.#scopes.isActive(this.#definitions.get(id)?.scope);
 	}
-	/**
-	* Bindings in effect: the keymap's, minus single-key ones while those are
-	* switched off. Everything that binds, displays or compares keys reads
-	* this, so a suppressed shortcut is not advertised either.
-	*/
+	/** Bindings in effect: the keymap's, minus single-key ones while those are switched off. */
 	#bindings(id) {
 		const bindings = this.#keymap.get(id);
 		if (this.#singleKeys) return bindings;
 		return bindings.filter((binding) => !isSingleKeyBinding(binding));
 	}
 	/**
-	* A command's default keys: the app's `options.bindings` entry if it has
-	* one, else the definition's own. `hasOwn`, not `??`: a `null` entry
-	* deliberately ships the command unbound, and `??` would read that as
-	* "absent" and restore the very default the app asked to drop.
+	* A command's default bindings on a platform. An `options.bindings` entry
+	* wins over the definition's `keys`, and a `null` one means unbound.
 	*/
-	#defaultKeys(id, definition) {
+	#defaultBindings(id, platform) {
 		const overrides = this.#options.bindings;
-		return overrides && Object.hasOwn(overrides, id) ? overrides[id] : definition.keys;
+		return toBindings(keysFor(overrides && Object.hasOwn(overrides, id) ? overrides[id] : this.#definitions.get(id)?.keys, platform));
+	}
+	/** Hands the keymap every command's defaults for the platform in effect. */
+	#setDefaults() {
+		const platform = this.#platform();
+		for (const id of this.#definitions.keys()) this.#keymap.setDefault(id, this.#defaultBindings(id, platform));
 	}
 	#execute(id, context) {
 		const run = this.#handler(id);
@@ -1563,11 +1657,11 @@ var CommandRegistry = class {
 	}
 	#bindingsChanged() {
 		this.#keys.refresh();
-		this.#invalidate();
+		this.#invalidate("bindings");
 	}
 	#reachabilityChanged() {
 		this.#keys.prune();
-		this.#invalidate();
+		this.#invalidate("reachable");
 	}
 	#platform() {
 		return this.#options.platform ?? (this.#hydrated ? detectPlatform() : SSR_PLATFORM);
@@ -1578,28 +1672,46 @@ var CommandRegistry = class {
 			...this.#options.display
 		};
 	}
+	/**
+	* The commands as they are now. A command that did not change keeps its
+	* object, and the list keeps its own while none did, so a subscriber can
+	* tell by identity whether it has anything to do.
+	*/
 	#snapshots() {
-		if (this.#snapshot) return this.#snapshot;
+		const previous = this.#snapshot;
+		if (previous && !this.#stale) return previous;
+		const kept = this.#stale === "reachable" ? previous?.index : void 0;
 		const platform = this.#platform();
 		const options = this.#displayOptions();
 		const list = [];
 		const index = /* @__PURE__ */ new Map();
+		let changed = !kept;
 		for (const [id, definition] of this.#definitions) {
-			const command = describeCommand(id, definition, this.#bindings(id), platform, options, {
-				reachable: this.#reachable(id),
+			const reachable = this.#reachable(id);
+			let command = kept?.get(id);
+			if (!command) command = describeCommand(id, definition, this.#bindings(id), platform, options, {
+				reachable,
 				overridden: this.#keymap.isOverridden(id)
 			});
+			else if (command.reachable !== reachable) {
+				command = {
+					...command,
+					reachable
+				};
+				changed = true;
+			}
 			list.push(command);
 			index.set(id, command);
 		}
-		this.#snapshot = {
+		this.#stale = null;
+		this.#snapshot = changed || !previous ? {
 			list,
 			index
-		};
+		} : previous;
 		return this.#snapshot;
 	}
-	#invalidate() {
-		this.#snapshot = null;
+	#invalidate(stale) {
+		if (this.#stale !== "bindings") this.#stale = stale;
 		for (const listener of this.#listeners) listener();
 	}
 };
@@ -1646,12 +1758,10 @@ function createCommands(definitions, options) {
 //#endregion
 //#region src/search.ts
 /**
-* Filters commands for a search query, as a command palette does, leaving
-* out `hidden` ones. Every word of the query must appear somewhere in the
-* command — title, description, group, keywords, id or displayed shortcut —
-* in any order. Title matches come first: titles starting with the query,
-* then titles containing every word, then the rest; each tier keeps the
-* list's own order. An empty query returns every visible command.
+* Filters commands for a search query, leaving out `hidden` ones. Every word
+* must appear in the title, description, group, keywords, id or displayed
+* shortcut. Titles starting with the query come first, then titles containing
+* every word, then the rest. An empty query returns every visible command.
 *
 * @example
 * ```ts
@@ -1684,4 +1794,4 @@ function matchCommands(commands, query) {
 	return ranked.sort((a, b) => a.rank - b.rank).map(({ command }) => command);
 }
 //#endregion
-export { bindingTokens as a, isSingleKeyBinding as c, isModifierKey as d, keyName as f, ariaKeyShortcuts as i, seq as l, createCommands as n, formatBinding as o, createRebinder as r, spokenBinding as s, matchCommands as t, validateBinding as u };
+export { importKeymap as a, bindingTokens as c, isSingleKeyBinding as d, seq as f, exportKeymap as i, formatBinding as l, keyName$1 as m, createCommands as n, webStorage as o, isModifierKey as p, createRebinder as r, ariaKeyShortcuts as s, matchCommands as t, spokenBinding as u };