@3sln/trove 0.0.2

package/packages/web/src/platform/context.js

@@ -0,0 +1,77 @@
+// ContextKeyService — the reactive bag of boolean/string/number flags that
+// describe the workbench's current state (which view is focused, whether a file
+// is open, its type, whether the palette is showing…). when-clauses evaluate
+// against it, so commands/keybindings/menus light up and dim as state changes.
+//
+// It's a single cell of the whole context object, so any consumer can `watch` it and
+// re-render, and keybinding resolution reads a plain snapshot.
+// Plugins get a *scoped* setter (keys they set are namespaced under their id) so
+// they can drive their own when-clauses without stomping core keys.
+
+import { cell } from '../runtime.js';
+import { evaluateWhen } from './whenclause.js';
+
+export class ContextKeyService {
+  constructor(initial = {}) {
+    this.state = {
+      platform: navigatorPlatform(),
+      isMac: /mac/i.test(navigatorPlatform()),
+      ...initial,
+    };
+    this.cell = cell(this.state);
+  }
+
+  get(key) {
+    return this.state[key];
+  }
+  snapshot() {
+    return this.state;
+  }
+  observe() {
+    return this.cell;
+  }
+
+  set(key, value) {
+    if (this.state[key] === value) return;
+    this.state = { ...this.state, [key]: value };
+    this.cell.setValue(this.state);
+  }
+  setMany(obj) {
+    let changed = false;
+    const next = { ...this.state };
+    for (const [k, v] of Object.entries(obj)) {
+      if (next[k] !== v) {
+        next[k] = v;
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.state = next;
+      this.cell.setValue(next);
+    }
+  }
+  remove(key) {
+    if (!(key in this.state)) return;
+    const { [key]: _drop, ...rest } = this.state;
+    this.state = rest;
+    this.cell.setValue(rest);
+  }
+
+  /** True if `whenExpr` holds against the current context. */
+  evaluate(whenExpr) {
+    return evaluateWhen(whenExpr, this.state);
+  }
+
+  /** A setter namespaced under a plugin id, so plugin keys can't collide. */
+  scopedFor(pluginId) {
+    const prefix = `${pluginId}.`;
+    return {
+      set: (key, value) => this.set(prefix + key, value),
+      remove: (key) => this.remove(prefix + key),
+    };
+  }
+}
+
+function navigatorPlatform() {
+  return typeof navigator !== 'undefined' ? navigator.platform || navigator.userAgent || '' : '';
+}

package/packages/web/src/platform/contributions.js

@@ -0,0 +1,156 @@
+// ContributionRegistry — ONE map of `uri -> contribution`, where every contribution
+// carries its own `type` and that type's options.
+//
+// There used to be a separate collection per kind (commands, openers, statusItems…),
+// which meant a name could mean different things in different collections and nothing
+// tied a contribution back to a verifiable owner. Now there is a single address space:
+//
+//   trove+contrib:acme.com/docs/pdfViewer   { type: 'opener',     match, entry }
+//   trove+contrib:acme.com/docs/status      { type: 'statusItem', slot, render }
+//   trove+contrib:acme.com/docs/busy        { type: 'register',   default }
+//   trove+contrib:acme.com/docs/keys        { type: 'keymap',     bindings }
+//   trove+contrib:core/workbench/…          built-ins, reserved `core` domain
+//
+// So a plugin's opener, status slot, register and command may all be called "status"
+// without colliding — with each other, or with another plugin's.
+//
+// Contribution types (see @3sln/trove/core/plugins/contributions.js for the manifest form):
+//   command     { title, category?, icon?, when?, offline?, palette? }
+//   opener      { title, match:{ext,mime}, entry, priority?, offline?, dock? }
+//   indexer     { title, match, entry }            (declared here; the SERVER runs it)
+//   statusItem  { slot:'left'|'right', render:'html', order?, when?, offline? }
+//   register    { default?, description? }         (a context value slot)
+//   keymap      { bindings:[{key, command, when?, args?}] }
+//   view        { title, icon?, match?, priority?, render, move? }
+
+import { cell, derive } from '../runtime.js';
+import { selectorMatches } from '@3sln/trove/core/util.js';
+import { parseContribUri, coreUri, CONTRIB_SCHEME } from '@3sln/trove/core/plugins/identity.js';
+import { CONTRIBUTION_TYPES as PACKAGE_TYPES } from '@3sln/trove/core/plugins/contributions.js';
+
+// Everything a package can declare, plus the workbench's own. `view` — how a list of
+// results is drawn — is the second kind: it is not part of the package format, so core
+// (which is where the manifest is parsed) has no reason to know the word.
+export const CONTRIBUTION_TYPES = [...PACKAGE_TYPES, 'view'];
+
+/**
+ * Address normalization — the one rule: a bare name belongs to the host's reserved
+ * `core` domain, anything from a plugin is always fully qualified. So the workbench
+ * keeps saying `exec('explorer.delete')` while every contribution still has a real,
+ * unambiguous URI (`trove+contrib:core/workbench/explorer.delete`).
+ */
+export function toUri(nameOrUri) {
+  return String(nameOrUri).startsWith(CONTRIB_SCHEME) ? nameOrUri : coreUri(nameOrUri);
+}
+
+export class ContributionRegistry {
+  constructor() {
+    this.items = new Map(); // uri -> { uri, type, id, name, pluginId, ...options }
+    this.cell = cell([]);
+    this.byType = new Map(); // type -> derived cell (lazily created)
+  }
+
+  #emit() {
+    this.cell.setValue([...this.items.values()]);
+  }
+
+  /**
+   * Register one contribution at its URI. Returns a dispose fn.
+   * @param {string} nameOrUri  a bare core name, or trove+contrib:<domain>/<plugin>/<name>
+   * @param {{type: string}} contribution
+   */
+  register(nameOrUri, contribution) {
+    const type = contribution?.type;
+    if (!CONTRIBUTION_TYPES.includes(type)) {
+      throw new Error(`Unknown contribution type "${type}" for ${nameOrUri}`);
+    }
+    const uri = toUri(nameOrUri);
+    const parsed = parseContribUri(uri);
+    if (!parsed) throw new Error(`Not a contribution URI: ${uri}`);
+    const pluginId = contribution.pluginId ?? (parsed.domain === 'core' ? null : parsed.pluginId);
+    const entry = {
+      ...contribution, uri, type,
+      // `id` is the short name the workbench uses to address it (bare for built-ins,
+      // the URI for plugin contributions, which are only ever addressed fully).
+      id: parsed.domain === 'core' ? parsed.name : uri,
+      name: parsed.name,
+      pluginId,
+    };
+    this.items.set(uri, entry);
+    this.#emit();
+    return () => this.unregister(uri);
+  }
+
+  /** Merge new options into an existing contribution (a plugin driving its own slot). */
+  update(nameOrUri, patch) {
+    const uri = toUri(nameOrUri);
+    const cur = this.items.get(uri);
+    if (!cur) return false;
+    this.items.set(uri, { ...cur, ...patch });
+    this.#emit();
+    return true;
+  }
+
+  unregister(nameOrUri) {
+    if (this.items.delete(toUri(nameOrUri))) this.#emit();
+  }
+  /** Drop everything a plugin contributed (uninstall / reload). */
+  unregisterPlugin(pluginId) {
+    let changed = false;
+    for (const [uri, c] of this.items) if (c.pluginId === pluginId) { this.items.delete(uri); changed = true; }
+    if (changed) this.#emit();
+  }
+
+  get(nameOrUri) {
+    return nameOrUri ? this.items.get(toUri(nameOrUri)) || null : null;
+  }
+  all() {
+    return [...this.items.values()];
+  }
+  ofType(type) {
+    return this.all().filter((c) => c.type === type);
+  }
+  /** One plugin's contributions, optionally of a single type. */
+  ofPlugin(pluginId, type) {
+    return this.all().filter((c) => c.pluginId === pluginId && (!type || c.type === type));
+  }
+  observe() {
+    return this.cell;
+  }
+  /**
+   * A reactive view of one type (status items, openers, …).
+   *
+   * Derived rather than a second subject fanned out to by hand: `derive` recomputes
+   * from the one list, and a watcher of the result is only re-rendered when its own
+   * slice actually differs — so registering an opener no longer redraws the status bar.
+   */
+  observeType(type) {
+    let view = this.byType.get(type);
+    if (!view) {
+      view = derive([this.cell], (all) => all.filter((c) => c.type === type));
+      this.byType.set(type, view);
+    }
+    return view;
+  }
+
+  // --- typed lookups ---------------------------------------------------------
+
+  /** Every opener whose selector matches `node`, best (highest priority) first. */
+  openersFor(node) {
+    return this.ofType('opener')
+      .filter((o) => selectorMatches(o.match, node))
+      .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+
+  /** Pick the best opener for a node, honouring `when` and availability. */
+  openerFor(node, evaluate, isAvailable) {
+    return this.openersFor(node)
+      .find((o) => (!o.when || evaluate(o.when)) && (!isAvailable || isAvailable(o))) || null;
+  }
+
+  /** Every keybinding from every registered keymap, in registration order. */
+  keybindings() {
+    return this.ofType('keymap').flatMap((k) =>
+      (k.bindings || []).map((b) => ({ ...b, keymap: k.uri, pluginId: k.pluginId })));
+  }
+}

package/packages/web/src/platform/index.js

@@ -0,0 +1,150 @@
+// createPlatform — assemble every service into one object the whole app shares.
+// This is the "workbench platform": the reactive registries and services that
+// core features and plugins both build on. It also registers the default
+// settings schema and keybindings so the shell has sensible behaviour out of the
+// box. UI-facing shell state (which activity is open, is the palette showing…)
+// lives in WorkbenchService; data and mutations go through ngin (see ../bl).
+
+import { reactive } from '../runtime.js';
+import { ContributionRegistry } from './contributions.js';
+import { ContextKeyService } from './context.js';
+import { CommandService } from './commands.js';
+import { KeybindingService } from './keybindings.js';
+import { SettingsService } from './settings.js';
+import { NotificationService } from './notifications.js';
+import { TroveApiClient } from './api.js';
+import { PluginHost } from './pluginHost.js';
+import { WorkbenchService } from './workbench.js';
+import { ViewportService } from './viewport.js';
+import { SpatialNavigationService } from './spatialNav.js';
+import { VoiceSearchService } from './voiceSearch.js';
+import { MediaUrlService } from './mediaUrls.js';
+
+/**
+ * The bearer token for this browser, if any.
+ *
+ * `localStorage` rather than a cookie because the token is presented as an
+ * Authorization header, not sent ambiently — which is what makes CSRF a non-issue here.
+ * Wrapped in try/catch because storage access throws outright in some privacy modes,
+ * and a drive that white-screens because it couldn't read a key that is usually absent
+ * would be a poor trade.
+ */
+export function readToken() {
+  try { return localStorage.getItem('trove.token') || null; } catch { return null; }
+}
+/** Store (or clear, with null) the bearer token this browser presents. */
+export function writeToken(token) {
+  try {
+    if (token) localStorage.setItem('trove.token', token);
+    else localStorage.removeItem('trove.token');
+  } catch { /* storage unavailable; the session is simply not persisted */ }
+}
+
+export function createPlatform({ baseUrl = '' } = {}) {
+  const contributions = new ContributionRegistry();
+  // 'home' is where the app actually starts (WorkbenchService's initial `activity`), and
+  // nothing writes this key until the user navigates. Seeding it with a view that no
+  // longer exists left every `when: view.active == 'home'` binding — the Delete
+  // shortcut among them — dead from boot until the first click on the rail, while the
+  // row menu cheerfully advertised "Del" as the way to delete.
+  const context = new ContextKeyService({ 'view.active': 'home', 'sidebar.visible': true });
+  const notifications = new NotificationService();
+  const commands = new CommandService(contributions, context, notifications);
+  const settings = new SettingsService();
+  const keybindings = new KeybindingService(contributions, commands, context, settings);
+  // A bearer token, when this deployment uses one. Most don't: an authenticating proxy
+  // (Cloudflare Access, oauth2-proxy) sets its own header and the browser sends nothing.
+  // But a deployment where the user HOLDS a token has no other way to present it, and
+  // reading it here — once, from one place — keeps that out of every call site.
+  const api = new TroveApiClient({ baseUrl, token: () => readToken() });
+  const workbench = new WorkbenchService(context);
+  // Which shell to render — phone, desktop, or TV. Constructed before the defaults are
+  // registered, so it reads the setting through `settings.get` once that exists.
+  const viewport = new ViewportService({ settings, context });
+  // Arrow keys → geometry, but only on a TV. Inert everywhere else.
+  const spatialNav = new SpatialNavigationService({ workbench, viewport });
+  // Speak to search. Mostly this just puts the search field under the remote's mic —
+  // see voiceSearch.js for why that is the whole feature on a TV.
+  const voice = new VoiceSearchService({ workbench, notifications, settings });
+
+  const platform = {
+    reactive,
+    contributions, context, commands, keybindings, settings, notifications, api, workbench,
+    viewport, spatialNav, voice,
+    capabilities: null,
+    openPluginPanel: null, // set by the workbench UI
+  };
+  platform.mediaUrls = new MediaUrlService({ api: platform.api, settings });
+  platform.plugins = new PluginHost(platform);
+  // Commands consult the plugin host to hide/disable plugin commands that aren't
+  // available right now (offline, or the plugin isn't responding).
+  commands.availability = (cmd) => platform.plugins.isAvailable(cmd);
+
+  registerDefaults(platform);
+  // Defaults are in place now, so re-measure: `workbench.layout` was unreadable a moment
+  // ago and a forced layout must not need a resize to take effect.
+  viewport.refresh();
+  return platform;
+}
+
+function registerDefaults(p) {
+  // --- default settings schema ----------------------------------------------
+  p.settings.register([
+    { key: 'workbench.theme', type: 'enum', enum: ['dark', 'light', 'midnight'], enumLabels: ['Dark', 'Light', 'Midnight'], default: 'dark', title: 'Color theme', category: 'Appearance', order: 1 },
+    { key: 'workbench.density', type: 'enum', enum: ['comfortable', 'compact'], default: 'comfortable', title: 'List density', category: 'Appearance', order: 2 },
+    // Auto gets it right for phones and desktops. TVs are the reason this is a setting:
+    // a browser on a set-top box usually looks like a large desktop, so someone using
+    // one with a remote needs a way to say so.
+    { key: 'workbench.layout', type: 'enum', enum: ['auto', 'desktop', 'phone', 'tv'],
+      enumLabels: ['Automatic', 'Desktop', 'Phone', 'TV / remote'], default: 'auto',
+      title: 'Layout', description: 'Automatic follows the screen size. Choose TV for d-pad remote navigation.',
+      category: 'Appearance', order: 3 },
+    { key: 'explorer.sort', type: 'enum', enum: ['name', 'size', 'updatedAt'], enumLabels: ['Name', 'Size', 'Modified'], default: 'name', title: 'Sort files by', category: 'Explorer', order: 1 },
+    { key: 'explorer.sortOrder', type: 'enum', enum: ['asc', 'desc'], default: 'asc', title: 'Sort order', category: 'Explorer', order: 2 },
+    { key: 'explorer.confirmDelete', type: 'boolean', default: true, title: 'Confirm before deleting', category: 'Explorer', order: 3 },
+    { key: 'search.mode', type: 'enum', enum: ['hybrid', 'semantic', 'keyword'], default: 'hybrid', title: 'Search mode', description: 'Hybrid blends semantic meaning with keyword matches.', category: 'Search', order: 1 },
+    { key: 'uploads.concurrency', type: 'number', minimum: 1, maximum: 8, default: 4, title: 'Parallel upload parts', category: 'Transfers', order: 1 },
+    // Which viewer opens which file type. When several openers match a file and there
+    // is no entry here, the user is asked (and can save their answer) — see bl/openers.
+    // Markdown ships with an answer already: it matches both the markdown renderer and
+    // the plain-text viewer, and since documents are how things are grouped now,
+    // prompting on every first .md would be friction over a decision that's obvious.
+    // It stays changeable in Settings, and the text viewer is still reachable through
+    // the opener switcher.
+    { key: 'openers.associations', type: 'object', hidden: true, title: 'Default viewers',
+      default: { '.md': 'core.markdown', '.markdown': 'core.markdown' } },
+    // How results are drawn (see ui/components/views). Hidden and with no default on
+    // purpose: unset means "you decide", and the launcher then offers the grid by itself
+    // for a collection full of pictures. Picking one in the switcher pins it.
+    { key: 'explorer.view', type: 'string', hidden: true, title: 'Results view' },
+    // Whether media fetches use a URL that carries its own grant (see
+    // platform/mediaUrls.js). `auto` mints only where the browser cannot authenticate
+    // itself, which is the right answer almost everywhere — hence hidden.
+    { key: 'media.signedUrls', type: 'enum', enum: ['auto', 'always', 'never'], default: 'auto',
+      hidden: true, title: 'Signed media URLs' },
+  ]);
+
+  // --- the built-in keymap (commands themselves are registered in ../bl) -----
+  // One `keymap` contribution, exactly like a plugin's — the host has no privileged
+  // path into the keybinding service.
+  p.contributions.register('keymap.default', {
+    type: 'keymap',
+    bindings: [
+      { key: 'mod+shift+p', command: 'workbench.showCommandPalette' },
+      { key: 'mod+p', command: 'workbench.quickOpen' },
+      { key: 'mod+shift+f', command: 'workbench.view.home' },
+      { key: 'mod+shift+e', command: 'workbench.view.home' },
+      { key: 'mod+,', command: 'workbench.openSettings' },
+      { key: 'mod+shift+l', command: 'explorer.copyLink' },
+      { key: 'mod+u', command: 'explorer.upload' },
+      { key: 'delete', command: 'explorer.delete', when: "view.active == 'home' && explorer.hasSelection" },
+      { key: 'escape', command: 'workbench.closeOverlays' },
+      { key: 'f5', command: 'explorer.refresh' },
+      { key: 'mod+shift+i', command: 'workbench.toggleInfoPanel' },
+      // Some remotes and keyboards send a dedicated search key; where they do, it lands
+      // on the one command that opens the search field ready for dictation.
+      { key: 'mod+shift+v', command: 'search.voice' },
+      { key: 'browsersearch', command: 'search.voice' },
+    ],
+  });
+}

package/packages/web/src/platform/keybindings.js

@@ -0,0 +1,199 @@
+// KeybindingService — turns keystrokes into command executions, honouring
+// when-clauses and chords (multi-key sequences like "ctrl+k ctrl+s").
+//
+// Bindings come from `keymap` CONTRIBUTIONS: the host contributes one built-in keymap,
+// and a plugin contributes one by declaring `{ type: 'keymap', path: 'keymaps/x.json' }`
+// in its manifest (the host reads and validates that file at install). So core and
+// plugins share exactly one keymap and the shortcuts UI can render all of it.
+// User rebinds live in settings under `keybindings.overrides` (command -> key) and win
+// over whatever a keymap declared. Typing in an input is respected: only bindings with
+// a modifier (or Escape) fire while editing.
+
+export const OVERRIDES_KEY = 'keybindings.overrides';
+
+export function normalizeKey(str) {
+  // Canonical form: sorted modifiers + key, lowercased. "Cmd+Shift+P" → "meta+shift+p"
+  const parts = str.trim().toLowerCase().split('+').map((p) => p.trim());
+  const mods = new Set();
+  let key = '';
+  for (const p of parts) {
+    if (['ctrl', 'control'].includes(p)) mods.add('ctrl');
+    else if (['cmd', 'meta', 'super', 'win'].includes(p)) mods.add('meta');
+    else if (p === 'alt' || p === 'option') mods.add('alt');
+    else if (p === 'shift') mods.add('shift');
+    else if (['ctrlcmd', 'mod'].includes(p)) mods.add(isMac() ? 'meta' : 'ctrl');
+    else key = p;
+  }
+  const order = ['ctrl', 'meta', 'alt', 'shift'];
+  return [...order.filter((m) => mods.has(m)), key].filter(Boolean).join('+');
+}
+
+export function eventToKey(e) {
+  const mods = [];
+  if (e.ctrlKey) mods.push('ctrl');
+  if (e.metaKey) mods.push('meta');
+  if (e.altKey) mods.push('alt');
+  if (e.shiftKey) mods.push('shift');
+  let key = e.key.toLowerCase();
+  const named = { ' ': 'space', escape: 'escape', enter: 'enter', arrowup: 'up', arrowdown: 'down', arrowleft: 'left', arrowright: 'right' };
+  key = named[key] || key;
+  return [...mods.filter((m) => key !== m), key].join('+');
+}
+
+export class KeybindingService {
+  /**
+   * @param {import('./contributions.js').ContributionRegistry} contributions
+   * @param {import('./commands.js').CommandService} commands
+   * @param {import('./context.js').ContextKeyService} context
+   * @param {import('./settings.js').SettingsService} [settings] source of user rebinds
+   */
+  constructor(contributions, commands, context, settings = null) {
+    this.contributions = contributions;
+    this.commands = commands;
+    this.context = context;
+    this.settings = settings;
+    this.chordPrefix = null;
+    this.chordTimer = null;
+    this._onKeyDown = this.#onKeyDown.bind(this);
+  }
+
+  install(target = window) {
+    target.addEventListener('keydown', this._onKeyDown);
+    return () => target.removeEventListener('keydown', this._onKeyDown);
+  }
+
+  /**
+   * User rebinds, keyed by BINDING rather than by command.
+   *
+   * Keyed by command, one shortcut could not be changed without changing the others:
+   * `workbench.view.home` ships bound twice (⌘⇧F and ⌘⇧E), so rebinding either
+   * collapsed both onto the new chord — two identical rows in Settings and one shortcut
+   * silently gone. A binding's identity is (command, the key it was DECLARED with),
+   * which is stable across restarts and unique per row.
+   */
+  overrides() {
+    return this.settings?.get(OVERRIDES_KEY) || {};
+  }
+
+  /** The override key for one declared binding. */
+  static bindingId(binding) {
+    return `${binding.command}\u0000${normalizeKey(binding.defaultKey || binding.key)}`;
+  }
+
+  /**
+   * Rebind one BINDING (null clears it back to what its keymap declared).
+   * @param {{command: string, defaultKey?: string, key: string}|string} binding
+   *   a resolved binding, or a bare command id for the legacy single-binding case.
+   */
+  rebind(binding, key) {
+    if (!this.settings) return;
+    const id = typeof binding === 'string'
+      ? this.#idForCommand(binding)
+      : KeybindingService.bindingId(binding);
+    if (!id) return;
+    const next = { ...this.overrides() };
+    if (key) next[id] = key; else delete next[id];
+    this.settings.set(OVERRIDES_KEY, next);
+  }
+
+  /** Resolve a bare command id to its (single) binding id, for older callers. */
+  #idForCommand(command) {
+    const b = this.contributions.keybindings().find((x) => x?.command === command && x.key);
+    return b ? KeybindingService.bindingId({ ...b, defaultKey: b.key }) : null;
+  }
+
+  /** Current effective bindings (every keymap's, plus user overrides). */
+  resolved() {
+    const overrides = this.overrides();
+    return this.contributions.keybindings()
+      .filter((b) => b?.key && b.command)
+      .map((b) => {
+        // `defaultKey` is what the keymap declared — the row's stable identity, and what
+        // "reset" restores to.
+        const defaultKey = normalizeKey(b.key);
+        const id = KeybindingService.bindingId({ command: b.command, defaultKey });
+        return { ...b, defaultKey, bindingId: id, key: normalizeKey(overrides[id] || b.key) };
+      });
+  }
+
+  #matchFor(keyChord) {
+    const snapshot = this.context.snapshot();
+    // Later registrations win (plugins can override), so scan in reverse.
+    const list = this.resolved();
+    for (let i = list.length - 1; i >= 0; i--) {
+      const b = list[i];
+      if (b.key !== keyChord) continue;
+      if (b.when && !this.context.evaluate(b.when)) continue;
+      return b;
+    }
+    return null;
+  }
+
+  #onKeyDown(e) {
+    if (e.defaultPrevented) return;
+    const chord = eventToKey(e);
+    const hasMod = e.ctrlKey || e.metaKey || e.altKey;
+    const typing = isTyping(e.target);
+
+    // While typing, only modifier chords and Escape are eligible (don't eat text).
+    if (typing && !hasMod && e.key !== 'Escape') {
+      this.#resetChord();
+      return;
+    }
+
+    const full = this.chordPrefix ? `${this.chordPrefix} ${chord}` : chord;
+    const binding = this.#matchFor(full);
+
+    if (binding) {
+      e.preventDefault();
+      this.#resetChord();
+      this.commands.execute(binding.command, ...(binding.args || []));
+      return;
+    }
+
+    // Could this be the first key of a chord?
+    if (!this.chordPrefix && this.resolved().some((b) => b.key.startsWith(chord + ' '))) {
+      e.preventDefault();
+      this.chordPrefix = chord;
+      this.chordTimer = setTimeout(() => this.#resetChord(), 1500);
+      return;
+    }
+    this.#resetChord();
+  }
+
+  #resetChord() {
+    this.chordPrefix = null;
+    if (this.chordTimer) clearTimeout(this.chordTimer);
+    this.chordTimer = null;
+  }
+
+  /** Human-readable label for a command's binding, for menus/tooltips. */
+  labelFor(command) {
+    const b = this.resolved().find((x) => x.command === command);
+    return b ? prettyKey(b.key) : null;
+  }
+}
+
+function isTyping(el) {
+  if (!el) return false;
+  const tag = el.tagName;
+  return tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || el.isContentEditable;
+}
+function isMac() {
+  return typeof navigator !== 'undefined' && /mac/i.test(navigator.platform || navigator.userAgent || '');
+}
+export function prettyKey(key) {
+  const mac = isMac();
+  const map = mac
+    ? { ctrl: '⌃', meta: '⌘', alt: '⌥', shift: '⇧', enter: '↵', escape: 'esc', up: '↑', down: '↓', left: '←', right: '→', space: '␣' }
+    : { ctrl: 'Ctrl', meta: 'Win', alt: 'Alt', shift: 'Shift', enter: 'Enter', escape: 'Esc', up: '↑', down: '↓', left: '←', right: '→', space: 'Space' };
+  return key
+    .split(' ')
+    .map((chord) =>
+      chord
+        .split('+')
+        .map((p) => map[p] || (p.length === 1 ? p.toUpperCase() : p[0].toUpperCase() + p.slice(1)))
+        .join(mac ? '' : '+'),
+    )
+    .join(' ');
+}