impact-nova 1.2.4 → 1.5.0

package/dist/components/ui/command-palette/command-palette.js

@@ -0,0 +1,402 @@
+import { jsx as e, jsxs as d, Fragment as J } from "react/jsx-runtime";
+import * as r from "react";
+import * as k from "@radix-ui/react-dialog";
+import { Search as D } from "lucide-react";
+import { cn as i } from "../../../lib/utils.js";
+import { useCommandPalette as W } from "./command-palette-context.js";
+import { Kbd as v } from "./kbd.js";
+import { fuzzyFilter as X, keybindingToSymbols as Y } from "./utils.js";
+const O = r.createContext({
+  query: "",
+  setQuery: () => {
+  },
+  selectedIndex: 0,
+  setSelectedIndex: () => {
+  },
+  flatItems: [],
+  onExecute: () => {
+  }
+});
+function Z({
+  className: s,
+  children: a,
+  commands: o,
+  placeholder: u = "Type a command or search...",
+  onCommandExecute: f,
+  onOpenChange: y
+}) {
+  const { open: h, setOpen: P, getPaletteCommands: T, getEffectiveKeybinding: B, registry: C } = W(), [b, I] = r.useState(""), [N, g] = r.useState(0), E = r.useRef(null), R = r.useRef(null), S = r.useMemo(() => o ?? T(), [o, h]), z = r.useMemo(() => {
+    const t = X(
+      S,
+      b,
+      (n) => `${n.category ? n.category + ": " : ""}${n.label}${n.description ? " " + n.description : ""}`
+    );
+    if (!b.trim()) {
+      const n = C.getRecentCommandIds(), x = new Set(n), l = [], m = [];
+      for (const p of t)
+        x.has(p.item.id) ? l.push(p) : m.push(p);
+      return l.sort((p, _) => n.indexOf(p.item.id) - n.indexOf(_.item.id)), [...l, ...m];
+    }
+    return t;
+  }, [S, b, C]), c = r.useMemo(() => z.map((t) => t.item), [z]), Q = r.useMemo(() => {
+    const t = /* @__PURE__ */ new Map(), n = new Set(C.getRecentCommandIds());
+    if (b.trim())
+      for (const x of c) {
+        const l = x.category || "Commands";
+        t.has(l) || t.set(l, []), t.get(l).push(x);
+      }
+    else {
+      const x = c.filter((m) => n.has(m.id));
+      x.length > 0 && t.set("Recently Used", x);
+      const l = c.filter((m) => !n.has(m.id));
+      for (const m of l) {
+        const p = m.category || "Commands";
+        t.has(p) || t.set(p, []), t.get(p).push(m);
+      }
+    }
+    return t;
+  }, [c, b, C]);
+  r.useEffect(() => {
+    h && (I(""), g(0), requestAnimationFrame(() => {
+      E.current?.focus();
+    }));
+  }, [h]);
+  const M = (t) => {
+    P(t), y?.(t);
+  }, w = r.useCallback((t) => {
+    t.handler(), C.addRecentCommand(t.id), f?.(t), M(!1);
+  }, [C, f]), U = r.useCallback((t) => {
+    switch (t.key) {
+      case "ArrowDown": {
+        t.preventDefault(), g((n) => Math.min(n + 1, c.length - 1));
+        break;
+      }
+      case "ArrowUp": {
+        t.preventDefault(), g((n) => Math.max(n - 1, 0));
+        break;
+      }
+      case "Enter": {
+        t.preventDefault();
+        const n = c[N];
+        n && w(n);
+        break;
+      }
+      case "Home": {
+        t.preventDefault(), g(0);
+        break;
+      }
+      case "End": {
+        t.preventDefault(), g(Math.max(c.length - 1, 0));
+        break;
+      }
+    }
+  }, [c, N, w]);
+  r.useEffect(() => {
+    g(0);
+  }, [b]), r.useEffect(() => {
+    const t = R.current;
+    if (!t) return;
+    const n = t.querySelector('[data-selected="true"]');
+    n && n.scrollIntoView({ block: "nearest" });
+  }, [N]);
+  const H = r.useMemo(
+    () => ({
+      query: b,
+      setQuery: I,
+      selectedIndex: N,
+      setSelectedIndex: g,
+      flatItems: c,
+      onExecute: w
+    }),
+    [b, N, c, w]
+  ), V = r.Children.count(a) > 0;
+  return /* @__PURE__ */ e(k.Root, { open: h, onOpenChange: M, children: /* @__PURE__ */ d(k.Portal, { children: [
+    /* @__PURE__ */ e(
+      k.Overlay,
+      {
+        className: "fixed inset-0 z-50 bg-black/40 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0"
+      }
+    ),
+    /* @__PURE__ */ d(
+      k.Content,
+      {
+        "aria-describedby": void 0,
+        "data-command-palette": !0,
+        "data-component": "command-palette",
+        onKeyDown: U,
+        className: i(
+          "fixed left-[50%] top-[20%] z-50 w-full max-w-[640px] -translate-x-1/2",
+          "rounded-xl border border-[#d1d5db] bg-white shadow-2xl overflow-hidden",
+          "data-[state=open]:animate-in data-[state=closed]:animate-out",
+          "data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
+          "data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95",
+          // Pin translate-x at -50% during animation so it stays centered (no horizontal slide)
+          "data-[state=open]:slide-in-from-left-1/2 data-[state=closed]:slide-out-to-left-1/2",
+          "duration-150",
+          s
+        ),
+        style: { transformOrigin: "top center" },
+        children: [
+          /* @__PURE__ */ e(k.Title, { className: "sr-only", children: "Command Palette" }),
+          /* @__PURE__ */ e(O.Provider, { value: H, children: V ? a : /* @__PURE__ */ d(J, { children: [
+            /* @__PURE__ */ e(
+              A,
+              {
+                ref: E,
+                placeholder: u
+              }
+            ),
+            /* @__PURE__ */ e(F, { ref: R, children: c.length === 0 ? /* @__PURE__ */ e(G, {}) : Array.from(Q.entries()).map(([t, n], x) => /* @__PURE__ */ d(r.Fragment, { children: [
+              x > 0 && /* @__PURE__ */ e(K, {}),
+              /* @__PURE__ */ e(j, { heading: t, children: n.map((l) => {
+                const m = c.indexOf(l), p = B(l.id);
+                return /* @__PURE__ */ e(
+                  q,
+                  {
+                    command: l,
+                    isSelected: m === N,
+                    onSelect: () => w(l),
+                    onMouseEnter: () => g(m),
+                    keybinding: p
+                  },
+                  l.id
+                );
+              }) })
+            ] }, t)) }),
+            /* @__PURE__ */ e(L, {})
+          ] }) })
+        ]
+      }
+    )
+  ] }) });
+}
+Z.displayName = "CommandPalette";
+const A = r.forwardRef(
+  ({ className: s, placeholder: a, onValueChange: o, ...u }, f) => {
+    const { query: y, setQuery: h } = r.useContext(O);
+    return /* @__PURE__ */ d(
+      "div",
+      {
+        className: i(
+          "flex items-center gap-3 border-b border-[#e5e7eb] px-4",
+          s
+        ),
+        "data-command-palette-input": !0,
+        children: [
+          /* @__PURE__ */ e(D, { className: "h-4 w-4 shrink-0 text-[#9ca3af]" }),
+          /* @__PURE__ */ e(
+            "input",
+            {
+              ref: f,
+              value: y,
+              onChange: (P) => {
+                h(P.target.value), o?.(P.target.value);
+              },
+              placeholder: a,
+              autoComplete: "off",
+              autoCorrect: "off",
+              spellCheck: !1,
+              className: i(
+                "flex h-12 w-full bg-transparent py-3 text-sm font-medium outline-none",
+                "placeholder:text-[#9ca3af]"
+              ),
+              ...u
+            }
+          ),
+          /* @__PURE__ */ e(
+            v,
+            {
+              keybinding: { key: "Escape" },
+              size: "sm",
+              variant: "muted",
+              className: "shrink-0"
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+A.displayName = "CommandPaletteInput";
+const F = r.forwardRef(({ className: s, children: a, ...o }, u) => /* @__PURE__ */ e(
+  "div",
+  {
+    ref: u,
+    role: "listbox",
+    "data-command-palette-list": !0,
+    className: i(
+      "max-h-[360px] overflow-y-auto overscroll-contain py-1",
+      s
+    ),
+    ...o,
+    children: a
+  }
+));
+F.displayName = "CommandPaletteList";
+const j = r.forwardRef(
+  ({ className: s, heading: a, children: o, ...u }, f) => /* @__PURE__ */ d(
+    "div",
+    {
+      ref: f,
+      role: "group",
+      "aria-label": a,
+      "data-command-palette-group": !0,
+      className: i("py-1", s),
+      ...u,
+      children: [
+        a && /* @__PURE__ */ e("div", { className: "px-4 py-1.5 text-[10px] font-semibold uppercase tracking-wider text-[#9ca3af]", children: a }),
+        o
+      ]
+    }
+  )
+);
+j.displayName = "CommandPaletteGroup";
+const ee = {
+  browser: "Browser",
+  "ag-grid": "AG Grid",
+  system: "System"
+};
+function te({ source: s, isSelected: a }) {
+  if (!s || s === "user") return null;
+  const o = ee[s];
+  return o ? /* @__PURE__ */ e(
+    "span",
+    {
+      className: i(
+        "shrink-0 rounded px-1.5 py-px text-[9px] font-medium leading-tight tracking-wide",
+        a ? "text-white/50" : "text-[#9ca3af] border border-[#e5e7eb]"
+      ),
+      children: o
+    }
+  ) : null;
+}
+const q = r.forwardRef(
+  ({ className: s, command: a, isSelected: o, onSelect: u, keybinding: f, ...y }, h) => /* @__PURE__ */ d(
+    "div",
+    {
+      ref: h,
+      role: "option",
+      "aria-selected": o,
+      "data-selected": o,
+      "data-command-palette-item": !0,
+      "data-command-id": a.id,
+      onClick: u,
+      className: i(
+        "flex items-center gap-3 cursor-pointer px-4 py-2 text-sm",
+        "transition-colors duration-75",
+        o ? "bg-[#4259ee] text-white" : "text-[#374151] hover:bg-[#f3f4f6]",
+        s
+      ),
+      ...y,
+      children: [
+        a.icon && /* @__PURE__ */ e("span", { className: i(
+          "flex h-4 w-4 shrink-0 items-center justify-center",
+          o ? "text-white" : "text-[#6b7280]"
+        ), children: a.icon }),
+        /* @__PURE__ */ d("div", { className: "flex flex-1 flex-col min-w-0", children: [
+          /* @__PURE__ */ e("span", { className: "truncate font-medium", children: a.label }),
+          a.description && /* @__PURE__ */ e("span", { className: i(
+            "truncate text-xs",
+            o ? "text-white/70" : "text-[#9ca3af]"
+          ), children: a.description })
+        ] }),
+        /* @__PURE__ */ e(te, { source: a.source, isSelected: o }),
+        f && /* @__PURE__ */ e($, { keybinding: f, isSelected: o })
+      ]
+    }
+  )
+);
+q.displayName = "CommandPaletteItem";
+function $({ keybinding: s, isSelected: a, className: o, ...u }) {
+  const f = Y(s);
+  return /* @__PURE__ */ e(
+    "span",
+    {
+      className: i("ml-auto flex items-center gap-0.5 shrink-0", o),
+      "data-command-palette-shortcut": !0,
+      ...u,
+      children: f.map((y, h) => /* @__PURE__ */ e(
+        "kbd",
+        {
+          className: i(
+            "inline-flex min-w-[20px] items-center justify-center rounded px-1 h-[20px] text-[10px] font-mono leading-none",
+            a ? "bg-white/20 text-white border border-white/30" : "bg-[#f4f5f7] text-[#6b7280] border border-[#d1d5db]"
+          ),
+          children: y
+        },
+        `${y}-${h}`
+      ))
+    }
+  );
+}
+$.displayName = "CommandPaletteShortcut";
+function G({ className: s, ...a }) {
+  return /* @__PURE__ */ d(
+    "div",
+    {
+      "data-command-palette-empty": !0,
+      className: i(
+        "flex flex-col items-center justify-center py-12 text-center text-sm text-[#9ca3af]",
+        s
+      ),
+      ...a,
+      children: [
+        /* @__PURE__ */ e(D, { className: "h-8 w-8 mb-3 text-[#d1d5db]" }),
+        /* @__PURE__ */ e("p", { className: "font-medium", children: "No results found" }),
+        /* @__PURE__ */ e("p", { className: "text-xs mt-1", children: "Try a different search term" })
+      ]
+    }
+  );
+}
+G.displayName = "CommandPaletteEmpty";
+function K({ className: s, ...a }) {
+  return /* @__PURE__ */ e(
+    "div",
+    {
+      "data-command-palette-separator": !0,
+      className: i("h-px bg-[#e5e7eb] mx-2", s),
+      ...a
+    }
+  );
+}
+K.displayName = "CommandPaletteSeparator";
+function L({ className: s, ...a }) {
+  return /* @__PURE__ */ d(
+    "div",
+    {
+      "data-command-palette-footer": !0,
+      className: i(
+        "flex items-center gap-4 border-t border-[#e5e7eb] px-4 py-2 text-[11px] text-[#9ca3af]",
+        s
+      ),
+      ...a,
+      children: [
+        /* @__PURE__ */ d("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["↑"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e(v, { keys: ["↓"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: "Navigate" })
+        ] }),
+        /* @__PURE__ */ d("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["↵"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: "Run" })
+        ] }),
+        /* @__PURE__ */ d("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(v, { keys: ["Escape"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: "Close" })
+        ] })
+      ]
+    }
+  );
+}
+L.displayName = "CommandPaletteFooter";
+export {
+  Z as CommandPalette,
+  G as CommandPaletteEmpty,
+  L as CommandPaletteFooter,
+  j as CommandPaletteGroup,
+  A as CommandPaletteInput,
+  q as CommandPaletteItem,
+  F as CommandPaletteList,
+  K as CommandPaletteSeparator,
+  $ as CommandPaletteShortcut
+};

package/dist/components/ui/command-palette/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Command Palette & Keyboard Shortcuts — Public API
+ */
+export type { ShortcutScope, KeyBinding, CommandDefinition, FuzzyResult, SerializedOverride, BrowserShortcutInfo, } from './utils';
+export { isMac, getKeySymbol, keybindingToSymbols, keybindingToString, matchesKeybinding, parseKeybinding, keybindingsEqual, keybindingFromEvent, isReservedShortcut, getBrowserShortcutInfo, BROWSER_SHORTCUTS, fuzzyScore, fuzzyFilter, scopePriority, } from './utils';
+export { ShortcutRegistry } from './shortcut-registry';
+export type { RegistryChangeEvent, RegistryListener, ConflictInfo } from './shortcut-registry';
+export { CommandPaletteProvider, useCommandPalette, } from './command-palette-context';
+export type { CommandPaletteContextValue, CommandPaletteProviderProps } from './command-palette-context';
+export { useShortcut } from './use-shortcut';
+export type { UseShortcutOptions } from './use-shortcut';
+export { useGlobalShortcut } from './use-global-shortcut';
+export type { UseGlobalShortcutOptions } from './use-global-shortcut';
+export { useBrowserShortcuts } from './use-browser-shortcuts';
+export type { UseBrowserShortcutsOptions } from './use-browser-shortcuts';
+export { ShortcutScopeProvider } from './shortcut-scope-provider';
+export type { ShortcutScopeProviderProps } from './shortcut-scope-provider';
+export { CommandPalette, CommandPaletteInput, CommandPaletteList, CommandPaletteGroup, CommandPaletteItem, CommandPaletteShortcut, CommandPaletteEmpty, CommandPaletteSeparator, CommandPaletteFooter, } from './command-palette';
+export type { CommandPaletteProps, CommandPaletteInputProps, CommandPaletteGroupProps, CommandPaletteItemProps, CommandPaletteShortcutProps, } from './command-palette';
+export { Kbd } from './kbd';
+export type { KbdProps } from './kbd';
+export { ShortcutSettings } from './shortcut-settings';
+export type { ShortcutSettingsProps } from './shortcut-settings';

package/dist/components/ui/command-palette/index.js

@@ -0,0 +1,44 @@
+import { BROWSER_SHORTCUTS as o, fuzzyFilter as r, fuzzyScore as m, getBrowserShortcutInfo as a, getKeySymbol as n, isMac as i, isReservedShortcut as d, keybindingFromEvent as S, keybindingToString as s, keybindingToSymbols as u, keybindingsEqual as l, matchesKeybinding as p, parseKeybinding as c, scopePriority as y } from "./utils.js";
+import { ShortcutRegistry as f } from "./shortcut-registry.js";
+import { CommandPaletteProvider as g, useCommandPalette as b } from "./command-palette-context.js";
+import { useShortcut as x } from "./use-shortcut.js";
+import { useGlobalShortcut as k } from "./use-global-shortcut.js";
+import { useBrowserShortcuts as z } from "./use-browser-shortcuts.js";
+import { ShortcutScopeProvider as K } from "./shortcut-scope-provider.js";
+import { CommandPalette as B, CommandPaletteEmpty as F, CommandPaletteFooter as I, CommandPaletteGroup as w, CommandPaletteInput as G, CommandPaletteItem as O, CommandPaletteList as q, CommandPaletteSeparator as H, CommandPaletteShortcut as L } from "./command-palette.js";
+import { Kbd as U } from "./kbd.js";
+import { ShortcutSettings as _ } from "./shortcut-settings.js";
+export {
+  o as BROWSER_SHORTCUTS,
+  B as CommandPalette,
+  F as CommandPaletteEmpty,
+  I as CommandPaletteFooter,
+  w as CommandPaletteGroup,
+  G as CommandPaletteInput,
+  O as CommandPaletteItem,
+  q as CommandPaletteList,
+  g as CommandPaletteProvider,
+  H as CommandPaletteSeparator,
+  L as CommandPaletteShortcut,
+  U as Kbd,
+  f as ShortcutRegistry,
+  K as ShortcutScopeProvider,
+  _ as ShortcutSettings,
+  r as fuzzyFilter,
+  m as fuzzyScore,
+  a as getBrowserShortcutInfo,
+  n as getKeySymbol,
+  i as isMac,
+  d as isReservedShortcut,
+  S as keybindingFromEvent,
+  s as keybindingToString,
+  u as keybindingToSymbols,
+  l as keybindingsEqual,
+  p as matchesKeybinding,
+  c as parseKeybinding,
+  y as scopePriority,
+  z as useBrowserShortcuts,
+  b as useCommandPalette,
+  k as useGlobalShortcut,
+  x as useShortcut
+};

package/dist/components/ui/command-palette/kbd.d.ts

@@ -0,0 +1,28 @@
+import { VariantProps } from 'class-variance-authority';
+import { KeyBinding } from './utils';
+/**
+ * Kbd — Keyboard key badge component.
+ *
+ * Renders individual key caps (e.g. ⌘, ⇧, K) as styled <kbd> elements.
+ * Automatically maps modifier names to platform-appropriate symbols.
+ *
+ * Usage:
+ *   <Kbd keys={['meta', 'shift', 'P']} />
+ *   // Renders: [⌘] [⇧] [P] on Mac, [Ctrl] [Shift] [P] on Windows
+ *
+ *   <Kbd keybinding={{ key: 'k', meta: true }} />
+ *   // Renders: [⌘] [K] on Mac, [Ctrl] [K] on Windows
+ */
+import * as React from 'react';
+declare const kbdVariants: (props?: {
+    size?: "sm" | "lg" | "default";
+    variant?: "default" | "dark" | "muted";
+} & import('class-variance-authority/types').ClassProp) => string;
+export interface KbdProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children'>, VariantProps<typeof kbdVariants> {
+    /** Array of key names/symbols to render. e.g. ['meta', 'shift', 'P'] */
+    keys?: string[];
+    /** Or provide a KeyBinding object directly */
+    keybinding?: KeyBinding;
+}
+declare const Kbd: React.ForwardRefExoticComponent<KbdProps & React.RefAttributes<HTMLElement>>;
+export { Kbd, kbdVariants };

package/dist/components/ui/command-palette/kbd.js

@@ -0,0 +1,52 @@
+import { jsx as a } from "react/jsx-runtime";
+import * as d from "react";
+import { cva as l } from "class-variance-authority";
+import { cn as o } from "../../../lib/utils.js";
+import { keybindingToSymbols as b, getKeySymbol as c } from "./utils.js";
+const u = l(
+  "inline-flex items-center justify-center rounded border font-mono leading-none select-none",
+  {
+    variants: {
+      size: {
+        sm: "min-w-[18px] h-[18px] px-1 text-[10px]",
+        default: "min-w-[22px] h-[22px] px-1.5 text-[11px]",
+        lg: "min-w-[26px] h-[26px] px-2 text-xs"
+      },
+      variant: {
+        default: "bg-[#f4f5f7] border-[#d1d5db] text-[#374151] shadow-[0_1px_0_0_#d1d5db]",
+        muted: "bg-[#e5e7eb] border-[#d1d5db] text-[#6b7280]",
+        dark: "bg-[#374151] border-[#4b5563] text-[#e5e7eb] shadow-[0_1px_0_0_#1f2937]"
+      }
+    },
+    defaultVariants: {
+      size: "default",
+      variant: "default"
+    }
+  }
+), h = d.forwardRef(
+  ({ className: i, keys: t, keybinding: r, size: m, variant: p, ...s }, x) => {
+    const n = d.useMemo(() => r ? b(r) : t ? t.map((e) => c(e)) : [], [t, r]);
+    return n.length === 0 ? null : /* @__PURE__ */ a(
+      "span",
+      {
+        ref: x,
+        className: o("inline-flex items-center gap-0.5", i),
+        "data-component": "kbd",
+        ...s,
+        children: n.map((e, f) => /* @__PURE__ */ a(
+          "kbd",
+          {
+            className: o(u({ size: m, variant: p })),
+            children: e
+          },
+          `${e}-${f}`
+        ))
+      }
+    );
+  }
+);
+h.displayName = "Kbd";
+export {
+  h as Kbd,
+  u as kbdVariants
+};

package/dist/components/ui/command-palette/shortcut-registry.d.ts

@@ -0,0 +1,68 @@
+import { CommandDefinition, KeyBinding, ShortcutScope } from './utils';
+export type RegistryChangeEvent = {
+    type: 'register' | 'unregister' | 'update-keybinding' | 'reset-keybinding' | 'scope-change';
+    commandId?: string;
+};
+export type RegistryListener = (event: RegistryChangeEvent) => void;
+export interface ConflictInfo {
+    conflictingCommandId: string;
+    conflictingLabel: string;
+    scope: ShortcutScope;
+}
+export declare class ShortcutRegistry {
+    private commands;
+    private overrides;
+    private recentCommandIds;
+    private listeners;
+    private activeScopes;
+    private activeInstance;
+    constructor();
+    setActiveInstance(instance: string | null): void;
+    getActiveInstance(): string | null;
+    /**
+     * Get all unique instance identifiers currently registered.
+     */
+    getRegisteredInstances(): string[];
+    register(command: CommandDefinition): void;
+    unregister(commandId: string): void;
+    getEffectiveKeybinding(commandId: string): KeyBinding | undefined;
+    updateKeybinding(commandId: string, keybinding: KeyBinding): {
+        success: boolean;
+        conflict?: ConflictInfo;
+        reserved?: boolean;
+    };
+    resetKeybinding(commandId: string): void;
+    findConflict(commandId: string, keybinding: KeyBinding, scope: ShortcutScope): ConflictInfo | null;
+    pushScope(scope: ShortcutScope): void;
+    popScope(scope: ShortcutScope): void;
+    getActiveScopes(): ShortcutScope[];
+    getHighestActiveScope(): ShortcutScope;
+    getCommand(id: string): CommandDefinition | undefined;
+    getAllCommands(): CommandDefinition[];
+    /**
+     * Get commands visible in the command palette.
+     * Instance-scoped commands are filtered (only active instance shows unless
+     * there's only one instance, in which case it always shows).
+     * When multiple instances exist, labels are auto-prefixed with the instance name.
+     */
+    getPaletteCommands(): CommandDefinition[];
+    /**
+     * Get commands for the settings panel (all registered, including hidden).
+     */
+    getSettingsCommands(): CommandDefinition[];
+    /**
+     * Handle a keyboard event. Finds the highest-priority matching command
+     * and executes its handler.
+     *
+     * @returns true if a command was executed, false otherwise
+     */
+    handleKeyEvent(event: KeyboardEvent): boolean;
+    getRecentCommandIds(): string[];
+    addRecentCommand(commandId: string): void;
+    subscribe(listener: RegistryListener): () => void;
+    private emit;
+    private loadOverrides;
+    private saveOverrides;
+    private loadRecentCommands;
+    private saveRecentCommands;
+}