nexus-shell 0.1.23 → 0.2.1

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

@@ -1,21 +1,110 @@
 import { default as React } from 'react';
 
+/** A node in the {@link TreeWidget} hierarchy. */
 export interface ITreeNode {
+    /** Stable identifier, unique across the whole tree. */
     id: string;
+    /** Text shown for the node. */
     label: string;
+    /** `folder` nodes expand on click; `file` nodes do not. */
     type: 'file' | 'folder';
+    /** Child nodes. Only rendered while `isOpen` is `true`. */
     children?: ITreeNode[];
+    /** Whether a folder is expanded. Controlled by you — see `onToggle`. */
     isOpen?: boolean;
-    level?: number;
+}
+/**
+ * Where a context-menu action applies.
+ *
+ * `nodeId` is `null` when the menu was opened on empty background, which is how
+ * you distinguish "new file here" from "new file at the root".
+ */
+export interface ITreeContext {
+    /** The right-clicked node's id, or `null` for the background. */
+    nodeId: string | null;
+    /** The right-clicked node, or `null` for the background. */
+    node: ITreeNode | null;
+}
+/** A custom entry in the tree's right-click menu. */
+export interface ITreeAction {
+    /** Stable identifier. Used as the React key. */
+    id: string;
+    /** Label shown in the menu. */
+    label: string;
+    /** Optional icon element, rendered before the label. */
+    icon?: React.ReactNode;
+    /** Runs with the right-clicked target. */
+    onSelect: (context: ITreeContext) => void;
+    /** Draw a separator above this entry. */
+    divider?: boolean;
+    /**
+     * Restrict where the entry appears. Defaults to everywhere. Use this for
+     * actions that only make sense on a folder, or only on the background.
+     */
+    showFor?: ('file' | 'folder' | 'background')[];
 }
 export interface TreeWidgetProps {
+    /** Root nodes. Expansion state lives on the nodes themselves via `isOpen`. */
     data: ITreeNode[];
-    onMoveNode?: (draggedId: string, targetId: string) => void;
+    /**
+     * Called when a folder is clicked. Flip that node's `isOpen` in your own
+     * state — the tree renders expansion but does not own it.
+     */
+    onToggle?: (node: ITreeNode) => void;
+    /** Called when a node is double-clicked. Typically opens the item. */
+    onActivate?: (node: ITreeNode) => void;
+    /** Called after a node is dragged onto a folder. */
+    onMoveNode?: (draggedId: string, targetFolderId: string) => void;
+    /**
+     * Entries for the right-click menu. Defaults to New File, New Folder, Rename
+     * and Delete, which map to the `onNew*` / `onRename` / `onDelete` props.
+     *
+     * Pass your own array to replace that set entirely — this is the extension
+     * point for app-specific commands, so the tree itself stays generic.
+     */
+    actions?: ITreeAction[];
+    /** Handler for the built-in "New File" action. */
     onNewFile?: (parentId: string | null) => void;
+    /** Handler for the built-in "New Folder" action. */
     onNewFolder?: (parentId: string | null) => void;
-    onNewDialogueMap?: (parentId: string | null) => void;
+    /** Handler for the built-in "Rename" action. */
     onRename?: (nodeId: string) => void;
+    /** Handler for the built-in "Delete" action. */
     onDelete?: (nodeId: string) => void;
-    onDoubleClick?: (node: ITreeNode) => void;
+    /** Indentation added per depth level, in px. Defaults to `12`. */
+    indent?: number;
+    /**
+     * Virtualise rows with `react-virtuoso`. Leave on for large trees; turn it
+     * off when every row must be present in the DOM — printing, full-text browser
+     * search, or a test environment that can't measure layout. Defaults to `true`.
+     */
+    virtualized?: boolean;
+    /** Extra classes merged onto the root element. */
+    className?: string;
 }
-export declare const TreeWidget: React.FC<TreeWidgetProps>;
+/**
+ * A virtualised file-explorer tree with drag-to-move and a right-click menu.
+ *
+ * Rows are virtualised via `react-virtuoso`, so very large trees stay
+ * responsive. The component is controlled: expansion lives on your nodes as
+ * `isOpen` and changes are reported through `onToggle`, so the tree never holds
+ * a second copy of your data.
+ *
+ * The context menu is data-driven. The defaults cover the usual file
+ * operations; pass `actions` to replace them with your own commands rather than
+ * adding one-off props.
+ *
+ * @example
+ * ```tsx
+ * <TreeWidget
+ *   data={nodes}
+ *   onToggle={(n) => setNodes(toggle(nodes, n.id))}
+ *   onActivate={(n) => open(n.id)}
+ *   actions={[
+ *     { id: 'new-map', label: 'New Map', icon: <Map size={14} />,
+ *       showFor: ['folder', 'background'], onSelect: (ctx) => createMap(ctx.nodeId) },
+ *   ]}
+ * />
+ * ```
+ */
+export declare const TreeWidget: ({ data, onToggle, onActivate, onMoveNode, actions, onNewFile, onNewFolder, onRename, onDelete, indent, virtualized, className, }: TreeWidgetProps) => import("react/jsx-runtime").JSX.Element;

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/Boot.d.ts

@@ -1,4 +1,66 @@
+import { ICommand } from './registry/CommandRegistry';
+import { IMenuItemConfig } from './registry/MenuRegistry';
+import { ISlashCommandConfig } from './services/ChatService';
+import { ISidebarPanel } from './services/SidebarService';
+import { IStatusBarWidgetConfig } from './services/StatusBarService';
+
+export interface InitializeShellOptions {
+    /**
+     * Sidebar panels to register. Each becomes an icon in the activity bar and
+     * renders its `component` in the sidebar when selected.
+     */
+    panels?: ISidebarPanel[];
+    /** Menus keyed by top-level name. Items dispatch through their `commandId`. */
+    menus?: Record<string, IMenuItemConfig[]>;
+    /** Commands available to the palette, menus and keybindings. */
+    commands?: ICommand[];
+    /** Items for the status bar, grouped by their `alignment`. */
+    statusBar?: IStatusBarWidgetConfig[];
+    /** Slash commands offered in the chat pane. */
+    slashCommands?: ISlashCommandConfig[];
+    /**
+     * Register the built-in view and theme commands listed in
+     * {@link DEFAULT_COMMAND_IDS}. Defaults to `true`. Turn it off if your app
+     * wants to own every command id.
+     */
+    defaultCommands?: boolean;
+    /**
+     * Register a default **View** menu exposing the built-in commands. Defaults
+     * to `true`, and is ignored when `defaultCommands` is `false`.
+     */
+    defaultMenus?: boolean;
+}
+/** The command ids `initializeShell` registers unless told not to. */
+export declare const DEFAULT_COMMAND_IDS: readonly ["view.toggleTerminal", "view.toggleChat", "view.toggleSidebar", "theme.light", "theme.dark", "theme.gt"];
 /**
- * Initializes the shell's core commands and menus.
+ * Boot the shell: register commands, menus, panels and status bar items into
+ * the shell registries and stores.
+ *
+ * This is the usual first call in a Nexus Shell application. `ShellLayout` can
+ * take the same configuration as props, but doing it here has two advantages:
+ * it runs once rather than on every render, and it happens outside React, so
+ * plugins and other non-component code can contribute in exactly the same way.
+ *
+ * Call it once, before rendering. It is safe to call again — the registries
+ * warn on duplicate ids rather than throwing — but it is not a reset: nothing
+ * previously registered is removed.
+ *
+ * @example
+ * ```ts
+ * // main.tsx
+ * import { initializeShell, componentRegistry } from 'nexus-shell';
+ * import 'nexus-shell/style.css';
+ *
+ * componentRegistry.register('editor', Editor);
+ *
+ * initializeShell({
+ *   panels: [{ id: 'files', label: 'Explorer', icon: Files, component: FileTree }],
+ *   commands: [{ id: 'file.save', label: 'File: Save', keybinding: 'Control+s', execute: save }],
+ *   menus: { File: [{ id: 'save', label: 'Save', commandId: 'file.save' }] },
+ *   statusBar: [{ id: 'branch', label: 'main', alignment: 'left' }],
+ * });
+ *
+ * createRoot(el).render(<ShellLayout title={<AppTitle title="Acme" />} />);
+ * ```
  */
-export declare const initializeShell: () => Promise<void>;
+export declare const initializeShell: (options?: InitializeShellOptions) => void;

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 };