@opengeni/react 4.2.1-canary.39642758903001 → 4.3.1

package/dist/chunk-JRJUSKDY.js

@@ -0,0 +1,832 @@
+"use client";
+import {
+  readChatDirectory,
+  recordChatVisit
+} from "./chunk-4IWBQUQU.js";
+import {
+  applicableChords,
+  chordAccelerator,
+  chordAriaKeys,
+  chordLabel,
+  currentPlatform,
+  isTextEntry,
+  matchesChord
+} from "./chunk-MF464AKA.js";
+import {
+  applySessionArchiveProjection
+} from "./chunk-OSI2QWSL.js";
+import {
+  notifySessionListChanged
+} from "./chunk-O5S57N6H.js";
+import {
+  OPEN_COMMAND_MENU_EVENT,
+  RENAME_CURRENT_CHAT_EVENT,
+  useRail
+} from "./chunk-SF3M27AN.js";
+import {
+  requestSessionSearch
+} from "./chunk-TXIIBNCA.js";
+import {
+  requestConversationFind
+} from "./chunk-7ZEGSUR7.js";
+import {
+  useSessionUiFeature
+} from "./chunk-XFNLU7EW.js";
+import {
+  useUiEventTarget
+} from "./chunk-WGPLDFEC.js";
+import {
+  desktopBridge,
+  desktopCapability
+} from "./chunk-FABYS4WM.js";
+import {
+  toast
+} from "./chunk-YG6NARQY.js";
+import {
+  useNavigate,
+  usePage,
+  useRouterState
+} from "./chunk-MYNUBDU7.js";
+import {
+  useAppContext
+} from "./chunk-W6KAUGXO.js";
+
+// src/app/lib/actions/actions-provider.tsx
+import {
+  createContext,
+  lazy,
+  Suspense,
+  useCallback as useCallback2,
+  useContext,
+  useEffect,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState
+} from "react";
+
+// src/app/lib/actions/chat-switcher.ts
+var SWITCHER_LIMIT = 10;
+var SWITCHER_SHOW_DELAY_MS = 140;
+function openChatSwitcher(directory, currentChatId, backwards) {
+  const switchable = directory.recent.filter((id) => {
+    const record = directory.rows.get(id);
+    if (!record || record.archived) return false;
+    return !record.row || record.row.parentSessionId === null;
+  });
+  const ids = currentChatId ? [currentChatId, ...switchable.filter((id) => id !== currentChatId)] : switchable;
+  const limited = ids.slice(0, SWITCHER_LIMIT);
+  const first = currentChatId ? 1 : 0;
+  if (limited.length <= first) return null;
+  return { ids: limited, index: backwards ? limited.length - 1 : first, visible: false };
+}
+function stepChatSwitcher(state, step) {
+  const count = state.ids.length;
+  return { ...state, index: (state.index + step + count) % count, visible: true };
+}
+function isSwitcherKey(event) {
+  return event.code === "Tab" && event.ctrlKey && !event.metaKey && !event.altKey;
+}
+
+// src/app/lib/actions/chat-operations.ts
+import { useCallback, useMemo, useRef } from "react";
+function chatPath(chat) {
+  return `/workspaces/${encodeURIComponent(chat.workspaceId)}/sessions/${encodeURIComponent(chat.id)}`;
+}
+async function writeClipboard(text) {
+  if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+    await navigator.clipboard.writeText(text);
+    return;
+  }
+  const area = document.createElement("textarea");
+  area.value = text;
+  area.setAttribute("readonly", "");
+  area.style.position = "fixed";
+  area.style.opacity = "0";
+  document.body.append(area);
+  area.select();
+  const copied = document.execCommand("copy");
+  area.remove();
+  if (!copied) throw new Error("The browser blocked copying.");
+}
+function useChatOperations() {
+  const context = useAppContext();
+  const page = usePage();
+  const archiving = useRef(/* @__PURE__ */ new Set());
+  const linkTo = useCallback(
+    (chat) => `${page.origin()}${chatPath(chat)}`,
+    [page]
+  );
+  const copyLink = useCallback(
+    async (chat) => {
+      try {
+        await writeClipboard(linkTo(chat));
+        toast.success("Link copied");
+      } catch (error) {
+        toast.error("Couldn't copy the link.", {
+          description: error instanceof Error ? error.message : String(error)
+        });
+      }
+    },
+    [linkTo]
+  );
+  const setPinned = useCallback(
+    async (chat, pinned) => {
+      const updated = await context.updateSessionPin(
+        chat.workspaceId,
+        chat.id,
+        pinned,
+        chat.pinVersion ?? 0
+      );
+      if (updated) toast.success(pinned ? "Chat pinned" : "Chat unpinned");
+      else toast.error(pinned ? "Couldn't pin the chat." : "Couldn't unpin the chat.");
+    },
+    [context]
+  );
+  const setArchived = useCallback(
+    async (chat, archived) => {
+      if (archiving.current.has(chat.id)) return;
+      const accepted = context.captureWorkspaceInvocation(chat.workspaceId);
+      if (!accepted) return;
+      archiving.current.add(chat.id);
+      try {
+        const updated = await context.client.updateSessionArchive(chat.workspaceId, chat.id, {
+          archived,
+          expectedVersion: chat.archiveVersion ?? 0
+        });
+        if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
+        context.setSession(
+          (current) => current?.id === updated.id && current.workspaceId === updated.workspaceId ? applySessionArchiveProjection(current, updated) : current
+        );
+        notifySessionListChanged({
+          workspaceId: chat.workspaceId,
+          sessionId: chat.id,
+          archived: updated.archived
+        });
+        toast.success(updated.archived ? "Chat archived." : "Chat restored.");
+      } catch (error) {
+        if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
+        toast.error(archived ? "Couldn't archive the chat." : "Couldn't restore the chat.", {
+          description: error instanceof Error ? error.message : String(error)
+        });
+      } finally {
+        archiving.current.delete(chat.id);
+      }
+    },
+    [context]
+  );
+  const setUnread = useCallback(
+    async (chat, unread) => {
+      try {
+        const updated = await context.client.updateSessionAttention(chat.workspaceId, chat.id, {
+          unread,
+          expectedVersion: chat.attentionVersion ?? 0
+        });
+        context.setSession(
+          (current) => current?.id === updated.id ? {
+            ...current,
+            ...updated.unread !== void 0 ? { unread: updated.unread } : {},
+            ...updated.attentionVersion !== void 0 ? { attentionVersion: updated.attentionVersion } : {}
+          } : current
+        );
+        notifySessionListChanged({ workspaceId: chat.workspaceId, sessionId: chat.id });
+        toast.success(unread ? "Marked as unread" : "Marked as read");
+      } catch (error) {
+        toast.error("Couldn't update the chat.", {
+          description: error instanceof Error ? error.message : String(error)
+        });
+      }
+    },
+    [context]
+  );
+  return useMemo(
+    () => ({ linkTo, copyLink, setPinned, setArchived, setUnread }),
+    [linkTo, copyLink, setPinned, setArchived, setUnread]
+  );
+}
+
+// src/app/lib/actions/registry.ts
+import {
+  ArchiveIcon,
+  ArchiveRestoreIcon,
+  ArrowDownIcon,
+  ArrowUpIcon,
+  CommandIcon,
+  HistoryIcon,
+  InboxIcon,
+  KeyboardIcon,
+  LinkIcon,
+  MailIcon,
+  MailOpenIcon,
+  PanelLeftIcon,
+  PencilIcon,
+  PinIcon,
+  PinOffIcon,
+  PlusIcon,
+  SearchIcon,
+  TextSearchIcon
+} from "lucide-react";
+function actionTitle(action, env, chat) {
+  return typeof action.title === "string" ? action.title : action.title(env, chat);
+}
+function actionIcon(action, chat) {
+  return action.iconFor?.(chat) ?? action.icon;
+}
+var ALWAYS = () => true;
+function stepChat(env, direction) {
+  const order = env.sidebarOrder();
+  if (order.length === 0) return;
+  const index = env.currentChat ? order.indexOf(env.currentChat.id) : -1;
+  const next = index < 0 ? direction === 1 ? 0 : order.length - 1 : index + direction;
+  if (next < 0 || next >= order.length) return;
+  env.openChat(order[next]);
+}
+var PINNED_CHORDS = Array.from({ length: 9 }, (_, index) => ({
+  code: `Digit${index + 1}`,
+  mod: true,
+  only: "desktop"
+}));
+var APP_ACTIONS = [
+  {
+    id: "commandMenu.open",
+    title: "Command menu",
+    group: "help",
+    icon: CommandIcon,
+    chords: [{ code: "KeyK", mod: true }],
+    inCommandMenu: false,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.openCommandMenu()
+  },
+  {
+    id: "chat.new",
+    title: "New chat",
+    group: "chat",
+    icon: PlusIcon,
+    keywords: ["start", "create", "session"],
+    // The desktop menu shows its first key, the familiar ⌘N; browsers keep ⌘N for windows.
+    chords: [
+      { code: "KeyN", mod: true, only: "desktop" },
+      { code: "KeyO", mod: true, shift: true }
+    ],
+    suggested: true,
+    desktopMenu: "file",
+    available: ALWAYS,
+    run: (env) => env.newChat()
+  },
+  {
+    id: "chat.copyLink",
+    title: "Copy link",
+    group: "chat",
+    icon: LinkIcon,
+    keywords: ["share", "url", "address"],
+    chords: [{ code: "Comma", mod: true, shift: true }],
+    forChat: true,
+    suggested: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null,
+    run: (env, chat) => chat ? env.ops.copyLink(chat) : void 0
+  },
+  {
+    id: "chat.pin",
+    title: (_env, chat) => chat?.pinned ? "Unpin" : "Pin",
+    group: "chat",
+    icon: PinIcon,
+    iconFor: (chat) => chat?.pinned ? PinOffIcon : PinIcon,
+    keywords: ["unpin", "favorite", "star"],
+    chords: [{ code: "KeyP", mod: true, alt: true }],
+    forChat: true,
+    suggested: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && !chat.archived,
+    run: (env, chat) => chat ? env.ops.setPinned(chat, !chat.pinned) : void 0
+  },
+  {
+    id: "chat.rename",
+    title: "Rename",
+    group: "chat",
+    icon: PencilIcon,
+    keywords: ["title", "name"],
+    forChat: true,
+    desktopMenu: "chat",
+    // Renaming happens in the chat's own title, so only for the chat on screen.
+    available: (env, chat) => chat !== null && env.currentChat?.id === chat.id,
+    run: (env) => env.renameCurrentChat()
+  },
+  {
+    id: "chat.unread",
+    title: (_env, chat) => chat?.unread ? "Mark as read" : "Mark as unread",
+    group: "chat",
+    icon: MailIcon,
+    iconFor: (chat) => chat?.unread ? MailOpenIcon : MailIcon,
+    keywords: ["read", "unread"],
+    forChat: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && !chat.archived,
+    run: (env, chat) => chat ? env.ops.setUnread(chat, !chat.unread) : void 0
+  },
+  {
+    id: "chat.archive",
+    title: (_env, chat) => chat?.archived ? "Restore" : "Archive",
+    group: "chat",
+    icon: ArchiveIcon,
+    iconFor: (chat) => chat?.archived ? ArchiveRestoreIcon : ArchiveIcon,
+    keywords: ["restore", "hide", "done"],
+    forChat: true,
+    desktopMenu: "chat",
+    available: (_env, chat) => chat !== null && chat.parentSessionId === null,
+    run: (env, chat) => chat ? env.ops.setArchived(chat, !chat.archived) : void 0
+  },
+  {
+    id: "chat.find",
+    title: "Find in chat",
+    group: "chat",
+    icon: TextSearchIcon,
+    keywords: ["search", "find"],
+    chords: [{ code: "KeyF", mod: true }],
+    desktopMenu: "chat",
+    // The conversation owns ⌘F itself; the registry lists it so it is discoverable.
+    available: (env) => env.currentChat !== null,
+    run: (env) => env.findInChat()
+  },
+  {
+    id: "go.inbox",
+    title: "Inbox",
+    group: "navigate",
+    icon: InboxIcon,
+    keywords: ["notifications", "replies", "needs you"],
+    chords: [
+      { code: "KeyI", mod: true, shift: true, platform: "mac" },
+      // Browsers on Windows and Linux open developer tools with Ctrl+Shift+I.
+      { code: "KeyI", mod: true, shift: true, platform: "other", only: "desktop" }
+    ],
+    suggested: true,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.openInbox()
+  },
+  {
+    id: "go.previousChat",
+    title: "Previous chat",
+    group: "navigate",
+    icon: ArrowUpIcon,
+    chords: [{ code: "ArrowUp", alt: true }],
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env) => stepChat(env, -1)
+  },
+  {
+    id: "go.nextChat",
+    title: "Next chat",
+    group: "navigate",
+    icon: ArrowDownIcon,
+    chords: [{ code: "ArrowDown", alt: true }],
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env) => stepChat(env, 1)
+  },
+  {
+    // Hold Control to see recent chats and keep pressing Tab; release to open.
+    // The actions provider runs the switcher itself because it needs Control's
+    // release, so the desktop menu bar never owns this key.
+    id: "go.recentChat",
+    title: "Switch to recent chat",
+    group: "navigate",
+    icon: HistoryIcon,
+    chords: [
+      { code: "Tab", control: true, platform: "mac", only: "desktop" },
+      // Browsers keep Control+Tab for their own tabs.
+      { code: "Tab", mod: true, platform: "other", only: "desktop" }
+    ],
+    inCommandMenu: false,
+    available: ALWAYS,
+    run: (env) => env.switchToRecentChat()
+  },
+  {
+    id: "go.pinnedChat",
+    title: "Pinned chat 1 to 9",
+    group: "navigate",
+    icon: PinIcon,
+    chords: PINNED_CHORDS,
+    chordSummary: (platform) => platform === "mac" ? "\u23181 \u2013 \u23189" : "Ctrl+1 \u2013 Ctrl+9",
+    inCommandMenu: false,
+    available: (env) => env.chatList,
+    run: (env, _chat, chord) => {
+      const index = chord ? Number(chord.code.slice(5)) - 1 : 0;
+      const id = env.pinnedOrder()[index];
+      if (id) env.openChat(id);
+    }
+  },
+  {
+    id: "go.searchMessages",
+    title: "Search messages",
+    group: "navigate",
+    icon: SearchIcon,
+    keywords: ["find", "history", "full text"],
+    opensDialog: true,
+    desktopMenu: "go",
+    available: ALWAYS,
+    run: (env) => env.searchMessages()
+  },
+  {
+    id: "view.sidebar",
+    title: "Toggle sidebar",
+    group: "view",
+    icon: PanelLeftIcon,
+    keywords: ["hide", "show", "collapse", "rail"],
+    chords: [
+      { code: "KeyS", mod: true, control: true, platform: "mac" },
+      { code: "KeyS", mod: true, shift: true, platform: "other" }
+    ],
+    desktopMenu: "view",
+    available: (env) => env.chatList,
+    run: (env) => env.toggleSidebar()
+  },
+  {
+    id: "help.shortcuts",
+    title: "Keyboard shortcuts",
+    group: "help",
+    icon: KeyboardIcon,
+    keywords: ["keys", "hotkeys", "cheat sheet", "help"],
+    chords: [{ code: "Slash", mod: true }],
+    desktopMenu: "help",
+    available: ALWAYS,
+    run: (env) => env.openShortcutSheet()
+  }
+];
+function findAction(id) {
+  return APP_ACTIONS.find((action) => action.id === id);
+}
+
+// src/app/lib/actions/actions-provider.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var CommandMenu = lazy(() => import("./app/components/command-menu/command-menu.js"));
+var ShortcutSheet = lazy(() => import("./app/components/command-menu/shortcut-sheet.js"));
+var loadChatSwitcher = () => import("./app/components/command-menu/chat-switcher.js");
+var ChatSwitcher = lazy(loadChatSwitcher);
+var ActionsContext = createContext(null);
+function useAppActions() {
+  return useContext(ActionsContext);
+}
+function useActionShortcut(actionId) {
+  const enabled = useSessionUiFeature("keyboardShortcuts");
+  const action = findAction(actionId);
+  if (!enabled || !action) return null;
+  const platform = currentPlatform();
+  const chords = applicableChords(action.chords, surface, platform);
+  const chord = chords[0];
+  if (!chord) return null;
+  return {
+    label: chordLabel(chord, platform),
+    ariaKeys: chords.map((candidate) => chordAriaKeys(candidate, platform)).join(" "),
+    chord
+  };
+}
+var surface = desktopBridge ? "desktop" : "web";
+function insideOtherOverlay(target) {
+  if (!(target instanceof Element)) return false;
+  const overlay = target.closest(
+    '[role="dialog"],[role="alertdialog"],[role="menu"],[role="listbox"]'
+  );
+  return Boolean(overlay && !overlay.closest("[data-og-command-menu],[data-og-shortcut-sheet]"));
+}
+function menuOwnedChord(action, platform) {
+  return applicableChords(action.chords, "desktop", platform).find(
+    (chord) => !chord.alt || chord.mod
+  );
+}
+function menuChord(action, platform) {
+  const chord = menuOwnedChord(action, platform);
+  return chord ? chordAccelerator(chord) : null;
+}
+function insideCommandMenu(target) {
+  return target instanceof Element && Boolean(target.closest("[data-og-command-menu]"));
+}
+function textEntryIsEmpty(target) {
+  if (target instanceof HTMLTextAreaElement || target instanceof HTMLInputElement) {
+    return target.value.length === 0;
+  }
+  if (target instanceof HTMLElement && target.isContentEditable) {
+    return (target.textContent ?? "").length === 0;
+  }
+  return true;
+}
+function ActionsProvider(props) {
+  const app = useAppContext();
+  const rail = useRail();
+  const navigate = useNavigate();
+  const ops = useChatOperations();
+  const uiEvents = useUiEventTarget("document");
+  const windowEvents = useUiEventTarget("window");
+  const chatList = useSessionUiFeature("chatList");
+  const keyboardShortcuts = useSessionUiFeature("keyboardShortcuts");
+  const platform = useMemo2(() => currentPlatform(), []);
+  const workspaceId = rail.workspaceId;
+  const subjectId = app.accessContext.subjectId;
+  const pathname = useRouterState({ select: (state) => state.location.pathname });
+  const routeChatId = /\/sessions\/([^/]+)/.exec(pathname)?.[1] ?? null;
+  const currentChat = app.session && app.session.id === routeChatId && app.session.workspaceId === workspaceId ? app.session : null;
+  const [menu, setMenu] = useState({ open: false, mounted: false, chat: null });
+  const [sheet, setSheet] = useState({ open: false, mounted: false });
+  const railRef = useRef2(rail);
+  railRef.current = rail;
+  const returnFocus = useRef2(null);
+  const menuOpen = useRef2(false);
+  const sheetOpen = useRef2(false);
+  menuOpen.current = menu.open;
+  sheetOpen.current = sheet.open;
+  const rememberFocus = useCallback2(() => {
+    if (menuOpen.current || sheetOpen.current || typeof document === "undefined") return;
+    const drawerTrigger = railRef.current.drawerOpen ? railRef.current.drawerTriggerRef.current : null;
+    if (drawerTrigger) {
+      returnFocus.current = drawerTrigger;
+      return;
+    }
+    const active = document.activeElement;
+    returnFocus.current = active instanceof HTMLElement && active !== document.body ? active : null;
+  }, []);
+  const openCommandMenu = useCallback2(() => {
+    rememberFocus();
+    setSheet((current) => current.open ? { ...current, open: false } : current);
+    railRef.current.handOffDrawer();
+    setMenu((current) => ({ open: !current.open, mounted: true, chat: null }));
+  }, [rememberFocus]);
+  const openShortcutSheet = useCallback2(() => {
+    rememberFocus();
+    setMenu((current) => current.open ? { ...current, open: false } : current);
+    setSheet((current) => ({ open: !current.open, mounted: true }));
+  }, [rememberFocus]);
+  useEffect(() => {
+    if (currentChat) recordChatVisit(subjectId, workspaceId, currentChat);
+  }, [currentChat?.id, subjectId, workspaceId]);
+  const env = useMemo2(
+    () => ({
+      workspaceId,
+      subjectId,
+      surface,
+      platform,
+      currentChat,
+      ops,
+      chatList,
+      newChat: () => rail.startNewSession(),
+      openChat: (chatId) => rail.openSession(chatId),
+      openInbox: () => {
+        rail.setDrawerOpen(false);
+        void navigate({ to: "/workspaces/$workspaceId/inbox", params: { workspaceId } });
+      },
+      toggleSidebar: () => rail.isMobile ? rail.setDrawerOpen(!rail.drawerOpen) : rail.toggleCollapsed(),
+      findInChat: () => requestConversationFind(uiEvents),
+      searchMessages: (query) => requestSessionSearch(windowEvents, workspaceId, void 0, query),
+      renameCurrentChat: () => uiEvents.dispatchEvent(new Event(RENAME_CURRENT_CHAT_EVENT)),
+      openCommandMenu,
+      openShortcutSheet,
+      switchToRecentChat: () => {
+        const target = openChatSwitcher(
+          readChatDirectory(subjectId, workspaceId),
+          routeChatId,
+          false
+        );
+        const id = target?.ids[target.index];
+        if (id) rail.openSession(id);
+      },
+      sidebarOrder: () => readChatDirectory(subjectId, workspaceId).sidebarOrder,
+      pinnedOrder: () => readChatDirectory(subjectId, workspaceId).pinnedOrder
+    }),
+    [
+      workspaceId,
+      subjectId,
+      platform,
+      currentChat,
+      routeChatId,
+      ops,
+      chatList,
+      rail,
+      navigate,
+      uiEvents,
+      windowEvents,
+      openCommandMenu,
+      openShortcutSheet
+    ]
+  );
+  const envRef = useRef2(env);
+  envRef.current = env;
+  const chordsFor = useCallback2(
+    (action) => applicableChords(action.chords, surface, platform),
+    [platform]
+  );
+  const run = useCallback2((action, chat, chord) => {
+    const current = envRef.current;
+    if (action.id !== "commandMenu.open") {
+      setMenu((state) => state.open ? { ...state, open: false } : state);
+    }
+    if (action.id !== "help.shortcuts") {
+      setSheet((state) => state.open ? { ...state, open: false } : state);
+    }
+    const target = chat === void 0 ? current.currentChat : chat;
+    if (!action.available(current, action.forChat ? target : null)) return;
+    void Promise.resolve(action.run(current, action.forChat ? target : null, chord)).catch(() => {
+    });
+  }, []);
+  const menuBridge = desktopCapability("menuActions")?.menuActions ?? null;
+  const menuSignature = useMemo2(() => {
+    if (!menuBridge) return "";
+    return JSON.stringify(
+      APP_ACTIONS.filter((action) => action.desktopMenu).map((action) => {
+        const chat = action.forChat ? env.currentChat : null;
+        return {
+          id: action.id,
+          label: actionTitle(action, env, chat),
+          section: action.desktopMenu,
+          accelerator: menuChord(action, platform),
+          enabled: action.available(env, chat)
+        };
+      })
+    );
+  }, [menuBridge, env, platform]);
+  useEffect(() => {
+    if (!menuBridge || !menuSignature) return;
+    menuBridge.set(JSON.parse(menuSignature));
+  }, [menuBridge, menuSignature]);
+  useEffect(() => {
+    if (!menuBridge) return;
+    return menuBridge.onAction((id) => {
+      const action = findAction(id);
+      if (action) run(action);
+    });
+  }, [menuBridge, run]);
+  useEffect(() => {
+    const open = () => openCommandMenu();
+    windowEvents.addEventListener(OPEN_COMMAND_MENU_EVENT, open);
+    return () => windowEvents.removeEventListener(OPEN_COMMAND_MENU_EVENT, open);
+  }, [windowEvents, openCommandMenu]);
+  useEffect(() => {
+    if (!keyboardShortcuts) return;
+    const menuOwnsKeys = Boolean(menuBridge);
+    function onKeyDown(event) {
+      if (event.defaultPrevented) return;
+      const current = envRef.current;
+      for (const action of APP_ACTIONS) {
+        if (action.id === "chat.find") continue;
+        if (action.id === "go.recentChat") continue;
+        const chord = applicableChords(action.chords, surface, platform).find(
+          (candidate) => matchesChord(event, candidate, platform)
+        );
+        if (!chord) continue;
+        if (menuOwnsKeys && action.desktopMenu && chord === menuOwnedChord(action, platform))
+          return;
+        const toggleMenu = action.id === "commandMenu.open";
+        if (action.forChat && insideCommandMenu(event.target)) return;
+        if (!toggleMenu && insideOtherOverlay(event.target)) return;
+        if (!chord.mod && isTextEntry(event.target) && !textEntryIsEmpty(event.target)) return;
+        if (!action.available(current, action.forChat ? current.currentChat : null)) return;
+        event.preventDefault();
+        event.stopPropagation();
+        run(action, void 0, chord);
+        return;
+      }
+    }
+    document.addEventListener("keydown", onKeyDown, true);
+    return () => document.removeEventListener("keydown", onKeyDown, true);
+  }, [keyboardShortcuts, menuBridge, platform, run]);
+  const [switcher, setSwitcherState] = useState(null);
+  const switcherRef = useRef2(null);
+  const setSwitcher = useCallback2((next) => {
+    switcherRef.current = next;
+    setSwitcherState(next);
+  }, []);
+  const routeChatIdRef = useRef2(routeChatId);
+  routeChatIdRef.current = routeChatId;
+  const switcherEnabled = keyboardShortcuts && chatList && surface === "desktop";
+  const pickSwitcherChat = useCallback2(
+    (index) => {
+      const state = switcherRef.current;
+      if (!state) return;
+      const id = state.ids[index ?? state.index];
+      setSwitcher(null);
+      if (id && id !== routeChatIdRef.current) envRef.current.openChat(id);
+    },
+    [setSwitcher]
+  );
+  useEffect(() => {
+    if (!switcherEnabled) {
+      setSwitcher(null);
+      return;
+    }
+    let showTimer;
+    const cancel = () => {
+      clearTimeout(showTimer);
+      if (switcherRef.current) setSwitcher(null);
+    };
+    function onKeyDown(event) {
+      const state = switcherRef.current;
+      if (isSwitcherKey(event)) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (state) {
+          clearTimeout(showTimer);
+          setSwitcher(stepChatSwitcher(state, event.shiftKey ? -1 : 1));
+          return;
+        }
+        if (event.repeat || menuOpen.current || sheetOpen.current) return;
+        if (insideOtherOverlay(event.target)) return;
+        const opened = openChatSwitcher(
+          readChatDirectory(subjectId, workspaceId),
+          routeChatIdRef.current,
+          event.shiftKey
+        );
+        if (!opened) return;
+        void loadChatSwitcher();
+        setSwitcher(opened);
+        showTimer = setTimeout(() => {
+          const current = switcherRef.current;
+          if (current && !current.visible) setSwitcher({ ...current, visible: true });
+        }, SWITCHER_SHOW_DELAY_MS);
+        return;
+      }
+      if (!state) return;
+      if (!event.ctrlKey && event.key !== "Control") {
+        cancel();
+        return;
+      }
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        cancel();
+      } else if (event.key === "Enter") {
+        event.preventDefault();
+        event.stopPropagation();
+        clearTimeout(showTimer);
+        pickSwitcherChat();
+      } else if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+        event.preventDefault();
+        event.stopPropagation();
+        clearTimeout(showTimer);
+        setSwitcher(stepChatSwitcher(state, event.key === "ArrowDown" ? 1 : -1));
+      }
+    }
+    function onKeyUp(event) {
+      if (event.key !== "Control" || !switcherRef.current) return;
+      clearTimeout(showTimer);
+      pickSwitcherChat();
+    }
+    document.addEventListener("keydown", onKeyDown, true);
+    document.addEventListener("keyup", onKeyUp, true);
+    window.addEventListener("blur", cancel);
+    return () => {
+      clearTimeout(showTimer);
+      document.removeEventListener("keydown", onKeyDown, true);
+      document.removeEventListener("keyup", onKeyUp, true);
+      window.removeEventListener("blur", cancel);
+    };
+  }, [switcherEnabled, subjectId, workspaceId, pickSwitcherChat, setSwitcher]);
+  const value = useMemo2(
+    () => ({ env, run, chordsFor }),
+    [env, run, chordsFor]
+  );
+  return /* @__PURE__ */ jsxs(ActionsContext.Provider, { value, children: [
+    props.children,
+    menu.mounted ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      CommandMenu,
+      {
+        open: menu.open,
+        onOpenChange: (open) => setMenu((current) => ({ ...current, open })),
+        returnFocus
+      }
+    ) }) : null,
+    sheet.mounted ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      ShortcutSheet,
+      {
+        open: sheet.open,
+        onOpenChange: (open) => setSheet((current) => ({ ...current, open })),
+        returnFocus
+      }
+    ) }) : null,
+    switcher?.visible ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      ChatSwitcher,
+      {
+        state: switcher,
+        subjectId,
+        workspaceId,
+        currentChatId: routeChatId,
+        platform,
+        onHover: (index) => {
+          const current = switcherRef.current;
+          if (current) setSwitcher({ ...current, index });
+        },
+        onPick: pickSwitcherChat,
+        onDismiss: () => setSwitcher(null)
+      }
+    ) }) : null
+  ] });
+}
+
+export {
+  useChatOperations,
+  actionTitle,
+  actionIcon,
+  APP_ACTIONS,
+  findAction,
+  useAppActions,
+  useActionShortcut,
+  ActionsProvider
+};
+//# sourceMappingURL=chunk-JRJUSKDY.js.map