nexus-shell 0.1.22 → 0.2.0

package/dist/components/widgets/UserProfile.d.ts

@@ -1,12 +1,81 @@
-import { default as React } from 'react';
+import { LucideIcon } from 'lucide-react';
 
-export interface UserProfileProps {
-    name?: string;
-    avatarUrl?: string;
+/** The identity rendered by {@link UserProfile}. */
+export interface IUserProfile {
+    /** Display name. Shown on the trigger and in the dropdown header. */
+    name: string;
+    /** Secondary line, e.g. job title. Omit to hide it. */
     role?: string;
+    /** Shown in the dropdown header only. */
     email?: string;
+    /** Image URL or data URL. Falls back to a generic user icon. */
+    avatarUrl?: string;
+}
+/** An action in the profile dropdown. */
+export interface IUserProfileAction {
+    /** Stable identifier. Used as the React key. */
+    id: string;
+    /** Label shown for the action. */
+    label: string;
+    /** `lucide-react` icon rendered at 12px. */
+    icon?: LucideIcon;
+    /** Runs on click. The dropdown closes afterwards. */
+    onSelect: () => void;
+    /** Render in the destructive colour, for sign-out and similar. */
+    destructive?: boolean;
+    /** Draw a separator above this action. */
+    divider?: boolean;
+}
+export interface UserProfileProps {
+    /** The identity to display. */
+    profile: IUserProfile;
+    /**
+     * Actions listed in the dropdown. Empty by default — the component prescribes
+     * no menu, since "Sign Out" and "Account Settings" mean different things in
+     * every app.
+     */
+    actions?: IUserProfileAction[];
+    /**
+     * Called with the new name and role when the inline editor is saved.
+     * Omit it to hide the edit affordance entirely.
+     */
+    onProfileChange?: (profile: Pick<IUserProfile, 'name' | 'role'>) => void;
+    /**
+     * Called with a file the user picked for their avatar. Read it and update
+     * `profile.avatarUrl` yourself — the component neither reads files nor holds
+     * the result. Omit it to hide the upload affordance.
+     */
+    onAvatarChange?: (file: File) => void;
+    /**
+     * Bypass the dropdown entirely and just report the click. Useful when the
+     * profile should open a full settings tab instead of a menu.
+     */
     onClick?: () => void;
-    className?: string;
+    /** Show the name and role beside the avatar. Defaults to `true`. */
     showName?: boolean;
+    /** Extra classes merged onto the trigger button. */
+    className?: string;
 }
-export declare const UserProfile: React.FC<UserProfileProps>;
+/**
+ * An avatar and identity widget with a dropdown menu, sized for a menu bar's
+ * right slot.
+ *
+ * Fully controlled — it owns only its open/editing UI state. The identity comes
+ * in as `profile`, edits go out through `onProfileChange`, and the menu is
+ * whatever you pass as `actions`. It reads no store and prescribes no menu
+ * items, so it works the same against a session hook, an auth provider, or
+ * static props.
+ *
+ * @example
+ * ```tsx
+ * <UserProfile
+ *   profile={{ name: 'Ada Lovelace', role: 'Engineer', email: 'ada@example.com' }}
+ *   onProfileChange={(next) => save(next)}
+ *   actions={[
+ *     { id: 'settings', label: 'Account Settings', icon: Settings, onSelect: openSettings },
+ *     { id: 'out', label: 'Sign Out', icon: LogOut, onSelect: signOut, destructive: true, divider: true },
+ *   ]}
+ * />
+ * ```
+ */
+export declare const UserProfile: ({ profile, actions, onProfileChange, onAvatarChange, onClick, showName, className, }: UserProfileProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedActivityBar.d.ts

@@ -0,0 +1,10 @@
+import { ActivityBarProps } from '../components/widgets/ActivityBar';
+
+export type ConnectedActivityBarProps = Omit<ActivityBarProps, 'items' | 'activeId' | 'onSelect'>;
+/**
+ * {@link ActivityBar} bound to `useSidebarStore`.
+ *
+ * Derives its items from the registered sidebar panels and toggles the active
+ * panel on click — clicking the already-active item closes the sidebar.
+ */
+export declare const ConnectedActivityBar: (props: ConnectedActivityBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedChatPane.d.ts

@@ -0,0 +1,18 @@
+import { ChatPaneProps } from '../components/widgets/ChatPane';
+
+export type ConnectedChatPaneProps = Omit<ChatPaneProps, 'messages' | 'slashCommands' | 'onSend' | 'onClose'> & {
+    /**
+     * Handle a plain (non-slash) message. Append any reply with
+     * `useChatStore.getState().addMessage(...)`. Without this, user messages are
+     * recorded but nothing responds.
+     */
+    onSend?: (text: string) => void;
+};
+/**
+ * {@link ChatPane} bound to `useChatStore` and `useRightSidebarStore`.
+ *
+ * Renders nothing while the right sidebar reports chat closed. Appends each
+ * submission to the transcript, then either dispatches a registered slash
+ * command's `execute` or hands the text to `onSend`.
+ */
+export declare const ConnectedChatPane: ({ onSend, ...props }: ConnectedChatPaneProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/connected/ConnectedCommandPalette.d.ts

@@ -0,0 +1,18 @@
+import { CommandPaletteProps } from '../components/widgets/CommandPalette';
+import { ICommand } from '../core/registry/CommandRegistry';
+
+export type ConnectedCommandPaletteProps = Omit<CommandPaletteProps<ICommand>, 'open' | 'commands' | 'onSelect' | 'onClose'> & {
+    /**
+     * Key that opens the palette when held with Cmd/Ctrl+Shift. Defaults to
+     * `"p"`, matching VS Code's `Cmd+Shift+P`. Pass `null` to bind nothing.
+     */
+    shortcutKey?: string | null;
+};
+/**
+ * {@link CommandPalette} bound to the {@link commandRegistry}.
+ *
+ * Owns its own visibility and binds a global `Cmd/Ctrl+Shift+P` listener to
+ * toggle it. Selecting a command runs the registry entry's `execute` and closes
+ * the palette.
+ */
+export declare const ConnectedCommandPalette: ({ shortcutKey, ...props }: ConnectedCommandPaletteProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedMenuBar.d.ts

@@ -0,0 +1,12 @@
+import { MenuBarProps } from '../components/widgets/MenuBar';
+
+export type ConnectedMenuBarProps = Omit<MenuBarProps, 'menus' | 'onSelect'>;
+/**
+ * {@link MenuBar} bound to the {@link menuRegistry} and {@link commandRegistry}.
+ *
+ * Reads the menu structure from the registry, backfills keybinding hints from
+ * each item's registered command, and dispatches the item's `commandId` on
+ * select. Use this inside a shell; use the plain {@link MenuBar} when you want
+ * to pass menus as data.
+ */
+export declare const ConnectedMenuBar: (props: ConnectedMenuBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedModal.d.ts

@@ -0,0 +1,15 @@
+import { ModalProps } from '../components/widgets/Modal';
+
+export type ConnectedModalProps = Omit<ModalProps, 'open' | 'type' | 'title' | 'message' | 'defaultValue' | 'onConfirm' | 'onCancel'>;
+/**
+ * {@link Modal} bound to `useModalStore`.
+ *
+ * Mount this once near the root of your app. It renders whichever dialog the
+ * store has open and resolves the store's pending promise on dismissal, which
+ * is what lets any code `await useModalStore.getState().openConfirm(...)`
+ * without holding a component reference.
+ *
+ * Resolution values follow the store's contract: `prompt` resolves to the text
+ * or `null`, `confirm` to a boolean, `alert` to `undefined`.
+ */
+export declare const ConnectedModal: (props: ConnectedModalProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedSidebarPane.d.ts

@@ -0,0 +1,12 @@
+import { SidebarPaneProps } from '../components/widgets/SidebarPane';
+
+export type ConnectedSidebarPaneProps = Omit<SidebarPaneProps, 'title' | 'children' | 'onClose'>;
+/**
+ * {@link SidebarPane} bound to `useSidebarStore`.
+ *
+ * Renders whichever panel is active, or nothing when the sidebar is closed. The
+ * reserved `"settings"` panel id renders the built-in {@link SettingsPanel}
+ * wired to `useThemeStore`; every other id resolves against the panels
+ * registered in the store.
+ */
+export declare const ConnectedSidebarPane: (props: ConnectedSidebarPaneProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/connected/ConnectedStatusBar.d.ts

@@ -0,0 +1,15 @@
+import { StatusBarProps } from '../components/widgets/StatusBar';
+
+export type ConnectedStatusBarProps = Omit<StatusBarProps, 'widgets'>;
+/**
+ * {@link StatusBar} bound to `useStatusBarStore`.
+ *
+ * Reads items from the shell store and resolves each item's `commandId`
+ * against the {@link commandRegistry}, so store-registered items can trigger
+ * commands without holding a function reference. An explicit `onClick` on the
+ * item takes precedence over its `commandId`.
+ *
+ * Use this inside a shell; use the plain {@link StatusBar} when you want to
+ * supply items yourself.
+ */
+export declare const ConnectedStatusBar: (props: ConnectedStatusBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedTerminalPane.d.ts

@@ -0,0 +1,18 @@
+import { TerminalPaneProps } from '../components/widgets/TerminalPane';
+
+export type ConnectedTerminalPaneProps = Omit<TerminalPaneProps, 'history' | 'onCommand' | 'onClose'> & {
+    /**
+     * Handle a command the built-ins don't cover. Return `true` if you handled
+     * it; return `false` or omit the handler to fall through to
+     * "command not found".
+     */
+    onCommand?: (command: string) => boolean | void;
+};
+/**
+ * {@link TerminalPane} bound to `useTerminalStore`.
+ *
+ * Renders nothing while the store reports the terminal closed. Echoes each
+ * command into history and handles `help` and `clear` internally; anything else
+ * is offered to `onCommand` before falling back to a not-found message.
+ */
+export declare const ConnectedTerminalPane: ({ onCommand, ...props }: ConnectedTerminalPaneProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/connected/ConnectedThemeSwitcher.d.ts

@@ -0,0 +1,11 @@
+import { ThemeSwitcherProps } from '../components/widgets/ThemeSwitcher';
+import { ThemeType } from '../core/services/ThemeService';
+
+export type ConnectedThemeSwitcherProps = Omit<ThemeSwitcherProps<ThemeType>, 'value' | 'onChange'>;
+/**
+ * {@link ThemeSwitcher} bound to `useThemeStore`.
+ *
+ * Selecting a theme writes it to the store, which applies the matching
+ * `theme-*` class to `<html>` and persists the choice to `localStorage`.
+ */
+export declare const ConnectedThemeSwitcher: (props: ConnectedThemeSwitcherProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedUserProfile.d.ts

@@ -0,0 +1,14 @@
+import { UserProfileProps } from '../components/widgets/UserProfile';
+
+export type ConnectedUserProfileProps = Omit<UserProfileProps, 'profile' | 'onProfileChange' | 'onAvatarChange'>;
+/**
+ * {@link UserProfile} bound to `useUserProfileStore`.
+ *
+ * Reads the identity from the store, writes inline edits back to it, and reads
+ * a picked avatar file as a data URL before storing it.
+ *
+ * The dropdown's `actions` are deliberately still yours to pass — sign-out and
+ * account settings mean different things in every app, so the library declines
+ * to guess.
+ */
+export declare const ConnectedUserProfile: (props: ConnectedUserProfileProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Store-connected component variants.
+ *
+ * Every component in `components/` is pure and prop-driven. The wrappers here
+ * bind those components to the shell's zustand stores and registries, so
+ * `ShellLayout` — and any app that opts into the batteries-included shell — can
+ * compose them without prop-drilling.
+ *
+ * Reach for these when you want the shell's behavior. Reach for the plain
+ * components when you want control.
+ */
+export { ConnectedActivityBar, type ConnectedActivityBarProps } from './ConnectedActivityBar';
+export { ConnectedChatPane, type ConnectedChatPaneProps } from './ConnectedChatPane';
+export { ConnectedCommandPalette, type ConnectedCommandPaletteProps } from './ConnectedCommandPalette';
+export { ConnectedMenuBar, type ConnectedMenuBarProps } from './ConnectedMenuBar';
+export { ConnectedModal, type ConnectedModalProps } from './ConnectedModal';
+export { ConnectedSidebarPane, type ConnectedSidebarPaneProps } from './ConnectedSidebarPane';
+export { ConnectedStatusBar, type ConnectedStatusBarProps } from './ConnectedStatusBar';
+export { ConnectedTerminalPane, type ConnectedTerminalPaneProps } from './ConnectedTerminalPane';
+export { ConnectedThemeSwitcher, type ConnectedThemeSwitcherProps } from './ConnectedThemeSwitcher';
+export { ConnectedUserProfile, type ConnectedUserProfileProps } from './ConnectedUserProfile';

package/dist/core/registry/MenuRegistry.d.ts

@@ -1,15 +1,28 @@
-export interface IMenuItem {
-    id: string;
-    label: string;
+import { IMenuItem } from '../../components/widgets/MenuBar';
+
+/**
+ * A menu entry as held in the registry. Extends the presentational
+ * {@link IMenuItem} with `commandId`, which `ConnectedMenuBar` resolves against
+ * the {@link commandRegistry} when the item is chosen.
+ */
+export interface IMenuItemConfig extends IMenuItem {
+    /** Command to execute when the item is selected. */
     commandId?: string;
-    keybinding?: string;
-    submenu?: IMenuItem[];
+    /** Nested entries, which may themselves carry a `commandId`. */
+    submenu?: IMenuItemConfig[];
 }
+/**
+ * Holds the application's menu structure, keyed by top-level menu name.
+ *
+ * This is a shell-level convenience so plugins can contribute menu entries
+ * without prop-drilling. The presentational `MenuBar` does not read it.
+ */
 export declare class MenuRegistry {
     private menus;
-    registerMenu(menuId: string, item: IMenuItem): void;
-    setMenus(menuConfig: Record<string, IMenuItem[]>): void;
-    getMenu(menuId: string): IMenuItem[];
-    getAllMenus(): Record<string, IMenuItem[]>;
+    registerMenu(menuId: string, item: IMenuItemConfig): void;
+    setMenus(menuConfig: Record<string, IMenuItemConfig[]>): void;
+    getMenu(menuId: string): IMenuItemConfig[];
+    getAllMenus(): Record<string, IMenuItemConfig[]>;
 }
 export declare const menuRegistry: MenuRegistry;
+export type { IMenuItem };

package/dist/core/services/ChatService.d.ts

@@ -1,12 +1,28 @@
-export interface ISlashCommand {
-    command: string;
-    description: string;
+import { IChatMessage, ISlashCommand } from '../../components/widgets/ChatPane';
+
+/**
+ * A slash command as held in the shell store. Extends the presentational
+ * {@link ISlashCommand} with the handler that runs when it is invoked.
+ */
+export interface ISlashCommandConfig extends ISlashCommand {
+    /** Runs when the command is submitted. Receives the whitespace-split args. */
     execute: (args: string[]) => void;
 }
 interface ChatState {
-    slashCommands: ISlashCommand[];
-    setSlashCommands: (commands: ISlashCommand[]) => void;
-    registerSlashCommand: (command: ISlashCommand) => void;
+    messages: IChatMessage[];
+    slashCommands: ISlashCommandConfig[];
+    setMessages: (messages: IChatMessage[]) => void;
+    addMessage: (message: Omit<IChatMessage, 'id'> & {
+        id?: string;
+    }) => void;
+    clearMessages: () => void;
+    setSlashCommands: (commands: ISlashCommandConfig[]) => void;
+    registerSlashCommand: (command: ISlashCommandConfig) => void;
 }
+/**
+ * Shell-level store for the chat pane's transcript and slash commands.
+ * Consumed by `ConnectedChatPane`; the presentational `ChatPane` does not read
+ * it.
+ */
 export declare const useChatStore: import('zustand').UseBoundStore<import('zustand').StoreApi<ChatState>>;
-export {};
+export type { IChatMessage, ISlashCommand };

package/dist/core/services/StatusBarService.d.ts

@@ -1,21 +1,24 @@
-import { LucideIcon } from 'lucide-react';
+import { IStatusBarWidget } from '../../components/widgets/StatusBar';
 
-export interface IStatusBarWidget {
-    id: string;
-    label: string;
-    icon?: LucideIcon;
-    alignment: 'left' | 'center' | 'right';
+/**
+ * A status bar item as held in the shell store. Extends the presentational
+ * {@link IStatusBarWidget} with `commandId`, which the connected wrapper
+ * resolves against the {@link commandRegistry} at click time.
+ */
+export interface IStatusBarWidgetConfig extends IStatusBarWidget {
+    /** Command to execute on click. Ignored if `onClick` is also provided. */
     commandId?: string;
-    onClick?: () => void;
-    className?: string;
-    priority?: number;
 }
 interface StatusBarState {
-    widgets: IStatusBarWidget[];
-    setWidgets: (widgets: IStatusBarWidget[]) => void;
-    addWidget: (widget: IStatusBarWidget) => void;
+    widgets: IStatusBarWidgetConfig[];
+    setWidgets: (widgets: IStatusBarWidgetConfig[]) => void;
+    addWidget: (widget: IStatusBarWidgetConfig) => void;
     removeWidget: (id: string) => void;
-    updateWidget: (id: string, updates: Partial<IStatusBarWidget>) => void;
+    updateWidget: (id: string, updates: Partial<IStatusBarWidgetConfig>) => void;
 }
+/**
+ * Shell-level store holding the status bar's items. Consumed by
+ * `ConnectedStatusBar`; the presentational `StatusBar` does not read it.
+ */
 export declare const useStatusBarStore: import('zustand').UseBoundStore<import('zustand').StoreApi<StatusBarState>>;
-export {};
+export type { IStatusBarWidget };

package/dist/index.d.ts

@@ -1,39 +1,51 @@
-export { ShellLayout } from './components/layout/ShellLayout';
-export { MenuBar } from './components/widgets/MenuBar';
-export { StatusBar } from './components/widgets/StatusBar';
-export { ActivityBar } from './components/widgets/ActivityBar';
-export { SidebarPane } from './components/widgets/SidebarPane';
-export { TreeWidget } from './components/widgets/TreeWidget';
-export { SearchWidget, type ISearchResult, type SearchWidgetProps } from './components/widgets/SearchWidget';
-export { CommandPalette } from './components/widgets/CommandPalette';
-export { UserProfile, type UserProfileProps } from './components/widgets/UserProfile';
-export { ChatPane } from './components/widgets/ChatPane';
-export { TerminalPane } from './components/widgets/TerminalPane';
-export { AgentManager, type Agent, type AgentManagerProps } from './components/widgets/AgentManager';
-export { WargameMap, type WargameMapProps, type UnitData, type AttackData, type TerrainHexData } from './components/widgets/WargameMap';
+/**
+ * Nexus Shell — a React component library for building IDE-style application
+ * shells.
+ *
+ * The surface is deliberately two-tier:
+ *
+ * 1. **Primitives** — pure, prop-driven components with no global state. Use
+ *    these to build your own layout. They are the supported public API.
+ * 2. **Shell** — `ShellLayout` plus the stores and registries behind it, for
+ *    when you want the whole assembled application frame.
+ *
+ * Import the stylesheet once in your app entry:
+ * ```ts
+ * import 'nexus-shell/style.css';
+ * ```
+ */
+export { ActivityBar, type ActivityBarProps, type IActivityBarItem } from './components/widgets/ActivityBar';
+export { ChatPane, type ChatPaneProps, type IChatMessage, type ISlashCommand } from './components/widgets/ChatPane';
+export { CommandPalette, type CommandPaletteProps, type ICommandItem } from './components/widgets/CommandPalette';
+export { ContextMenu, type ContextMenuProps, type IContextMenuItem } from './components/widgets/ContextMenu';
 export { DataGrid, type DataGridProps, type IDataGridColumn } from './components/widgets/DataGrid';
-export { MockupReviewWidget } from './components/widgets/MockupReviewWidget';
-export { useMockupReviewStore, type IMockupAnnotation, type IMockupVersion, type IMockupView } from './core/services/MockupReviewService';
-export { DialogueMappingWidget } from './components/widgets/DialogueMappingWidget';
-export { DialogueMapperLibraryWidget } from './components/widgets/DialogueMapperLibraryWidget';
-export { ArgumentInspectorWidget } from './components/widgets/ArgumentInspectorWidget';
-export { DialogueMapperLibrary, type DialogueMapperLibraryProps } from './components/widgets/DialogueMapperLibrary';
-export { FlowControlToolbar, type FlowControlToolbarProps } from './components/widgets/FlowControlToolbar';
-export { NexusWorkspaceShell, type NexusWorkspaceShellProps } from './components/layout/NexusWorkspaceShell';
-export { ThemeSwitcher, type ThemeSwitcherProps } from './components/widgets/ThemeSwitcher';
-export { NexusWorkspaceTitle, type NexusWorkspaceTitleProps } from './components/widgets/NexusWorkspaceTitle';
-export { useDialogueMappingStore, type IDialogueNodeData, type IbisNodeType } from './core/services/DialogueMappingService';
-export { commandRegistry, type ICommand } from './core/registry/CommandRegistry';
-export { menuRegistry, type IMenuItem } from './core/registry/MenuRegistry';
+export { MenuBar, type MenuBarProps, type IMenuItem } from './components/widgets/MenuBar';
+export { Modal, type ModalProps, type ModalType } from './components/widgets/Modal';
+export { QuickSearch, type QuickSearchProps, type IQuickSearchResult } from './components/widgets/QuickSearch';
+export { SearchWidget, type SearchWidgetProps, type ISearchResult } from './components/widgets/SearchWidget';
+export { SettingsPanel, type SettingsPanelProps, type ISettingsThemeOption, DEFAULT_SETTINGS_THEMES } from './components/widgets/SettingsPanel';
+export { SidebarPane, type SidebarPaneProps } from './components/widgets/SidebarPane';
+export { StatusBar, type StatusBarProps, type IStatusBarWidget } from './components/widgets/StatusBar';
+export { TerminalPane, type TerminalPaneProps } from './components/widgets/TerminalPane';
+export { ThemeSwitcher, type ThemeSwitcherProps, type IThemeOption, DEFAULT_THEME_OPTIONS } from './components/widgets/ThemeSwitcher';
+export { TreeWidget, type TreeWidgetProps, type ITreeNode, type ITreeAction, type ITreeContext } from './components/widgets/TreeWidget';
+export { UserProfile, type UserProfileProps, type IUserProfile, type IUserProfileAction } from './components/widgets/UserProfile';
+export { AppTitle, type AppTitleProps } from './components/widgets/AppTitle';
+export { cn } from './lib/cn';
+export { ShellLayout, ShellLayout as NexusWorkspaceShell, type ShellLayoutProps } from './components/layout/ShellLayout';
+export declare const initializeShell: (_config?: unknown) => void;
+export * from './connected';
+export { commandRegistry, CommandRegistry, type ICommand } from './core/registry/CommandRegistry';
+export { menuRegistry, MenuRegistry, type IMenuItemConfig } from './core/registry/MenuRegistry';
 export { pluginRegistry, type IPlugin, type PluginStatus } from './core/registry/PluginRegistry';
 export { componentRegistry, type ComponentConstructor } from './core/registry/ComponentRegistry';
-export { initializeShell } from './core/Boot';
+export { useChatStore, type ISlashCommandConfig } from './core/services/ChatService';
 export { useLayoutStore } from './core/services/LayoutService';
-export { useThemeStore, type ThemeType } from './core/services/ThemeService';
-export { useSidebarStore, type ISidebarPanel } from './core/services/SidebarService';
+export { useModalStore, type ModalType as ModalStoreType } from './core/services/ModalStoreService';
 export { useRightSidebarStore } from './core/services/RightSidebarService';
+export { useSidebarStore, type ISidebarPanel } from './core/services/SidebarService';
+export { useStatusBarStore, type IStatusBarWidgetConfig } from './core/services/StatusBarService';
 export { useTerminalStore } from './core/services/TerminalService';
-export { useChatStore, type ISlashCommand } from './core/services/ChatService';
-export { useStatusBarStore, type IStatusBarWidget } from './core/services/StatusBarService';
-export { useKeyboardShortcuts } from './core/services/KeyboardService';
+export { useThemeStore, type ThemeType } from './core/services/ThemeService';
 export { useUserProfileStore, type UserProfileState } from './core/services/UserProfileService';
+export { useKeyboardShortcuts } from './core/services/KeyboardService';

package/dist/lib/cn.d.ts

@@ -0,0 +1,12 @@
+import { ClassValue } from 'clsx';
+
+/**
+ * Merge Tailwind class names, resolving conflicts so the last-specified
+ * utility wins. Use this anywhere a component accepts a `className` prop
+ * that should be able to override the component's own defaults.
+ *
+ * @example
+ * cn('px-2 text-sm', isActive && 'text-primary', className)
+ */
+export declare function cn(...inputs: ClassValue[]): string;
+export type { ClassValue };