@remit/web-client 0.0.115 → 0.0.117

package/src/hooks/useTriageKeyboard.ts

@@ -1,108 +0,0 @@
-import { useEffect, useRef } from "react";
-import type { TriageAction } from "@/lib/keymap";
-import {
-	dispatchKey,
-	isControlTarget,
-	isEditableTarget,
-	type SequencePrefix,
-} from "@/lib/keymap-dispatch";
-
-/** Map of action → handler. Omitted actions are inert (no-op). */
-export type TriageHandlers = Partial<Record<TriageAction, () => void>>;
-
-interface UseTriageKeyboardOptions {
-	handlers: TriageHandlers;
-	/** Disable the whole layer (e.g. a blocking modal owns the keyboard). */
-	enabled?: boolean;
-	/**
-	 * Reset window (ms) for a pending `g …` sequence prefix. After this with no
-	 * second key, the prefix is dropped. ~1s per the spec.
-	 */
-	sequenceTimeoutMs?: number;
-}
-
-/**
- * Global keydown handler for the triage layer's VERBS (#429). Routes keystrokes
- * through the pure {@link dispatchKey} core to the supplied handler table,
- * staying fully inert while focus is in an editable surface (input/textarea/CE;
- * even Esc is left to the focused field's own handler) and carrying the `g …`
- * go-to sequence prefix across keystrokes with a timeout.
- *
- * List navigation and selection route through here and nowhere else: the
- * message list publishes its commands upward (see `MessageListCommands`) and
- * the route wires them into the handler table, so `@/lib/keymap` is the source
- * of truth for both the displayed bindings and the routed ones. The list used
- * to run a second window listener claiming the same keys, which is what made
- * Enter unusable on every focused button in the app (#43).
- *
- * Other window-level keydown listeners still exist for keys this layer does not
- * own — `?` at the mail layout, `/` in SearchBar, Esc in the compose and
- * conversation views. They bind disjoint keys; only the list's competing
- * listener was removed.
- *
- * Per-action targeting (focused row vs selection) and the actual mutations live
- * in the handlers the caller passes in — this hook only dispatches.
- */
-export function useTriageKeyboard({
-	handlers,
-	enabled = true,
-	sequenceTimeoutMs = 1000,
-}: UseTriageKeyboardOptions): void {
-	// Latest handlers without re-subscribing the listener every render.
-	const handlersRef = useRef(handlers);
-	handlersRef.current = handlers;
-
-	const prefixRef = useRef<SequencePrefix>(null);
-	const prefixTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-
-	useEffect(() => {
-		if (!enabled) return;
-
-		const clearPrefixTimer = () => {
-			if (prefixTimerRef.current !== null) {
-				clearTimeout(prefixTimerRef.current);
-				prefixTimerRef.current = null;
-			}
-		};
-
-		const onKeyDown = (event: KeyboardEvent) => {
-			const result = dispatchKey(
-				{
-					key: event.key,
-					shiftKey: event.shiftKey,
-					metaKey: event.metaKey,
-					ctrlKey: event.ctrlKey,
-					altKey: event.altKey,
-					inEditable: isEditableTarget(event.target),
-					onControl: isControlTarget(event.target),
-				},
-				prefixRef.current,
-			);
-
-			// Update the pending prefix and (re)arm / clear its reset timer.
-			clearPrefixTimer();
-			prefixRef.current = result.nextPrefix;
-			if (result.nextPrefix !== null) {
-				prefixTimerRef.current = setTimeout(() => {
-					prefixRef.current = null;
-					prefixTimerRef.current = null;
-				}, sequenceTimeoutMs);
-			}
-
-			if (result.action === null) return;
-
-			const handler = handlersRef.current[result.action];
-			if (!handler) return;
-
-			if (result.preventDefault) event.preventDefault();
-			handler();
-		};
-
-		window.addEventListener("keydown", onKeyDown);
-		return () => {
-			window.removeEventListener("keydown", onKeyDown);
-			clearPrefixTimer();
-			prefixRef.current = null;
-		};
-	}, [enabled, sequenceTimeoutMs]);
-}

package/src/lib/keymap-dispatch.test.ts

@@ -1,255 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import {
-	dispatchKey,
-	type KeyStroke,
-	type SequencePrefix,
-} from "./keymap-dispatch.ts";
-
-const stroke = (partial: Partial<KeyStroke> & { key: string }): KeyStroke => ({
-	shiftKey: false,
-	metaKey: false,
-	ctrlKey: false,
-	altKey: false,
-	inEditable: false,
-	onControl: false,
-	...partial,
-});
-
-const run = (
-	s: Partial<KeyStroke> & { key: string },
-	prefix: SequencePrefix = null,
-) => dispatchKey(stroke(s), prefix);
-
-describe("dispatchKey — plain bindings", () => {
-	const cases: Array<[string, string]> = [
-		["j", "focusNext"],
-		["k", "focusPrevious"],
-		["Enter", "openFocused"],
-		["u", "toggleRead"],
-		["x", "toggleSelect"],
-		["r", "reply"],
-		["a", "replyAll"],
-		["f", "forward"],
-		["#", "delete"],
-		["s", "toggleStar"],
-		["m", "muteSender"],
-		["b", "blockSender"],
-		["v", "vipSender"],
-		["!", "markJunk"],
-		["i", "toggleIntelligence"],
-		["d", "toggleDensity"],
-		["/", "focusSearch"],
-		["c", "compose"],
-		["?", "help"],
-	];
-
-	for (const [key, action] of cases) {
-		test(`'${key}' → ${action}`, () => {
-			const result = run({ key });
-			assert.strictEqual(result.action, action);
-			assert.strictEqual(result.nextPrefix, null);
-		});
-	}
-
-	test("uppercase letters match case-insensitively", () => {
-		assert.strictEqual(run({ key: "R", shiftKey: true }).action, null);
-		assert.strictEqual(run({ key: "R" }).action, "reply");
-	});
-
-	test("unknown key maps to nothing", () => {
-		assert.strictEqual(run({ key: "q" }).action, null);
-	});
-});
-
-describe("dispatchKey — list navigation", () => {
-	const cases: Array<[string, string]> = [
-		["ArrowDown", "focusNext"],
-		["ArrowUp", "focusPrevious"],
-		["Home", "focusFirst"],
-		["End", "focusLast"],
-		[" ", "toggleSelect"],
-		["Delete", "delete"],
-		["Backspace", "delete"],
-	];
-
-	for (const [key, action] of cases) {
-		test(`'${key}' → ${action}`, () => {
-			const result = run({ key });
-			assert.strictEqual(result.action, action);
-			assert.strictEqual(result.preventDefault, true);
-		});
-	}
-
-	test("Shift+Arrow extends the selection instead of moving the cursor", () => {
-		assert.strictEqual(
-			run({ key: "ArrowDown", shiftKey: true }).action,
-			"extendSelectDown",
-		);
-		assert.strictEqual(
-			run({ key: "ArrowUp", shiftKey: true }).action,
-			"extendSelectUp",
-		);
-	});
-
-	test("⌘A / Ctrl+A selects every loaded row", () => {
-		assert.strictEqual(run({ key: "a", metaKey: true }).action, "selectAll");
-		assert.strictEqual(run({ key: "a", ctrlKey: true }).action, "selectAll");
-		assert.strictEqual(
-			run({ key: "a", metaKey: true }).preventDefault,
-			true,
-			"the browser's select-all-text default must be replaced",
-		);
-	});
-});
-
-describe("dispatchKey — controls keep their activation keys", () => {
-	// The regression behind #43: a global Enter binding cancelled the default
-	// action of whatever the user had tabbed to, so no button in the app could
-	// be activated from the keyboard.
-	test("Enter on a focused control is left to the control", () => {
-		const result = run({ key: "Enter", onControl: true });
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.preventDefault, false);
-	});
-
-	test("Space on a focused control is left to the control", () => {
-		const result = run({ key: " ", onControl: true });
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.preventDefault, false);
-	});
-
-	test("Enter and Space still drive the list away from a control", () => {
-		assert.strictEqual(run({ key: "Enter" }).action, "openFocused");
-		assert.strictEqual(run({ key: " " }).action, "toggleSelect");
-	});
-
-	test("non-activation keys still fire from a focused control", () => {
-		// Tabbing to a toolbar button must not strand the rest of the keymap.
-		assert.strictEqual(run({ key: "j", onControl: true }).action, "focusNext");
-		assert.strictEqual(run({ key: "r", onControl: true }).action, "reply");
-	});
-
-	test("an Enter released to a control still cancels a pending g prefix", () => {
-		assert.strictEqual(
-			run({ key: "Enter", onControl: true }, "g").nextPrefix,
-			null,
-		);
-	});
-});
-
-describe("dispatchKey — input suppression", () => {
-	test("plain keys are inert in an editable surface", () => {
-		assert.strictEqual(run({ key: "j", inEditable: true }).action, null);
-		assert.strictEqual(run({ key: "e", inEditable: true }).action, null);
-		assert.strictEqual(run({ key: "c", inEditable: true }).action, null);
-	});
-
-	test("Esc is inert in an editable surface (field owns its own Esc)", () => {
-		// The layer must NOT emit `back` for Esc-while-typing: that would
-		// double-fire with SearchBar's own Esc (clear query AND close thread).
-		const result = run({ key: "Escape", inEditable: true });
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.preventDefault, false);
-	});
-
-	test("Esc in an input clears a pending g prefix", () => {
-		const result = run({ key: "Escape", inEditable: true }, "g");
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.nextPrefix, null);
-	});
-
-	test("any key in an editable surface clears a pending g prefix", () => {
-		// You can't be mid-`g`-sequence while typing in a field; entering an
-		// editable surface drops any stale prefix so it can't leak back out.
-		const result = run({ key: "x", inEditable: true }, "g");
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.nextPrefix, null);
-	});
-});
-
-describe("dispatchKey — modifiers", () => {
-	test("⌘N / Ctrl+N → compose", () => {
-		assert.strictEqual(run({ key: "n", metaKey: true }).action, "compose");
-		assert.strictEqual(run({ key: "n", ctrlKey: true }).action, "compose");
-	});
-
-	test("other meta combos are left to the browser", () => {
-		assert.strictEqual(run({ key: "c", metaKey: true }).action, null);
-		assert.strictEqual(run({ key: "f", metaKey: true }).action, null);
-	});
-
-	test("Shift+J / Shift+K extend the selection", () => {
-		assert.strictEqual(
-			run({ key: "j", shiftKey: true }).action,
-			"extendSelectDown",
-		);
-		assert.strictEqual(
-			run({ key: "k", shiftKey: true }).action,
-			"extendSelectUp",
-		);
-	});
-
-	test("Shift on a letter verb suppresses it (no Shift+R reply)", () => {
-		assert.strictEqual(run({ key: "r", shiftKey: true }).action, null);
-		assert.strictEqual(run({ key: "e", shiftKey: true }).action, null);
-	});
-
-	test("Shift on a shifted-punctuation binding still fires (#, !, ?)", () => {
-		assert.strictEqual(run({ key: "#", shiftKey: true }).action, "delete");
-		assert.strictEqual(run({ key: "!", shiftKey: true }).action, "markJunk");
-		assert.strictEqual(run({ key: "?", shiftKey: true }).action, "help");
-	});
-});
-
-describe("dispatchKey — g … sequences", () => {
-	test("g arms the prefix without an action", () => {
-		const result = run({ key: "g" });
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.nextPrefix, "g");
-		assert.strictEqual(result.preventDefault, true);
-	});
-
-	const seq: Array<[string, string]> = [
-		["b", "goBrief"],
-		["i", "goInbox"],
-		["s", "goSent"],
-		["f", "goFlagged"],
-		[",", "goSettings"],
-	];
-	for (const [key, action] of seq) {
-		test(`g then '${key}' → ${action}`, () => {
-			const result = run({ key }, "g");
-			assert.strictEqual(result.action, action);
-			assert.strictEqual(result.nextPrefix, null);
-		});
-	}
-
-	test("g then an unmapped key cancels the prefix and is inert", () => {
-		const result = run({ key: "q" }, "g");
-		assert.strictEqual(result.action, null);
-		assert.strictEqual(result.nextPrefix, null);
-	});
-
-	test("Shift+G does not arm the prefix", () => {
-		assert.strictEqual(run({ key: "g", shiftKey: true }).nextPrefix, null);
-	});
-
-	test("after a sequence resolves, the next key is a plain binding again", () => {
-		const first = run({ key: "g" });
-		assert.strictEqual(first.nextPrefix, "g");
-		const second = run({ key: "j" }, first.nextPrefix);
-		// 'j' is not a go-to key → cancels, inert.
-		assert.strictEqual(second.action, null);
-		const third = run({ key: "j" }, second.nextPrefix);
-		assert.strictEqual(third.action, "focusNext");
-	});
-});
-
-describe("dispatchKey — escape", () => {
-	test("Esc maps to back and clears any prefix", () => {
-		const result = run({ key: "Escape" }, "g");
-		assert.strictEqual(result.action, "back");
-		assert.strictEqual(result.nextPrefix, null);
-	});
-});

package/src/lib/keymap-dispatch.ts

@@ -1,244 +0,0 @@
-import type { TriageAction } from "./keymap.js";
-
-/**
- * Pure dispatch core for the global triage keyboard layer (#429).
- *
- * The React hook (`useTriageKeyboard`) owns DOM wiring and the handler table;
- * this module owns the *decision* — given a normalized keystroke and the
- * current sequence-prefix state, which {@link TriageAction} (if any) fires, and
- * what the next sequence-prefix state is. Keeping it pure makes the routing,
- * input suppression and `g`-prefix sequencing unit-testable without JSDOM.
- */
-
-/** The subset of a KeyboardEvent the dispatcher reads. */
-export interface KeyStroke {
-	key: string;
-	shiftKey: boolean;
-	metaKey: boolean;
-	ctrlKey: boolean;
-	altKey: boolean;
-	/** Whether the event originated inside an editable surface. */
-	inEditable: boolean;
-	/**
-	 * Whether the event originated on an activatable control that is not a
-	 * message-list row — a button, link, `role="button"`, `<summary>`. Enter and
-	 * Space are that control's activation keys, so the layer releases them; every
-	 * other binding still fires. Without this a global Enter binding cancels the
-	 * default action of whatever the user tabbed to, and no button in the app can
-	 * be activated from the keyboard.
-	 */
-	onControl: boolean;
-}
-
-/** Pending sequence-prefix state. `"g"` means a `g` was pressed recently. */
-export type SequencePrefix = null | "g";
-
-export interface DispatchResult {
-	/** The action to run, or null when the stroke maps to nothing actionable. */
-	action: TriageAction | null;
-	/** The sequence-prefix state to carry into the next stroke. */
-	nextPrefix: SequencePrefix;
-	/** Whether the host should preventDefault on this stroke. */
-	preventDefault: boolean;
-}
-
-const NONE: DispatchResult = {
-	action: null,
-	nextPrefix: null,
-	preventDefault: false,
-};
-
-/**
- * Second key of a `g …` go-to sequence → action. Keys are lowercased; `,`
- * stays as-is.
- */
-const GO_TO_SEQUENCE: Record<string, TriageAction> = {
-	b: "goBrief",
-	i: "goInbox",
-	s: "goSent",
-	f: "goFlagged",
-	",": "goSettings",
-};
-
-/**
- * Plain single-key bindings (no meta, no `g` prefix). `shift` here means the
- * binding *requires* shift; absence means shift must be absent.
- */
-interface PlainBinding {
-	action: TriageAction;
-	requireShift?: boolean;
-}
-
-/**
- * Lowercased key → binding. `event.key` is lowercased before lookup, so the
- * shifted variants (`#`, `!`, `?`) are matched by their produced character, and
- * letter keys ignore caps. Shift-j/k extend selection and are handled before
- * this table.
- */
-const PLAIN_BINDINGS: Record<string, PlainBinding> = {
-	j: { action: "focusNext" },
-	k: { action: "focusPrevious" },
-	arrowdown: { action: "focusNext" },
-	arrowup: { action: "focusPrevious" },
-	home: { action: "focusFirst" },
-	end: { action: "focusLast" },
-	enter: { action: "openFocused" },
-	" ": { action: "toggleSelect" },
-	delete: { action: "delete" },
-	backspace: { action: "delete" },
-	u: { action: "toggleRead" },
-	x: { action: "toggleSelect" },
-	r: { action: "reply" },
-	a: { action: "replyAll" },
-	f: { action: "forward" },
-	"#": { action: "delete" },
-	s: { action: "toggleStar" },
-	m: { action: "muteSender" },
-	b: { action: "blockSender" },
-	v: { action: "vipSender" },
-	"!": { action: "markJunk" },
-	i: { action: "toggleIntelligence" },
-	d: { action: "toggleDensity" },
-	"/": { action: "focusSearch" },
-	c: { action: "compose" },
-	"?": { action: "help" },
-};
-
-/**
- * Resolve a keystroke into an action and the next sequence-prefix state. Pure:
- * no DOM, no side effects.
- *
- * Rules:
- * - In an editable surface only `Esc` fires (clears any pending prefix).
- * - `⌘N` / `Ctrl+N` → compose (the only meta combo we own).
- * - A pending `g` prefix consumes the next key as a go-to sequence; an
- *   unmatched second key cancels the prefix and is otherwise inert.
- * - `g` (no modifiers) arms the prefix.
- * - `Shift+J` / `Shift+K` extend the selection.
- * - Otherwise a plain single-key binding fires.
- * - Any non-Esc keystroke clears a stale prefix.
- */
-export function dispatchKey(
-	stroke: KeyStroke,
-	prefix: SequencePrefix,
-): DispatchResult {
-	const lower = stroke.key.toLowerCase();
-	const meta = stroke.metaKey || stroke.ctrlKey;
-
-	// Editable surfaces: the layer is fully inert. Even Esc is left to the
-	// focused field's own handler (SearchBar clears the query / blurs on Esc);
-	// emitting `back` here would double-fire — clearing search AND closing the
-	// open thread on one keypress. We still clear any pending `g` prefix so a
-	// stray sequence can't leak across a focus change into the field.
-	if (stroke.inEditable) {
-		return { ...NONE, nextPrefix: prefix === "g" ? null : prefix };
-	}
-
-	// Enter / Space belong to whatever control has focus. Releasing them here is
-	// what keeps Tab-to-a-button-then-Enter working anywhere in the app; the
-	// list's own rows are excluded from `onControl`, so the roving cursor still
-	// opens and selects.
-	if (stroke.onControl && (lower === "enter" || lower === " ")) {
-		return { ...NONE, nextPrefix: prefix === "g" ? null : prefix };
-	}
-
-	// ⌘N / Ctrl+N → compose. Checked before the prefix/plain tables so the
-	// browser's "new window" is the only thing we intercept among meta combos.
-	if (meta && lower === "n") {
-		return { action: "compose", nextPrefix: null, preventDefault: true };
-	}
-
-	// ⌘A / Ctrl+A → select every loaded row, replacing the browser's
-	// select-all-text default.
-	if (meta && lower === "a") {
-		return { action: "selectAll", nextPrefix: null, preventDefault: true };
-	}
-
-	// Any other meta/ctrl combo is left to the browser/OS.
-	if (meta) return { ...NONE, nextPrefix: prefix === "g" ? null : prefix };
-
-	// Esc: back/close. Always clears the prefix.
-	if (lower === "escape") {
-		return { action: "back", nextPrefix: null, preventDefault: false };
-	}
-
-	// Resolve a pending `g …` sequence.
-	if (prefix === "g") {
-		const seqKey = lower === "," ? "," : lower;
-		const action = GO_TO_SEQUENCE[seqKey] ?? null;
-		// Consume the second key whether or not it matched; the prefix resets.
-		return { action, nextPrefix: null, preventDefault: action !== null };
-	}
-
-	// Arm the `g` prefix (no shift, no modifiers).
-	if (lower === "g" && !stroke.shiftKey) {
-		return { action: null, nextPrefix: "g", preventDefault: true };
-	}
-
-	// Shift+J/K and Shift+Arrow extend the selection.
-	if (stroke.shiftKey) {
-		const down = lower === "j" || lower === "arrowdown";
-		const up = lower === "k" || lower === "arrowup";
-		if (down || up) {
-			return {
-				action: down ? "extendSelectDown" : "extendSelectUp",
-				nextPrefix: null,
-				preventDefault: true,
-			};
-		}
-	}
-
-	// Plain single-key bindings.
-	const binding = PLAIN_BINDINGS[lower];
-	if (binding) {
-		const needsShift = binding.requireShift === true;
-		// `?`, `#`, `!` are produced with Shift on most layouts; their entries
-		// are keyed by the produced character so we don't gate on shift here.
-		// Plain letter bindings must NOT fire when shift is held (e.g. Shift+R).
-		const isPunctuation = lower.length === 1 && !/[a-z0-9]/.test(lower);
-		if (!needsShift && stroke.shiftKey && !isPunctuation) {
-			return NONE;
-		}
-		return { action: binding.action, nextPrefix: null, preventDefault: true };
-	}
-
-	return NONE;
-}
-
-/**
- * Whether a DOM event target is an editable surface (input/textarea/select/
- * contenteditable). Exposed so the hook and tests share one definition.
- */
-export function isEditableTarget(target: EventTarget | null): boolean {
-	if (!(target instanceof HTMLElement)) return false;
-	const tag = target.tagName;
-	return (
-		tag === "INPUT" ||
-		tag === "TEXTAREA" ||
-		tag === "SELECT" ||
-		target.isContentEditable
-	);
-}
-
-/**
- * Marks an element as a message-list row. Rows are anchors, so they would
- * otherwise read as ordinary controls; the list owns Enter/Space on them.
- */
-export const ROW_ATTRIBUTE = "data-message-row";
-
-const CONTROL_SELECTOR =
-	'button, a[href], summary, [role="button"], [role="menuitem"], [role="tab"], [role="switch"], [role="checkbox"]';
-
-/**
- * Whether the event target sits inside an activatable control that is not a
- * message-list row. See {@link KeyStroke.onControl}.
- */
-export function isControlTarget(target: EventTarget | null): boolean {
-	if (!(target instanceof HTMLElement)) return false;
-	const control = target.closest(CONTROL_SELECTOR);
-	if (!control) return false;
-	// The nearest control wins. A row is an anchor and so matches the selector,
-	// but the list owns Enter/Space on its rows; a control nested *inside* a row
-	// (the select checkbox) is a control like any other and keeps its own keys.
-	return !control.hasAttribute(ROW_ATTRIBUTE);
-}

package/src/lib/keymap.test.ts

@@ -1,68 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import {
-	KEY_HINT_GROUPS,
-	keysForAction,
-	shortcutHintForAction,
-	tooltipForAction,
-} from "./keymap.ts";
-
-describe("keymap module", () => {
-	test("exposes the documented groups in reading order", () => {
-		const titles = KEY_HINT_GROUPS.map((g) => g.title);
-		assert.deepStrictEqual(titles, [
-			"Navigation",
-			"Selection",
-			"Actions",
-			"Sender",
-			"Go to",
-			"View & global",
-		]);
-	});
-
-	test("keysForAction returns the first hint's tokens", () => {
-		assert.deepStrictEqual(keysForAction("reply"), ["r"]);
-		assert.deepStrictEqual(keysForAction("goBrief"), ["g", "b"]);
-	});
-
-	test("keysForAction is undefined for an action with no hint", () => {
-		// `back` has a hint; a contrived missing lookup returns undefined.
-		assert.strictEqual(
-			keysForAction("totallyMissing" as Parameters<typeof keysForAction>[0]),
-			undefined,
-		);
-	});
-
-	test("tooltipForAction renders single keys, sequences and combos", () => {
-		assert.strictEqual(tooltipForAction("reply"), "(r)");
-		assert.strictEqual(tooltipForAction("goBrief"), "(g then b)");
-		// compose's first hint is the single 'c' key.
-		assert.strictEqual(tooltipForAction("compose"), "(c)");
-	});
-
-	test("shortcutHintForAction renders the binding without the parens", () => {
-		assert.strictEqual(shortcutHintForAction("reply"), "r");
-		assert.strictEqual(shortcutHintForAction("goBrief"), "g then b");
-		assert.strictEqual(shortcutHintForAction("compose"), "c");
-	});
-
-	test("an action with no binding gets no hint and no empty parens", () => {
-		const unbound = "totallyMissing" as Parameters<
-			typeof shortcutHintForAction
-		>[0];
-		assert.strictEqual(shortcutHintForAction(unbound), "");
-		assert.strictEqual(tooltipForAction(unbound), "");
-	});
-
-	test("every hint's action is a non-empty key list", () => {
-		for (const group of KEY_HINT_GROUPS) {
-			for (const hint of group.hints) {
-				assert.ok(hint.keys.length > 0, `${hint.action} has keys`);
-				assert.ok(
-					hint.description.length > 0,
-					`${hint.action} has a description`,
-				);
-			}
-		}
-	});
-});