@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-HGKTHF2U.js

@@ -0,0 +1,1356 @@
+"use client";
+import {
+  applicableChords,
+  chordAccelerator,
+  chordAriaKeys,
+  chordLabel,
+  currentPlatform,
+  isTextEntry,
+  matchesChord
+} from "./chunk-BTF7WNUT.js";
+import {
+  applySessionArchiveProjection
+} from "./chunk-OSI2QWSL.js";
+import {
+  notifySessionListChanged
+} from "./chunk-O5S57N6H.js";
+import {
+  archiveActionLabel,
+  requestSessionArchive
+} from "./chunk-KY2R73CG.js";
+import {
+  listsAsTopLevel,
+  readChatDirectory,
+  recordChatVisit,
+  rememberChats
+} from "./chunk-ROKQU7WG.js";
+import {
+  FORK_CURRENT_CHAT_EVENT,
+  OPEN_COMMAND_MENU_EVENT,
+  RENAME_CURRENT_CHAT_EVENT,
+  useRail
+} from "./chunk-5EWSRZ2Y.js";
+import {
+  requestConversationFind
+} from "./chunk-7ZEGSUR7.js";
+import {
+  requestSessionComposerFocus
+} from "./chunk-MMY23KS7.js";
+import {
+  requestSessionSearch
+} from "./chunk-TXIIBNCA.js";
+import {
+  copyLink
+} from "./chunk-SC6RRD2D.js";
+import {
+  useSessionUiFeature
+} from "./chunk-FWXMQTVG.js";
+import {
+  t
+} from "./chunk-HSOXMJOT.js";
+import {
+  hasWorkspacePermission
+} from "./chunk-H2ALCTWC.js";
+import {
+  isPersonalWorkspace,
+  navigableWorkspaces
+} from "./chunk-LBSXJVHD.js";
+import {
+  useNavigate,
+  usePage,
+  useRouterState
+} from "./chunk-BXBDYNRP.js";
+import {
+  desktopBridge,
+  desktopCapability
+} from "./chunk-5QBCQVKZ.js";
+import {
+  toast
+} from "./chunk-O4EA4F3W.js";
+import {
+  useAppContext
+} from "./chunk-JDFDPMKX.js";
+import {
+  useMeetingOnScreen
+} from "./chunk-TGT2R5VO.js";
+import {
+  useUiEventTarget
+} from "./chunk-WGPLDFEC.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+import {
+  meetingTitle
+} from "./chunk-2FSBSCZJ.js";
+import {
+  sessionDisplayTitle
+} from "./chunk-3PZ7JZI2.js";
+import {
+  canStartRecording,
+  useMeetingRecorderControls
+} from "./chunk-ZHDFQITM.js";
+import {
+  workspacesByOrganization
+} from "./chunk-NRP4REXE.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";
+import { OpenGeniRecordingsClient } from "@opengeni/sdk/recordings";
+
+// src/app/lib/actions/site-directory.ts
+import { useSyncExternalStore } from "react";
+var directories = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Map();
+function directory(subjectId) {
+  let state = directories.get(subjectId);
+  if (!state) {
+    state = { sites: /* @__PURE__ */ new Map(), version: 0 };
+    directories.set(subjectId, state);
+  }
+  return state;
+}
+function siteRecords(workspaceId, sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  for (const source of sources) {
+    const id = source.siteId ?? source.id;
+    if (typeof id !== "string" || !id || seen.has(id)) continue;
+    seen.add(id);
+    records.push({
+      id,
+      workspaceId,
+      title: typeof source.title === "string" && source.title.trim() || "Untitled Site",
+      updatedAt: Date.parse(source.updatedAt) || 0
+    });
+  }
+  return records;
+}
+function rememberSidebarSites(subjectId, workspaceId, sources) {
+  const state = directory(subjectId);
+  const next = siteRecords(workspaceId, sources).sort((a, b) => b.updatedAt - a.updatedAt);
+  const current = state.sites.get(workspaceId);
+  if (current && current.length === next.length && current.every(
+    (site, index) => site.id === next[index].id && site.title === next[index].title && site.updatedAt === next[index].updatedAt
+  ))
+    return;
+  state.sites.set(workspaceId, next);
+  state.version += 1;
+  for (const listener of listeners.get(subjectId) ?? []) listener();
+}
+function readSidebarSites(subjectId, workspaceId) {
+  return directory(subjectId).sites.get(workspaceId) ?? [];
+}
+function useSiteDirectoryVersion(subjectId) {
+  return useSyncExternalStore(
+    (listener) => {
+      let set = listeners.get(subjectId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(subjectId, set);
+      }
+      set.add(listener);
+      return () => {
+        set.delete(listener);
+      };
+    },
+    () => directory(subjectId).version,
+    () => 0
+  );
+}
+function sitePath(workspaceId, siteId) {
+  return `/workspaces/${encodeURIComponent(workspaceId)}/sites/${encodeURIComponent(siteId)}`;
+}
+
+// src/app/lib/actions/meeting-directory.ts
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+var directories2 = /* @__PURE__ */ new Map();
+var listeners2 = /* @__PURE__ */ new Map();
+function directory2(subjectId) {
+  let state = directories2.get(subjectId);
+  if (!state) {
+    state = { meetings: /* @__PURE__ */ new Map(), version: 0 };
+    directories2.set(subjectId, state);
+  }
+  return state;
+}
+function meetingRecords(recordings) {
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  for (const recording of recordings) {
+    if (!recording?.id || seen.has(recording.id)) continue;
+    seen.add(recording.id);
+    records.push({
+      id: recording.id,
+      workspaceId: recording.workspaceId,
+      title: meetingTitle(recording),
+      startedAt: Date.parse(recording.startedAt) || 0
+    });
+  }
+  return records;
+}
+function rememberRecentMeetings(subjectId, workspaceId, records) {
+  const state = directory2(subjectId);
+  const next = [...records].sort((a, b) => b.startedAt - a.startedAt);
+  const current = state.meetings.get(workspaceId);
+  if (current && current.length === next.length && current.every(
+    (meeting, index) => meeting.id === next[index].id && meeting.title === next[index].title && meeting.startedAt === next[index].startedAt
+  ))
+    return;
+  state.meetings.set(workspaceId, next);
+  state.version += 1;
+  for (const listener of listeners2.get(subjectId) ?? []) listener();
+}
+function readRecentMeetings(subjectId, workspaceId) {
+  return directory2(subjectId).meetings.get(workspaceId) ?? [];
+}
+function useMeetingDirectoryVersion(subjectId) {
+  return useSyncExternalStore2(
+    (listener) => {
+      let set = listeners2.get(subjectId);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners2.set(subjectId, set);
+      }
+      set.add(listener);
+      return () => {
+        set.delete(listener);
+      };
+    },
+    () => directory2(subjectId).version,
+    () => 0
+  );
+}
+function meetingPath(workspaceId, recordingId) {
+  return `/workspaces/${encodeURIComponent(workspaceId)}/meetings/${encodeURIComponent(recordingId)}`;
+}
+
+// src/app/lib/actions/chat-switcher.ts
+var SWITCHER_LIMIT = 100;
+var SWITCHER_SHOW_DELAY_MS = 140;
+function switchable(record, reachable) {
+  return Boolean(record && !record.archived && reachable(record.workspaceId));
+}
+function moreChats(directory3, taken, reachable, room) {
+  if (room <= 0) return [];
+  const more = [];
+  for (const record of directory3.rows.values()) {
+    if (!taken.has(record.id) && switchable(record, reachable) && listsAsTopLevel(record)) {
+      more.push(record);
+    }
+  }
+  more.sort((a, b) => b.updatedAt - a.updatedAt || (a.id < b.id ? -1 : 1));
+  return more.slice(0, room).map((record) => record.id);
+}
+function openChatSwitcher(directory3, currentChatId, backwards, reachable = () => true) {
+  const recent = directory3.recent.filter(
+    (id) => id !== currentChatId && switchable(directory3.rows.get(id), reachable)
+  );
+  const viewed = (currentChatId ? [currentChatId, ...recent] : recent).slice(0, SWITCHER_LIMIT);
+  const ids = [
+    ...viewed,
+    ...moreChats(directory3, new Set(viewed), reachable, SWITCHER_LIMIT - viewed.length)
+  ];
+  const first = currentChatId ? 1 : 0;
+  if (ids.length <= first) return null;
+  return {
+    ids,
+    viewed: viewed.length,
+    index: backwards ? ids.length - 1 : first,
+    visible: false
+  };
+}
+function extendChatSwitcher(state, directory3, reachable = () => true) {
+  const more = moreChats(
+    directory3,
+    new Set(state.ids),
+    reachable,
+    SWITCHER_LIMIT - state.ids.length
+  );
+  return more.length === 0 ? state : { ...state, ids: [...state.ids, ...more] };
+}
+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)}`;
+}
+function useChatOperations() {
+  const context = useAppContext();
+  const page = usePage();
+  const archiving = useRef(/* @__PURE__ */ new Set());
+  const linkTo = useCallback(
+    (chat) => `${page.origin()}${chatPath(chat)}`,
+    [page]
+  );
+  const copyLink2 = useCallback(
+    (chat) => copyLink(linkTo(chat)),
+    [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 setArchivedRef = useRef(null);
+  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 requestSessionArchive(
+          context,
+          chat,
+          archived,
+          sessionDisplayTitle(chat),
+          (next) => void setArchivedRef.current?.({ ...chat, archived: !next }, next)
+        );
+        if (!updated) return;
+        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
+        });
+      } catch (error) {
+        if (!context.ownsWorkspaceInvocation(chat.workspaceId, accepted)) return;
+        toast.error(archived ? "Couldn't archive the chat." : "Couldn't undo the archive.", {
+          description: userErrorText(error)
+        });
+      } finally {
+        archiving.current.delete(chat.id);
+      }
+    },
+    [context]
+  );
+  setArchivedRef.current = setArchived;
+  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: userErrorText(error)
+        });
+      }
+    },
+    [context]
+  );
+  return useMemo(
+    () => ({
+      linkTo,
+      copyLink: copyLink2,
+      setPinned,
+      setArchived,
+      setUnread,
+      archiveLabel: (chat) => archiveActionLabel(context, chat)
+    }),
+    [linkTo, copyLink2, setPinned, setArchived, setUnread, context]
+  );
+}
+
+// src/app/lib/actions/registry.ts
+import {
+  ArchiveIcon,
+  ArrowDownIcon,
+  ArrowUpIcon,
+  AudioLinesIcon,
+  ChevronsUpDownIcon,
+  CommandIcon,
+  GitForkIcon,
+  HistoryIcon,
+  InboxIcon,
+  KeyboardIcon,
+  LinkIcon,
+  MailIcon,
+  MailOpenIcon,
+  MessageCircleQuestionIcon,
+  MicIcon,
+  PanelLeftIcon,
+  PanelRightIcon,
+  PencilIcon,
+  PinIcon,
+  PinOffIcon,
+  PlusIcon,
+  SearchIcon,
+  SquareIcon,
+  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]);
+}
+function stepWorkspace(workspaces, currentId, direction) {
+  if (workspaces.length < 2) return null;
+  const index = workspaces.findIndex((workspace) => workspace.id === currentId);
+  const next = index < 0 ? direction === 1 ? 0 : workspaces.length - 1 : (index + direction + workspaces.length) % workspaces.length;
+  return workspaces[next].id;
+}
+function switchWorkspace(env, direction) {
+  const id = stepWorkspace(env.workspaces, env.workspaceId, direction);
+  if (id && id !== env.workspaceId) env.openWorkspace(id);
+}
+var hasOtherWorkspaces = (env) => env.workspaces.length > 1;
+function meetingBusy(env) {
+  return !canStartRecording(env.meetings?.state);
+}
+var PINNED_CHORDS = Array.from({ length: 9 }, (_, index) => ({
+  code: `Digit${index + 1}`,
+  mod: true,
+  only: "desktop"
+}));
+var appActionList;
+function appActions() {
+  return appActionList ??= [
+    {
+      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()
+    },
+    {
+      // The Meetings page's Start recording button, from anywhere. While one
+      // records, it shows that recording instead of starting a second one, as a
+      // desktop call notification's Record does. ⌃⌘N sits beside New chat's ⌘N
+      // and, like Archive, is Ctrl+Alt elsewhere; see the shortcuts doc.
+      id: "meetings.start",
+      title: (env) => meetingBusy(env) ? "Go to recording" : "Start recording",
+      group: "meetings",
+      icon: MicIcon,
+      keywords: ["meeting", "new meeting", "record", "notetaker", "transcript", "audio", "call"],
+      chords: [
+        { code: "KeyN", mod: true, control: true, platform: "mac" },
+        { code: "KeyN", mod: true, alt: true, platform: "other" }
+      ],
+      desktopMenu: "file",
+      available: (env) => env.meetings !== null,
+      run: (env) => meetingBusy(env) ? env.meetings?.show() : env.meetings?.start()
+    },
+    {
+      // No key, so a stray press never ends a meeting.
+      id: "meetings.stop",
+      title: "Stop recording",
+      group: "meetings",
+      icon: SquareIcon,
+      keywords: ["meeting", "end", "finish", "record"],
+      desktopMenu: "file",
+      available: (env) => env.meetings?.state === "recording" || env.meetings?.state === "paused",
+      run: (env) => env.meetings?.stop()
+    },
+    {
+      // The meeting on screen's Ask field, from ⌘K. Typing a question first
+      // asks it straight away; see the menu's "Ask about this meeting: …" row.
+      id: "meeting.ask",
+      title: "Ask about this meeting",
+      group: "meetings",
+      icon: MessageCircleQuestionIcon,
+      keywords: ["question", "chat", "agent", "summary", "notes"],
+      forMeeting: true,
+      opensDialog: true,
+      available: (env) => Boolean(env.meetingPages?.current?.ask),
+      run: (env) => env.meetingPages?.current?.ask?.(null)
+    },
+    {
+      id: "meeting.copyLink",
+      title: "Copy meeting link",
+      group: "meetings",
+      icon: LinkIcon,
+      keywords: ["share", "url", "address"],
+      forMeeting: true,
+      available: (env) => Boolean(env.meetingPages?.current),
+      run: (env) => {
+        const current = env.meetingPages?.current;
+        if (current) return env.meetingPages?.copyLink(current.recordingId);
+      }
+    },
+    {
+      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.fork",
+      title: "Fork chat",
+      group: "chat",
+      icon: GitForkIcon,
+      keywords: ["copy", "duplicate", "branch", "clone"],
+      forChat: true,
+      opensDialog: true,
+      desktopMenu: "chat",
+      // From the latest message, as the fork button under a message does; only
+      // for the chat on screen, whose messages are loaded.
+      available: (env, chat) => chat !== null && env.currentChat?.id === chat.id && env.canForkCurrentChat,
+      run: (env) => env.forkCurrentChat()
+    },
+    {
+      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: "Archive",
+      group: "chat",
+      icon: ArchiveIcon,
+      keywords: ["archive", "done", "storage"],
+      // Apple Mail's Archive key; Ctrl+Alt elsewhere, as Pin, since browsers there
+      // keep Ctrl+Shift+A for tab search.
+      chords: [
+        { code: "KeyA", mod: true, control: true, platform: "mac" },
+        { code: "KeyA", mod: true, alt: true, platform: "other" }
+      ],
+      forChat: true,
+      desktopMenu: "chat",
+      // Archived chats stay archived; only people who can control a chat archive it.
+      available: (env, chat) => chat !== null && chat.parentSessionId === null && !chat.archived && (env.ops.archiveLabel ? env.ops.archiveLabel(chat) !== null : true),
+      run: (env, chat) => chat ? env.ops.setArchived(chat, true) : 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.meetings",
+      title: "Meetings",
+      group: "navigate",
+      icon: AudioLinesIcon,
+      keywords: ["recordings", "transcripts", "calls", "notes"],
+      suggested: true,
+      desktopMenu: "go",
+      available: (env) => env.meetingPages !== null,
+      run: (env) => env.meetingPages?.openList()
+    },
+    {
+      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: "go.switchWorkspace",
+      title: "Switch workspace\u2026",
+      group: "navigate",
+      icon: ChevronsUpDownIcon,
+      keywords: ["workspace", "organization", "team", "change", "go to"],
+      desktopMenu: "go",
+      available: hasOtherWorkspaces,
+      run: (env) => env.openWorkspacePicker()
+    },
+    {
+      // The workspace picker's order, wrapping around. ⌥⌘ and arrows sit in the
+      // same place on every keyboard layout, and browsers leave them alone.
+      id: "go.previousWorkspace",
+      title: "Previous workspace",
+      group: "navigate",
+      icon: ArrowUpIcon,
+      chords: [
+        { code: "ArrowUp", mod: true, alt: true },
+        // Some Linux desktops take Ctrl+Alt+arrows to switch their own workspaces.
+        { code: "PageUp", mod: true, shift: true, platform: "other", only: "desktop" }
+      ],
+      inCommandMenu: false,
+      desktopMenu: "go",
+      available: hasOtherWorkspaces,
+      run: (env) => switchWorkspace(env, -1)
+    },
+    {
+      id: "go.nextWorkspace",
+      title: "Next workspace",
+      group: "navigate",
+      icon: ArrowDownIcon,
+      chords: [
+        { code: "ArrowDown", mod: true, alt: true },
+        { code: "PageDown", mod: true, shift: true, platform: "other", only: "desktop" }
+      ],
+      inCommandMenu: false,
+      desktopMenu: "go",
+      available: hasOtherWorkspaces,
+      run: (env) => switchWorkspace(env, 1)
+    },
+    {
+      id: "view.sidebar",
+      title: "Toggle sidebar",
+      group: "view",
+      icon: PanelLeftIcon,
+      keywords: ["hide", "show", "collapse", "rail"],
+      // ⌘B as in most editors and chat apps. It is bold in rich text, so the menu
+      // bar shows the platform's standard sidebar key instead, which also works.
+      chords: [
+        { code: "KeyB", mod: true, formatting: true },
+        { 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: "view.workspacePanel",
+      title: "Toggle workspace panel",
+      group: "view",
+      icon: PanelRightIcon,
+      keywords: ["right", "inspector", "files", "browser", "terminal", "hide", "show"],
+      // The second sidebar's key in VS Code and Cursor.
+      chords: [{ code: "KeyB", mod: true, alt: true }],
+      desktopMenu: "view",
+      available: (env) => env.workspacePanel && env.currentChat !== null,
+      run: (env) => env.toggleWorkspacePanel()
+    },
+    {
+      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 appActions().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 isRichTextEditor(target) {
+  return target instanceof HTMLElement && target.isContentEditable;
+}
+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) && !chord.formatting
+  );
+}
+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 page = usePage();
+  const ops = useChatOperations();
+  const uiEvents = useUiEventTarget("document");
+  const windowEvents = useUiEventTarget("window");
+  const chatList = useSessionUiFeature("chatList");
+  const workspacePanel = useSessionUiFeature("dock");
+  const { inspectorOpen, setInspectorOpen } = app;
+  const keyboardShortcuts = useSessionUiFeature("keyboardShortcuts");
+  const recorder = useMeetingRecorderControls();
+  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 routeSiteId = /\/sites\/([^/]+)/.exec(pathname)?.[1] ?? null;
+  const routeMeetingId = /\/meetings\/([^/]+)/.exec(pathname)?.[1] ?? null;
+  const meetingOnScreen = useMeetingOnScreen(uiEvents);
+  const currentChat = app.session && app.session.id === routeChatId && app.session.workspaceId === workspaceId ? app.session : null;
+  const workspaces = useMemo2(
+    () => workspacesByOrganization(
+      t,
+      app.accessContext,
+      navigableWorkspaces(app.workspaces, app.managedSelfContext, workspaceId)
+    ).flatMap(
+      (group) => group.workspaces.map((workspace) => ({
+        id: workspace.id,
+        name: workspace.name,
+        organization: group.org.label,
+        personal: isPersonalWorkspace(workspace, app.managedSelfContext)
+      }))
+    ),
+    [app.accessContext, app.workspaces, app.managedSelfContext, workspaceId]
+  );
+  const canForkCurrentChat = currentChat !== null && app.clientConfig.auth.mode === "managedSession" && app.authSession !== null && Boolean(app.session?.tenancy) && hasWorkspacePermission(app.accessContext, workspaceId, "sessions:create");
+  const meetings = useMemo2(() => {
+    if (!recorder || recorder.supported === false) return null;
+    const showMeetings = () => {
+      rail.setDrawerOpen(false);
+      void navigate({ to: "/workspaces/$workspaceId/meetings", params: { workspaceId } });
+    };
+    return {
+      state: recorder.state,
+      start: () => {
+        recorder.requestStart();
+        showMeetings();
+      },
+      show: showMeetings,
+      stop: async () => {
+        const stopped = await recorder.stop();
+        if (stopped && !stopped.opened) {
+          void navigate({
+            to: "/workspaces/$workspaceId/meetings/$recordingId",
+            params: { workspaceId: stopped.workspaceId, recordingId: stopped.recordingId }
+          });
+        }
+      }
+    };
+  }, [recorder, rail, navigate, workspaceId]);
+  const recordingsClient = useMemo2(
+    () => typeof app.client?.requestJson === "function" ? new OpenGeniRecordingsClient(app.client) : null,
+    [app.client]
+  );
+  const meetingPages = useMemo2(() => {
+    if (!recorder || !recordingsClient) return null;
+    const link = (recordingId) => `${page.origin()}${meetingPath(workspaceId, recordingId)}`;
+    const onScreen = routeMeetingId && meetingOnScreen?.recordingId === routeMeetingId ? meetingOnScreen : null;
+    return {
+      openList: () => {
+        rail.setDrawerOpen(false);
+        void navigate({ to: "/workspaces/$workspaceId/meetings", params: { workspaceId } });
+      },
+      open: (recordingId) => {
+        rail.setDrawerOpen(false);
+        void navigate({
+          to: "/workspaces/$workspaceId/meetings/$recordingId",
+          params: { workspaceId, recordingId }
+        });
+      },
+      link,
+      copyLink: (recordingId) => copyLink(link(recordingId)),
+      list: async (options) => {
+        const { signal, ...rest } = options;
+        const answer = await recordingsClient.listRecordings(workspaceId, {
+          ...rest,
+          ...signal ? { signal } : {}
+        });
+        return answer.recordings;
+      },
+      current: routeMeetingId ? { recordingId: routeMeetingId, ask: onScreen?.ask ?? null } : null
+    };
+  }, [
+    recorder,
+    recordingsClient,
+    page,
+    workspaceId,
+    routeMeetingId,
+    meetingOnScreen,
+    rail,
+    navigate
+  ]);
+  const [menu, setMenu] = useState({ open: false, mounted: false, workspaces: false });
+  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(
+    (pickWorkspace = false) => {
+      rememberFocus();
+      setSheet((current) => current.open ? { ...current, open: false } : current);
+      railRef.current.handOffDrawer();
+      setMenu((current) => ({
+        open: pickWorkspace ? true : !current.open,
+        mounted: true,
+        workspaces: pickWorkspace
+      }));
+    },
+    [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, currentChat);
+  }, [currentChat?.id, subjectId]);
+  useEffect(() => {
+    if (currentChat) rememberChats(subjectId, [currentChat]);
+  }, [currentChat, subjectId]);
+  const reachable = useMemo2(() => {
+    const ids = new Set(workspaces.map((workspace) => workspace.id));
+    return (id) => ids.has(id) || id === workspaceId;
+  }, [workspaces, workspaceId]);
+  const openChatForTyping = useCallback2(
+    (chatId, inWorkspaceId) => {
+      if (!rail.isMobile) {
+        requestSessionComposerFocus(windowEvents, inWorkspaceId ?? workspaceId, chatId, "keyboard");
+      }
+      rail.openSession(chatId, inWorkspaceId);
+    },
+    [rail, windowEvents, workspaceId]
+  );
+  const env = useMemo2(
+    () => ({
+      workspaceId,
+      subjectId,
+      surface,
+      platform,
+      currentChat,
+      currentSiteId: routeSiteId,
+      ops,
+      chatList,
+      workspacePanel,
+      workspaces,
+      canForkCurrentChat,
+      meetings,
+      meetingPages,
+      newChat: () => rail.startNewSession(),
+      openChat: (chatId, inWorkspaceId) => openChatForTyping(chatId, inWorkspaceId),
+      openSite: (siteId) => {
+        rail.setDrawerOpen(false);
+        void navigate({
+          to: "/workspaces/$workspaceId/sites/$siteId",
+          params: { workspaceId, siteId }
+        });
+      },
+      siteLink: (siteId) => `${page.origin()}${sitePath(workspaceId, siteId)}`,
+      openWorkspace: (id) => rail.openWorkspace(id),
+      openWorkspacePicker: () => openCommandMenu(true),
+      openInbox: () => {
+        rail.setDrawerOpen(false);
+        void navigate({ to: "/workspaces/$workspaceId/inbox", params: { workspaceId } });
+      },
+      toggleSidebar: () => rail.isMobile ? rail.setDrawerOpen(!rail.drawerOpen) : rail.toggleCollapsed(),
+      toggleWorkspacePanel: () => {
+        if (!inspectorOpen && rail.isMobile) rail.setDrawerOpen(false);
+        setInspectorOpen((open) => !open);
+      },
+      findInChat: () => requestConversationFind(uiEvents),
+      searchMessages: (query) => requestSessionSearch(windowEvents, workspaceId, void 0, query),
+      renameCurrentChat: () => uiEvents.dispatchEvent(new Event(RENAME_CURRENT_CHAT_EVENT)),
+      forkCurrentChat: () => uiEvents.dispatchEvent(new Event(FORK_CURRENT_CHAT_EVENT)),
+      openCommandMenu: () => openCommandMenu(),
+      openShortcutSheet,
+      switchToRecentChat: () => {
+        const directory3 = readChatDirectory(subjectId, workspaceId);
+        const target = openChatSwitcher(directory3, routeChatId, false, reachable);
+        const id = target?.ids[target.index];
+        if (id) openChatForTyping(id, directory3.rows.get(id)?.workspaceId);
+      },
+      sidebarOrder: () => readChatDirectory(subjectId, workspaceId).sidebarOrder,
+      pinnedOrder: () => readChatDirectory(subjectId, workspaceId).pinnedOrder
+    }),
+    [
+      workspaceId,
+      subjectId,
+      platform,
+      currentChat,
+      routeSiteId,
+      routeChatId,
+      ops,
+      chatList,
+      workspacePanel,
+      workspaces,
+      canForkCurrentChat,
+      reachable,
+      meetings,
+      meetingPages,
+      inspectorOpen,
+      setInspectorOpen,
+      rail,
+      openChatForTyping,
+      navigate,
+      page,
+      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(
+      appActions().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 appActions()) {
+        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.formatting && isRichTextEditor(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 reachableRef = useRef2(reachable);
+  reachableRef.current = reachable;
+  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) return;
+      const current = envRef.current;
+      current.openChat(
+        id,
+        readChatDirectory(current.subjectId, current.workspaceId).rows.get(id)?.workspaceId
+      );
+    },
+    [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,
+          reachableRef.current
+        );
+        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,
+        pickWorkspace: menu.workspaces,
+        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 ? /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(
+      ChatSwitcher,
+      {
+        state: switcher,
+        subjectId,
+        workspaceId,
+        workspaces,
+        currentChatId: routeChatId,
+        platform,
+        onHover: (index) => {
+          const current = switcherRef.current;
+          if (current) setSwitcher({ ...current, index });
+        },
+        onDirectoryChange: () => {
+          const current = switcherRef.current;
+          if (!current) return;
+          const next = extendChatSwitcher(
+            current,
+            readChatDirectory(subjectId, workspaceId),
+            reachableRef.current
+          );
+          if (next !== current) setSwitcher(next);
+        },
+        onPick: pickSwitcherChat,
+        onDismiss: () => setSwitcher(null)
+      }
+    ) }) : null
+  ] });
+}
+
+export {
+  siteRecords,
+  rememberSidebarSites,
+  readSidebarSites,
+  useSiteDirectoryVersion,
+  meetingRecords,
+  rememberRecentMeetings,
+  readRecentMeetings,
+  useMeetingDirectoryVersion,
+  useChatOperations,
+  actionTitle,
+  actionIcon,
+  appActions,
+  findAction,
+  useAppActions,
+  useActionShortcut,
+  ActionsProvider
+};
+//# sourceMappingURL=chunk-HGKTHF2U.js.map