impact-nova 2.0.9 → 2.1.0-alpha.10

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

@@ -0,0 +1,500 @@
+import { jsxs as m, jsx as e, Fragment as ee } from "react/jsx-runtime";
+import * as o from "react";
+import * as E from "@radix-ui/react-dialog";
+import { Search as B } from "impact-nova-icons";
+import { cn as c } from "../../../lib/utils.js";
+import { createComponent as b } from "../../../lib/primitives/create-component.js";
+import { wrapRadixPart as H } from "../../../lib/primitives/create-compound.js";
+import { useCommandPalette as te } from "./use-command-palette.js";
+import { Kbd as P } from "../../primitives/kbd/kbd.js";
+import { keybindingToSymbols as ne } from "../../primitives/kbd/keybinding-display.js";
+import { buildCommandPaletteLayout as ae } from "./command-palette-layout.js";
+import { COMMAND_SOURCE_LABELS as re, fuzzyFilter as oe } from "./utils.js";
+const se = /* @__PURE__ */ new Set(["browser", "system", "ag-grid"]);
+function ie(r) {
+  return !!r && se.has(r);
+}
+const I = o.createContext({
+  query: "",
+  setQuery: () => {
+  },
+  selectedIndex: 0,
+  setSelectedIndex: () => {
+  },
+  orderedCommands: [],
+  onExecute: () => {
+  }
+}), de = H(
+  "command-palette",
+  "overlay",
+  "CommandPaletteOverlay",
+  E.Overlay,
+  "fixed inset-0 z-50 bg-scrim data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 motion-reduce:animate-none motion-reduce:transition-none"
+), le = H(
+  "command-palette",
+  "title",
+  "CommandPaletteTitle",
+  E.Title,
+  "sr-only"
+);
+function ce({
+  className: r,
+  children: n,
+  commands: a,
+  placeholder: i = "Type a command or search...",
+  emptyTitle: l = "No results found",
+  emptyDescription: x = "Try a different search term",
+  recentGroupLabel: u = "Recently Used",
+  defaultGroupLabel: d = "Commands",
+  navigateLabel: S = "Navigate",
+  runLabel: D = "Run",
+  closeLabel: O = "Close",
+  configureShortcutsLabel: T = "Configure Shortcuts",
+  onCommandExecute: $,
+  onOpenChange: A
+}) {
+  const {
+    open: R,
+    setOpen: F,
+    getPaletteCommands: L,
+    getEffectiveKeybinding: V,
+    registry: v
+  } = te(), [y, j] = o.useState(""), [N, g] = o.useState(0), q = o.useRef(null), K = o.useRef(null), Q = o.useMemo(() => (a ?? L()).filter((s) => {
+    const p = s.source ?? "user";
+    return p === "user" || p === "ag-grid";
+  }), [a, R]), U = o.useMemo(() => {
+    const t = oe(
+      Q,
+      y,
+      (s) => `${s.category ? s.category + ": " : ""}${s.label}${s.description ? " " + s.description : ""}`
+    );
+    if (!y.trim()) {
+      const s = v.getRecentCommandIds(), p = new Set(s), f = [], k = [];
+      for (const h of t)
+        p.has(h.item.id) ? f.push(h) : k.push(h);
+      return f.sort(
+        (h, G) => s.indexOf(h.item.id) - s.indexOf(G.item.id)
+      ), [...f, ...k];
+    }
+    return t;
+  }, [Q, y, v]), _ = o.useMemo(
+    () => U.map((t) => t.item),
+    [U]
+  ), X = o.useMemo(
+    () => ae({
+      filteredCommands: _,
+      emptyQuery: !y.trim(),
+      recentCommandIds: v.getRecentCommandIds(),
+      recentGroupLabel: u,
+      defaultGroupLabel: d
+    }),
+    [_, y, v, u, d]
+  ), { groups: J, orderedCommands: C } = X, z = o.useRef({
+    ordered: C,
+    index: N
+  });
+  z.current = { ordered: C, index: N }, o.useEffect(() => {
+    R && (j(""), g(0), requestAnimationFrame(() => {
+      q.current?.focus();
+    }));
+  }, [R]);
+  const M = o.useCallback(
+    (t) => {
+      F(t), A?.(t);
+    },
+    [A, F]
+  ), w = o.useCallback(
+    (t) => {
+      t.handler(), v.addRecentCommand(t.id), $?.(t), M(!1);
+    },
+    [v, $, M]
+  ), W = o.useCallback(
+    (t) => {
+      const { ordered: s } = z.current, p = Math.max(s.length - 1, 0);
+      switch (t.key) {
+        case "ArrowDown": {
+          t.preventDefault(), g((f) => Math.min(f + 1, p));
+          break;
+        }
+        case "ArrowUp": {
+          t.preventDefault(), g((f) => Math.max(f - 1, 0));
+          break;
+        }
+        case "Enter": {
+          t.preventDefault();
+          const { ordered: f, index: k } = z.current, h = f[k];
+          h && w(h);
+          break;
+        }
+        case "Home": {
+          t.preventDefault(), g(0);
+          break;
+        }
+        case "End": {
+          t.preventDefault(), g(p);
+          break;
+        }
+      }
+    },
+    [w]
+  );
+  o.useEffect(() => {
+    g(0);
+  }, [y]), o.useEffect(() => {
+    const t = C.length;
+    g((s) => t === 0 ? 0 : Math.min(s, t - 1));
+  }, [C.length]), o.useLayoutEffect(() => {
+    const t = K.current;
+    if (!t) return;
+    const s = t.querySelector(
+      '[data-selected="true"]'
+    );
+    s && s.scrollIntoView({
+      block: "nearest",
+      inline: "nearest",
+      behavior: "auto"
+    });
+  }, [N]);
+  const Y = o.useMemo(
+    () => ({
+      query: y,
+      setQuery: j,
+      selectedIndex: N,
+      setSelectedIndex: g,
+      orderedCommands: C,
+      onExecute: w,
+      placeholder: i,
+      emptyTitle: l,
+      emptyDescription: x,
+      recentGroupLabel: u,
+      defaultGroupLabel: d,
+      navigateLabel: S,
+      runLabel: D,
+      closeLabel: O,
+      configureShortcutsLabel: T
+    }),
+    [
+      y,
+      N,
+      C,
+      w,
+      i,
+      l,
+      x,
+      u,
+      d,
+      S,
+      D,
+      O,
+      T
+    ]
+  ), Z = o.Children.count(n) > 0;
+  return /* @__PURE__ */ e(E.Root, { open: R, onOpenChange: M, children: /* @__PURE__ */ m(E.Portal, { children: [
+    /* @__PURE__ */ e(de, {}),
+    /* @__PURE__ */ m(
+      E.Content,
+      {
+        "aria-describedby": void 0,
+        "data-command-palette": !0,
+        "data-component": "command-palette",
+        onKeyDown: W,
+        className: c(
+          "fixed left-[50%] top-[20%] z-50 w-full max-w-[640px] -translate-x-1/2",
+          "rounded-xl border border-stroke-hairline bg-canvas-elevated 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",
+          "motion-reduce:animate-none motion-reduce:transition-none",
+          // 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",
+          r
+        ),
+        style: { transformOrigin: "top center" },
+        children: [
+          /* @__PURE__ */ e(le, { children: "Command Palette" }),
+          /* @__PURE__ */ e(I.Provider, { value: Y, children: Z ? n : /* @__PURE__ */ m(ee, { children: [
+            /* @__PURE__ */ e(me, { ref: q, placeholder: i }),
+            /* @__PURE__ */ e(ue, { ref: K, children: C.length === 0 ? /* @__PURE__ */ e(ge, {}) : J.map((t, s) => /* @__PURE__ */ m(
+              o.Fragment,
+              {
+                children: [
+                  s > 0 && /* @__PURE__ */ e(ye, {}),
+                  /* @__PURE__ */ e(pe, { heading: t.heading, children: t.items.map((p, f) => {
+                    const k = t.rowStart + f, h = V(p.id);
+                    return /* @__PURE__ */ e(
+                      xe,
+                      {
+                        command: p,
+                        isSelected: k === N,
+                        onSelect: () => w(p),
+                        onMouseEnter: () => g(k),
+                        keybinding: h
+                      },
+                      p.id
+                    );
+                  }) })
+                ]
+              },
+              `${t.heading}-${t.rowStart}`
+            )) }),
+            /* @__PURE__ */ e(be, {})
+          ] }) })
+        ]
+      }
+    )
+  ] }) });
+}
+ce.displayName = "CommandPalette";
+const me = b("CommandPaletteInput", ({ className: r, placeholder: n, onValueChange: a, ...i }, l) => {
+  const { query: x, setQuery: u } = o.useContext(I);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      className: c(
+        "flex items-center gap-3 border-b border-stroke-hairline px-4",
+        r
+      ),
+      "data-command-palette-input": !0,
+      children: [
+        /* @__PURE__ */ e(B, { className: "h-4 w-4 shrink-0 text-content-icon" }),
+        /* @__PURE__ */ e(
+          "input",
+          {
+            ref: l,
+            value: x,
+            onChange: (d) => {
+              u(d.target.value), a?.(d.target.value);
+            },
+            placeholder: n,
+            autoComplete: "off",
+            autoCorrect: "off",
+            spellCheck: !1,
+            className: c(
+              "flex h-12 w-full bg-transparent py-3 text-sm font-medium outline-none",
+              "placeholder:text-content-placeholder"
+            ),
+            ...i
+          }
+        ),
+        /* @__PURE__ */ e(
+          P,
+          {
+            keybinding: { key: "Escape" },
+            size: "sm",
+            variant: "muted",
+            className: "shrink-0"
+          }
+        )
+      ]
+    }
+  );
+}), ue = b("CommandPaletteList", ({ className: r, children: n, ...a }, i) => /* @__PURE__ */ e(
+  "div",
+  {
+    ref: i,
+    role: "listbox",
+    "data-command-palette-list": !0,
+    className: c(
+      "max-h-[360px] overflow-y-auto overscroll-contain py-1",
+      r
+    ),
+    ...a,
+    children: n
+  }
+)), pe = b("CommandPaletteGroup", ({ className: r, heading: n, children: a, ...i }, l) => /* @__PURE__ */ m(
+  "div",
+  {
+    ref: l,
+    role: "group",
+    "aria-label": n,
+    "data-command-palette-group": !0,
+    className: c("py-1", r),
+    ...i,
+    children: [
+      n && /* @__PURE__ */ e("div", { className: "px-4 py-1.5 text-[10px] font-semibold uppercase tracking-wider text-secondary-foreground", children: n }),
+      a
+    ]
+  }
+));
+function fe({
+  source: r,
+  isSelected: n
+}) {
+  if (!r || r === "user") return null;
+  const a = re[r];
+  return a ? /* @__PURE__ */ e(
+    "span",
+    {
+      className: c(
+        "shrink-0 rounded px-1.5 py-px text-[9px] font-medium leading-tight tracking-wide",
+        n ? "text-brand-foreground/50" : "text-secondary-foreground border border-stroke-hairline"
+      ),
+      children: a
+    }
+  ) : null;
+}
+const xe = o.memo(
+  b(
+    "CommandPaletteItem",
+    ({ className: r, command: n, isSelected: a, onSelect: i, keybinding: l, ...x }, u) => {
+      const d = ie(n.source);
+      return /* @__PURE__ */ m(
+        "div",
+        {
+          ref: u,
+          role: "option",
+          "aria-selected": a,
+          "data-selected": a,
+          "data-command-palette-item": !0,
+          "data-command-id": n.id,
+          onClick: i,
+          className: c(
+            "flex items-center gap-3 cursor-pointer px-4 py-2 text-sm",
+            "transition-[color,background-color] duration-150 ease-out [scroll-margin-block:6px]",
+            a ? "bg-brand text-brand-foreground" : d ? "text-secondary-foreground hover:bg-canvas-muted" : "text-content-charcoal hover:bg-canvas-muted",
+            r
+          ),
+          ...x,
+          children: [
+            n.icon && /* @__PURE__ */ e(
+              "span",
+              {
+                className: c(
+                  "flex h-4 w-4 shrink-0 items-center justify-center",
+                  a ? "text-brand-foreground" : d ? "text-stroke-hairline" : "text-secondary-foreground"
+                ),
+                children: n.icon
+              }
+            ),
+            /* @__PURE__ */ m("div", { className: "flex flex-1 flex-col min-w-0", children: [
+              /* @__PURE__ */ e(
+                "span",
+                {
+                  className: c(
+                    "truncate",
+                    d && !a ? "font-normal" : "font-medium"
+                  ),
+                  children: n.label
+                }
+              ),
+              n.description && /* @__PURE__ */ e(
+                "span",
+                {
+                  className: c(
+                    "truncate text-xs",
+                    a ? "text-brand-foreground/70" : d ? "text-stroke-hairline" : "text-secondary-foreground"
+                  ),
+                  children: n.description
+                }
+              )
+            ] }),
+            /* @__PURE__ */ e(fe, { source: n.source, isSelected: a }),
+            l && /* @__PURE__ */ e(
+              he,
+              {
+                keybinding: l,
+                isSelected: a,
+                external: d
+              }
+            )
+          ]
+        }
+      );
+    }
+  )
+), he = b("CommandPaletteShortcut", ({ keybinding: r, isSelected: n, external: a, className: i, ...l }, x) => {
+  const u = ne(r);
+  return /* @__PURE__ */ e(
+    "span",
+    {
+      ref: x,
+      className: c("ms-auto flex items-center gap-0.5 shrink-0", i),
+      "data-command-palette-shortcut": !0,
+      ...l,
+      children: u.map((d, S) => /* @__PURE__ */ e(
+        "kbd",
+        {
+          className: c(
+            "inline-flex min-w-[20px] items-center justify-center rounded px-1 h-[20px] text-[10px] font-mono leading-none",
+            "transition-[color,background-color,border-color] duration-150 ease-out",
+            n ? "bg-canvas-elevated/20 text-brand-foreground border border-brand-foreground/30" : a ? "bg-canvas-muted text-stroke-hairline border border-stroke-hairline" : "bg-canvas-muted text-secondary-foreground border border-stroke-hairline"
+          ),
+          children: d
+        },
+        `${d}-${S}`
+      ))
+    }
+  );
+}), ge = b("CommandPaletteEmpty", ({ className: r, ...n }, a) => {
+  const { emptyTitle: i, emptyDescription: l } = o.useContext(I);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      ref: a,
+      "data-command-palette-empty": !0,
+      className: c(
+        "flex flex-col items-center justify-center py-12 text-center text-sm text-secondary-foreground",
+        r
+      ),
+      ...n,
+      children: [
+        /* @__PURE__ */ e(B, { className: "h-8 w-8 mb-3 text-stroke-hairline" }),
+        /* @__PURE__ */ e("p", { className: "font-medium", children: i }),
+        /* @__PURE__ */ e("p", { className: "text-xs mt-1", children: l })
+      ]
+    }
+  );
+}), ye = b("CommandPaletteSeparator", ({ className: r, ...n }, a) => /* @__PURE__ */ e(
+  "div",
+  {
+    ref: a,
+    "data-command-palette-separator": !0,
+    className: c("h-px bg-stroke-hairline mx-2", r),
+    ...n
+  }
+)), be = b("CommandPaletteFooter", ({ className: r, ...n }, a) => {
+  const { navigateLabel: i, runLabel: l, closeLabel: x, configureShortcutsLabel: u } = o.useContext(I);
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      ref: a,
+      "data-command-palette-footer": !0,
+      className: c(
+        "flex items-center gap-4 border-t border-stroke-hairline px-4 py-2 text-[11px] text-secondary-foreground",
+        r
+      ),
+      ...n,
+      children: [
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(P, { keys: ["↑"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e(P, { keys: ["↓"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: i })
+        ] }),
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(P, { keys: ["↵"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: l })
+        ] }),
+        /* @__PURE__ */ m("span", { className: "inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(P, { keys: ["Escape"], size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: x })
+        ] }),
+        u && /* @__PURE__ */ m("span", { className: "ms-auto inline-flex items-center gap-1", children: [
+          /* @__PURE__ */ e(P, { keybinding: { key: "k", alt: !0 }, size: "sm", variant: "muted" }),
+          /* @__PURE__ */ e("span", { children: u })
+        ] })
+      ]
+    }
+  );
+});
+export {
+  ce as CommandPalette,
+  ge as CommandPaletteEmpty,
+  be as CommandPaletteFooter,
+  pe as CommandPaletteGroup,
+  me as CommandPaletteInput,
+  xe as CommandPaletteItem,
+  ue as CommandPaletteList,
+  ye as CommandPaletteSeparator,
+  he as CommandPaletteShortcut
+};

package/dist/components/flows/command-palette/command-palette.types.d.ts

@@ -0,0 +1,58 @@
+import { CommandDefinition, KeyBinding } from './utils';
+import type * as React from "react";
+/** Localized strings for the command palette chrome. */
+export interface CommandPaletteLabels {
+    /** Placeholder text for the search input */
+    placeholder?: string;
+    /** Title shown when no results are found */
+    emptyTitle?: string;
+    /** Description shown when no results are found */
+    emptyDescription?: string;
+    /** Group heading for recently used commands */
+    recentGroupLabel?: string;
+    /** Group heading for searched commands when no category is present */
+    defaultGroupLabel?: string;
+    /** Label for the navigation hint in the footer */
+    navigateLabel?: string;
+    /** Label for the execution hint in the footer */
+    runLabel?: string;
+    /** Label for the close hint in the footer */
+    closeLabel?: string;
+    /** Label for the configure shortcuts hint in the footer */
+    configureShortcutsLabel?: string;
+}
+/**
+ * Command palette dialog — search, grouped commands, keyboard navigation.
+ * Requires `CommandPaletteProvider` at app root.
+ */
+export interface CommandPaletteProps extends CommandPaletteLabels {
+    className?: string;
+    children?: React.ReactNode;
+    /** Custom list of commands (overrides automatic registry commands) */
+    commands?: CommandDefinition[];
+    /** Called when a command is executed */
+    onCommandExecute?: (command: CommandDefinition) => void;
+    /** Called when the palette opens/closes */
+    onOpenChange?: (open: boolean) => void;
+}
+/** Search input inside the palette — use `onValueChange` for controlled query. */
+export interface CommandPaletteInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "onChange"> {
+    onValueChange?: (value: string) => void;
+}
+/** Group heading + command items. */
+export interface CommandPaletteGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    heading?: string;
+}
+/** Single command row — pass `command` from registry or custom list. */
+export interface CommandPaletteItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    command: CommandDefinition;
+    isSelected?: boolean;
+    onSelect?: () => void;
+    keybinding?: KeyBinding;
+}
+/** Renders a shortcut key chord (pairs with `Kbd`). */
+export interface CommandPaletteShortcutProps extends React.HTMLAttributes<HTMLSpanElement> {
+    keybinding: KeyBinding;
+    isSelected?: boolean;
+    external?: boolean;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Command Palette & Keyboard Shortcuts — Public API
+ */
+export type { ShortcutScope, KeyBinding, CommandDefinition, FuzzyResult, SerializedOverride, BrowserShortcutInfo, ShortcutStorageAdapter, } from './utils';
+export { isMac, getKeySymbol, keybindingToSymbols, keybindingToString, matchesKeybinding, parseKeybinding, keybindingsEqual, keybindingFromEvent, isReservedShortcut, getBrowserShortcutInfo, BROWSER_SHORTCUTS, fuzzyScore, fuzzyFilter, COMMAND_SOURCE_LABELS, scopePriority, serialiseOverrides, deserialiseOverrides, } from './utils';
+export { ShortcutRegistry, LocalStorageAdapter } from './shortcut-registry';
+export type { RegistryChangeEvent, RegistryListener, ConflictInfo } from './shortcut-registry';
+export { CommandPaletteProvider, } from './command-palette-context';
+export { useCommandPalette } from './use-command-palette';
+export type { CommandPaletteContextValue, CommandPaletteProviderProps } from './command-palette-context.types';
+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 '../../primitives/kbd';
+export type { KbdProps } from '../../primitives/kbd';
+export { ShortcutOverlayProvider, useShortcutOverlay } from './shortcut-overlay-context';
+export type { ShortcutOverlayContextValue, ShortcutOverlayProviderProps } from './shortcut-overlay-context';
+export { ShortcutOverlay } from './shortcut-overlay';

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

@@ -0,0 +1,53 @@
+import { BROWSER_SHORTCUTS as r, COMMAND_SOURCE_LABELS as o, deserialiseOverrides as m, fuzzyFilter as a, fuzzyScore as i, getBrowserShortcutInfo as n, isReservedShortcut as d, keybindingFromEvent as s, keybindingsEqual as l, matchesKeybinding as S, parseKeybinding as p, scopePriority as u, serialiseOverrides as c } from "./utils.js";
+import { LocalStorageAdapter as f, ShortcutRegistry as P } from "./shortcut-registry.js";
+import { CommandPaletteProvider as x } from "./command-palette-context.js";
+import { useCommandPalette as g } from "./use-command-palette.js";
+import { useShortcut as v } from "./use-shortcut.js";
+import { useGlobalShortcut as E } from "./use-global-shortcut.js";
+import { useBrowserShortcuts as k } from "./use-browser-shortcuts.js";
+import { ShortcutScopeProvider as B } from "./shortcut-scope-provider.js";
+import { CommandPalette as L, CommandPaletteEmpty as T, CommandPaletteFooter as A, CommandPaletteGroup as F, CommandPaletteInput as I, CommandPaletteItem as M, CommandPaletteList as _, CommandPaletteSeparator as w, CommandPaletteShortcut as G } from "./command-palette.js";
+import { Kbd as q } from "../../primitives/kbd/kbd.js";
+import { getKeySymbol as H, isMac as N, keybindingToString as W, keybindingToSymbols as j } from "../../primitives/kbd/keybinding-display.js";
+import { ShortcutOverlayProvider as Q, useShortcutOverlay as V } from "./shortcut-overlay-context.js";
+import { ShortcutOverlay as Y } from "./shortcut-overlay.js";
+export {
+  r as BROWSER_SHORTCUTS,
+  o as COMMAND_SOURCE_LABELS,
+  L as CommandPalette,
+  T as CommandPaletteEmpty,
+  A as CommandPaletteFooter,
+  F as CommandPaletteGroup,
+  I as CommandPaletteInput,
+  M as CommandPaletteItem,
+  _ as CommandPaletteList,
+  x as CommandPaletteProvider,
+  w as CommandPaletteSeparator,
+  G as CommandPaletteShortcut,
+  q as Kbd,
+  f as LocalStorageAdapter,
+  Y as ShortcutOverlay,
+  Q as ShortcutOverlayProvider,
+  P as ShortcutRegistry,
+  B as ShortcutScopeProvider,
+  m as deserialiseOverrides,
+  a as fuzzyFilter,
+  i as fuzzyScore,
+  n as getBrowserShortcutInfo,
+  H as getKeySymbol,
+  N as isMac,
+  d as isReservedShortcut,
+  s as keybindingFromEvent,
+  W as keybindingToString,
+  j as keybindingToSymbols,
+  l as keybindingsEqual,
+  S as matchesKeybinding,
+  p as parseKeybinding,
+  u as scopePriority,
+  c as serialiseOverrides,
+  k as useBrowserShortcuts,
+  g as useCommandPalette,
+  E as useGlobalShortcut,
+  v as useShortcut,
+  V as useShortcutOverlay
+};

package/dist/components/flows/command-palette/shortcut-instance-context.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export declare const ShortcutInstanceContext: React.Context<{
+    instance?: string;
+    label?: string;
+} | null>;

package/dist/components/flows/command-palette/shortcut-instance-context.js

@@ -0,0 +1,5 @@
+import * as t from "react";
+const e = t.createContext(null);
+export {
+  e as ShortcutInstanceContext
+};

package/dist/components/flows/command-palette/shortcut-overlay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ShortcutOverlay — Excel-like "Key Tips" overlay.
+ *
+ * When visible, scans the DOM for elements with `[data-shortcut-id]`,
+ * resolves their effective keybindings from the command palette registry,
+ * and renders floating Kbd badges positioned next to each element.
+ *
+ * Performance notes:
+ *  - No `elementFromPoint` / forced reflows — uses containment checks only.
+ *  - MutationObserver (childList on body) detects panel open/close cheaply.
+ *  - All rescans are debounced via a single `requestAnimationFrame`.
+ *
+ * Dismiss: click backdrop, press Escape, or re-trigger the shortcut.
+ */
+import * as React from 'react';
+export declare function ShortcutOverlay(): React.ReactPortal | null;
+export declare namespace ShortcutOverlay {
+    var displayName: string;
+}