@hachej/boring-workspace 0.1.0

package/dist/workspace.d.ts

@@ -0,0 +1,2119 @@
+import { ClassValue } from 'clsx';
+import { Component } from 'react';
+import { ComponentType } from 'react';
+import { Context } from 'react';
+import { dismissToast } from '@hachej/boring-ui-kit';
+import { DockviewApi } from 'dockview-react';
+import { DockviewPanelApi } from 'dockview-react';
+import { ErrorInfo } from 'react';
+import { Extension } from '@codemirror/state';
+import { JSX } from 'react/jsx-runtime';
+import { JSXElementConstructor } from 'react';
+import { LucideIcon } from 'lucide-react';
+import { PersistOptions } from 'zustand/middleware';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { StoreApi as StoreApi_3 } from 'zustand';
+import { toast } from '@hachej/boring-ui-kit';
+import { ToastApi } from '@hachej/boring-ui-kit';
+import { Toaster } from '@hachej/boring-ui-kit';
+import { ToasterProps } from '@hachej/boring-ui-kit';
+import { ToastInput } from '@hachej/boring-ui-kit';
+import { ToastRecord } from '@hachej/boring-ui-kit';
+import { ToastVariant } from '@hachej/boring-ui-kit';
+import { z } from 'zod';
+
+export declare function agentMeta(toolCallId: string): {
+    cause: "agent";
+    toolCallId: string;
+    ts: number;
+};
+
+/**
+ * Structural tool contract accepted from workspace plugins and UI tool
+ * factories. Kept agent-runtime-neutral so only the app integration layer
+ * needs to import @hachej/boring-agent.
+ */
+export declare interface AgentTool {
+    name: string;
+    description: string;
+    promptSnippet?: string;
+    parameters: JSONSchema;
+    execute(params: Record<string, unknown>, ctx: ToolExecContext): Promise<ToolResult>;
+}
+
+export declare interface AgentToolOutput {
+    /**
+     * @deprecated Executable agent tools should be contributed by server
+     * plugins. This output remains for migration only.
+     */
+    type: "agent-tool";
+    id: string;
+    tool: AgentTool;
+}
+
+export declare interface AgentToolRegistry {
+    register(tool: AgentTool, pluginId: string): void;
+}
+
+export declare function appendDataCatalogOutputs<T extends WorkspaceFrontPlugin>(plugin: T, options: CreateDataCatalogOutputsOptions): T;
+
+export declare interface ArtifactPanel {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+}
+
+export declare function ArtifactSurfacePane({ visible, storageKey, allowedPanels, persistedLayout, onLayoutChange, onReady, prefixHeaderActions, rightHeaderActions, watermarkComponent, className, }: ArtifactSurfacePaneProps): JSX.Element | null;
+
+export declare namespace ArtifactSurfacePane {
+    var defaultAllowedPanels: string[];
+}
+
+export declare interface ArtifactSurfacePaneProps {
+    visible?: boolean;
+    storageKey?: string;
+    allowedPanels?: string[];
+    persistedLayout?: SerializedLayout;
+    onLayoutChange?: (layout: SerializedLayout) => void;
+    onReady?: (api: DockviewApi) => void;
+    prefixHeaderActions?: React.FunctionComponent<unknown>;
+    rightHeaderActions?: React.FunctionComponent<unknown>;
+    watermarkComponent?: React.FunctionComponent<unknown>;
+    className?: string;
+}
+
+export declare type Badge = {
+    /** 1–4 char mono code rendered as a chip. */
+    code: string;
+    tooltip?: string;
+};
+
+/**
+ * DataExplorer shared types — no runtime deps.
+ *
+ * Importable from BOTH front and server bundles without dragging in
+ * platform-specific code.
+ */
+declare type Badge_2 = {
+    /** 1–4 char mono code rendered as a chip. */
+    code: string;
+    tooltip?: string;
+};
+
+export declare interface BindingOutput {
+    type: "binding";
+    id: string;
+    component: PluginBinding;
+}
+
+export declare function bindStore(store: WorkspaceStoreApi): void;
+
+export declare function bootstrap(options: BootstrapOptions): BootstrapResult;
+
+export declare interface BootstrapOptions {
+    chatPanel: unknown;
+    plugins?: WorkspaceFrontPlugin[];
+    defaults?: WorkspaceFrontPlugin[];
+    excludeDefaults?: string[];
+    registries: {
+        panels: PanelRegistryLike;
+        commands: CommandRegistryLike;
+        catalogs: CatalogRegistryLike;
+        surfaceResolvers?: SurfaceResolverRegistryLike;
+        agentTools?: AgentToolRegistry;
+    };
+}
+
+export declare interface BootstrapResult {
+    registered: string[];
+    systemPromptAppend: string;
+}
+
+export declare interface BridgeClient {
+    connect(): void;
+    disconnect(): void;
+    pushState(causedBy: CausedBy): void;
+}
+
+export declare interface BridgeClientOptions {
+    endpoint: string;
+    bridge: WorkspaceBridge;
+    store: StoreApi_2;
+    authToken?: string;
+    pollMode?: boolean;
+    pollInterval?: number;
+    onAuthError?: (statusCode: number) => void;
+    onVersionMismatch?: (version: number) => void;
+    onConnectionChange?: (connected: boolean) => void;
+}
+
+export declare interface BridgeEventMap {
+    "panel:opened": {
+        panelId: string;
+        params: Record<string, unknown>;
+    };
+    "panel:closed": {
+        panelId: string;
+    };
+    "panel:activated": {
+        panelId: string;
+        previousPanelId: string | null;
+    };
+    "file:opened": {
+        path: string;
+        mode: "view" | "edit" | "diff";
+    };
+    "file:saved": {
+        path: string;
+    };
+    "file:dirty": {
+        path: string;
+        dirty: boolean;
+    };
+    "sidebar:toggled": {
+        collapsed: boolean;
+    };
+    "tree:expand": {
+        path: string;
+    };
+    "notification:shown": {
+        message: string;
+        level: "info" | "warn" | "error";
+    };
+    "pane:error": {
+        panelId: string;
+        error: string;
+        stack?: string;
+    };
+}
+
+export declare function buildChatLayout(props?: ChatLayoutProps): LayoutConfig;
+
+export declare function buildIdeLayout(props?: IdeLayoutProps): LayoutConfig;
+
+export declare interface CatalogConfig {
+    id: string;
+    label: string;
+    adapter: ExplorerAdapter_2;
+    onSelect: (row: ExplorerRow_2) => void;
+    pluginId?: string;
+}
+
+export declare interface CatalogOutput {
+    type: "catalog";
+    catalog: CatalogConfig;
+}
+
+export declare class CatalogRegistry {
+    private catalogs;
+    private listeners;
+    private snapshotCache;
+    private warnOnDuplicate;
+    constructor(options?: CatalogRegistryOptions);
+    register(config: CatalogConfig, sourcePluginId: string): void;
+    unregister(id: string): void;
+    unregisterByPluginId(pluginId: string): void;
+    list(): readonly CatalogConfig[];
+    get(id: string): CatalogConfig | undefined;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly CatalogConfig[];
+    private emit;
+}
+
+export declare interface CatalogRegistryLike {
+    register(catalog: CatalogConfig, pluginId: string): void;
+}
+
+export declare interface CatalogRegistryOptions {
+    warnOnDuplicate?: boolean;
+}
+
+export declare type CausedBy = "user" | "agent" | "restore";
+
+export declare function ChatLayout(props: ChatLayoutProps): JSX.Element;
+
+export declare interface ChatLayoutProps {
+    nav?: string | null;
+    navParams?: Record<string, unknown>;
+    center?: string;
+    centerParams?: Record<string, unknown>;
+    surface?: string | null;
+    surfaceParams?: Record<string, unknown>;
+    sidebar?: string | null;
+    sidebarParams?: Record<string, unknown>;
+    storageKey?: string;
+    onOpenNav?: () => void;
+    onOpenSurface?: () => void;
+    className?: string;
+}
+
+export declare const closePanelSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+
+export declare function cn(...inputs: ClassValue[]): string;
+
+export declare function CodeEditor({ content, onChange, language, readOnly, lineNumbers, wordWrap, className, }: CodeEditorProps): JSX.Element;
+
+export declare function CodeEditorPane({ params, api, className }: CodeEditorPaneProps): JSX.Element;
+
+export declare type CodeEditorPaneProps = PaneProps<{
+    path?: string;
+}>;
+
+export declare interface CodeEditorProps {
+    content: string;
+    onChange?: (content: string) => void;
+    language?: string;
+    readOnly?: boolean;
+    lineNumbers?: boolean;
+    wordWrap?: boolean;
+    className?: string;
+}
+
+export declare interface CommandConfig {
+    id: string;
+    title: string;
+    run: () => void;
+    keywords?: string[];
+    shortcut?: string;
+    when?: () => boolean;
+    pluginId?: string;
+}
+
+export declare interface CommandOutput {
+    type: "command";
+    command: CommandConfig;
+}
+
+export declare function CommandPalette(_props?: CommandPaletteProps): JSX.Element;
+
+export declare type CommandPaletteProps = Record<string, never>;
+
+export declare class CommandRegistry {
+    private commands;
+    private listeners;
+    private snapshotCache;
+    registerCommand(config: CommandConfig): void;
+    unregisterByPluginId(pluginId: string): void;
+    unregisterCommand(id: string): void;
+    getCommand(id: string): CommandConfig | undefined;
+    getCommands(): CommandConfig[];
+    getActiveCommands(): CommandConfig[];
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly CommandConfig[];
+    private emit;
+}
+
+export declare interface CommandRegistryLike {
+    registerCommand(command: CommandConfig): void;
+}
+
+export declare interface CommandResult {
+    seq: number;
+    status: "ok" | "error";
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+
+/**
+ * Compose a parent plugin from smaller child plugins without introducing a new
+ * enhancer/mixin lifecycle. Contributions are flattened into PluginOutput
+ * values so normal plugin bootstrap remains the single registration path.
+ */
+export declare function composePlugins(options: ComposePluginsOptions): WorkspaceFrontPlugin;
+
+export declare interface ComposePluginsOptions {
+    id: string;
+    label?: string;
+    plugins: WorkspaceFrontPlugin[];
+    outputs?: PluginOutput[];
+    panels?: WorkspaceFrontPlugin["panels"];
+    commands?: WorkspaceFrontPlugin["commands"];
+    catalogs?: WorkspaceFrontPlugin["catalogs"];
+    agentTools?: WorkspaceFrontPlugin["agentTools"];
+    systemPrompt?: string;
+    /**
+     * When true (default), child contributions are registered as owned by the
+     * composed parent plugin. When false, output contributions carry the child
+     * plugin id so bootstrap can preserve child ownership in registries.
+     */
+    adoptOutputs?: boolean;
+}
+
+export declare function createBridge(store: StoreApi): WorkspaceBridge;
+
+export declare function createBridgeClient(options: BridgeClientOptions): BridgeClient;
+
+export declare function createDataCatalogCatalog(options: Pick<CreateDataCatalogOutputsOptions, "id" | "label" | "adapter" | "catalogId" | "catalogLabel" | "onSelect">): CatalogConfig;
+
+export declare function createDataCatalogOpenHandler(options: OpenDataCatalogVisualizationOptions): (row: ExplorerRow) => void;
+
+export declare function createDataCatalogOutputs(options: CreateDataCatalogOutputsOptions): PluginOutput[];
+
+export declare interface CreateDataCatalogOutputsOptions {
+    /**
+     * Base contribution id. Defaults catalog id to this value and left tab /
+     * visualization panel ids to derived names.
+     */
+    id?: string;
+    label?: string;
+    adapter: ExplorerAdapter;
+    facets?: FacetConfig[];
+    groupBy?: string;
+    getDragPayload?: (row: ExplorerRow) => DragPayload | null | undefined;
+    onSelect?: (row: ExplorerRow, context: DataCatalogSelectContext) => void;
+    emptyState?: ReactNode;
+    searchPlaceholder?: string;
+    pageSize?: number;
+    debounceMs?: number;
+    leftTabId?: string;
+    leftTabTitle?: string;
+    leftTabIcon?: PanelConfig["icon"];
+    includeLeftTab?: boolean;
+    catalogId?: string;
+    catalogLabel?: string;
+    includeCatalog?: boolean;
+    visualizationPanelId?: string;
+    visualizationTitle?: string;
+    visualizationIcon?: PanelConfig["icon"];
+    visualizationComponent?: ComponentType<PaneProps<DataCatalogVisualizationParams>>;
+    includeVisualizationPanel?: boolean;
+    surfaceKind?: string;
+    surfaceResolverId?: string;
+    includeSurfaceResolver?: boolean;
+    source?: PanelConfig["source"];
+}
+
+export declare function createDataCatalogPlugin(options: CreateDataCatalogPluginOptions): WorkspaceFrontPlugin;
+
+export declare interface CreateDataCatalogPluginOptions extends CreateDataCatalogOutputsOptions {
+    pluginId?: string;
+}
+
+export declare function createDataCatalogSurfaceResolver(options: CreateDataCatalogSurfaceResolverOptions): SurfaceResolverConfig;
+
+export declare interface CreateDataCatalogSurfaceResolverOptions {
+    id: string;
+    catalogId: string;
+    visualizationPanelId: string;
+    visualizationTitle: string;
+    panelIdPrefix?: string;
+    surfaceKind?: string;
+    surfaceResolverId?: string;
+    source?: string;
+}
+
+export declare function createExplorerOutputs(options: CreateExplorerOutputsOptions): PluginOutput[];
+
+export declare interface CreateExplorerOutputsOptions {
+    id: string;
+    label?: string;
+    mode?: ExplorerMode;
+    adapter?: ExplorerAdapter;
+    sectionedAdapter?: SectionedExplorerAdapter;
+    facets?: FacetConfig[];
+    groupBy?: string;
+    onActivate?: (row: ExplorerRow) => void;
+    getDragPayload?: (row: ExplorerRow) => DragPayload | null | undefined;
+    emptyState?: ReactNode;
+    searchPlaceholder?: string;
+    searchable?: boolean;
+    query?: string;
+    pageSize?: number;
+    debounceMs?: number;
+    className?: string;
+    leftTab?: false | ExplorerContributionConfig;
+    panel?: false | ExplorerContributionConfig;
+    catalog?: false | ExplorerCatalogConfig;
+    source?: PanelConfig["source"];
+}
+
+export declare function createExplorerPlugin(options: CreateExplorerPluginOptions): WorkspaceFrontPlugin;
+
+export declare interface CreateExplorerPluginOptions extends CreateExplorerOutputsOptions {
+    pluginId?: string;
+}
+
+export declare function createShadcnTheme(options?: {
+    dark?: boolean;
+}): Extension[];
+
+export declare function createWorkspaceStore(options?: CreateWorkspaceStoreOptions): {
+    (): WorkspaceStore;
+    <U>(selector: (state: WorkspaceStore) => U): U;
+} & Omit<StoreApi_3<WorkspaceStore>, "setState" | "persist"> & {
+    setState(partial: WorkspaceStore | Partial<WorkspaceStore> | ((state: WorkspaceStore) => WorkspaceStore | Partial<WorkspaceStore>), replace?: false | undefined): unknown;
+    setState(state: WorkspaceStore | ((state: WorkspaceStore) => WorkspaceStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<PersistOptions<WorkspaceStore, {
+        layout: unknown;
+        sidebar: SidebarState;
+        panelSizes: Record<string, number>;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: WorkspaceStore) => void) => () => void;
+        onFinishHydration: (fn: (state: WorkspaceStore) => void) => () => void;
+        getOptions: () => Partial<PersistOptions<WorkspaceStore, {
+        layout: unknown;
+        sidebar: SidebarState;
+        panelSizes: Record<string, number>;
+        }, unknown>>;
+    };
+} & {
+    cleanup: () => void;
+};
+
+export declare interface CreateWorkspaceStoreOptions {
+    workspaceId?: string;
+    storageKey?: string;
+    persistenceEnabled?: boolean;
+    onLayoutVersionMismatch?: () => void;
+}
+
+export declare const DATA_CATALOG_DEFAULT_TOOL_NAME = "query_data_catalog";
+
+export declare const DATA_CATALOG_PLUGIN_ID = "data-catalog";
+
+export declare const DATA_CATALOG_ROW_SURFACE_KIND = "data-catalog.open-row";
+
+export declare function dataCatalogPanelInstanceId(rowId: string, prefix?: string): string;
+
+export declare interface DataCatalogResolvedQuery {
+    query?: string;
+    controlled: boolean;
+}
+
+export declare interface DataCatalogSelectContext {
+    params?: LeftTabParams;
+    bridge?: WorkspaceBridge;
+}
+
+export declare interface DataCatalogVisualizationParams {
+    row?: ExplorerRow;
+    query?: string;
+}
+
+export declare interface DataCatalogVisualizationState extends DataCatalogResolvedQuery {
+    row?: ExplorerRow;
+    title: string;
+}
+
+export declare function DataExplorer({ adapter, facets: facetConfigs, groupBy, onActivate, getDragPayload, emptyState, searchPlaceholder, searchable, query, pageSize, debounceMs, className, }: DataExplorerProps): JSX.Element;
+
+export declare type DataExplorerProps = {
+    adapter: ExplorerAdapter;
+    /** Facets shown in the toolbar popover. Adapter must implement fetchFacets for this to work. */
+    facets?: FacetConfig[];
+    /** Single grouping axis (must match a facet key). When set, renders tree mode. */
+    groupBy?: string;
+    /** Activated when a row is clicked, double-clicked, or Enter-pressed. */
+    onActivate?: (row: ExplorerRow) => void;
+    /** Returning a payload makes rows draggable. */
+    getDragPayload?: (row: ExplorerRow) => DragPayload | null | undefined;
+    /** Empty state shown when the top-level result has no rows and no query/filters. */
+    emptyState?: ReactNode;
+    searchPlaceholder?: string;
+    /** Hide the search input. Default true. */
+    searchable?: boolean;
+    /**
+     * Controlled query. When set, the toolbar's search input is hidden and the
+     * caller is responsible for supplying (and debouncing) the query value.
+     * Useful when an outer chrome already owns a search box.
+     */
+    query?: string;
+    /** Page size and debounce — passed through to useExplorerState. */
+    pageSize?: number;
+    debounceMs?: number;
+    className?: string;
+};
+
+export declare function defineFrontPlugin(spec: WorkspaceFrontPlugin): WorkspaceFrontPlugin;
+
+/**
+ * Identity helper for type-safe panel registration. Pure runtime
+ * passthrough — the value of this is forcing TypeScript to verify that
+ * the registered component accepts the params shape declared on the
+ * config. Without it, apps tend to widen `component` to
+ * `ComponentType<PaneProps<unknown>>` and lose the link.
+ *
+ * ```ts
+ * const editorPanel = definePanel<{ path: string }>({
+ *   id: "code-editor",
+ *   title: "Editor",
+ *   component: CodeEditorPane, // typechecked against PaneProps<{ path: string }>
+ *   placement: "center",
+ * })
+ * ```
+ */
+export declare function definePanel<T = unknown>(config: PanelConfig<T>): PanelConfig<T>;
+
+export { dismissToast }
+
+export declare interface DispatchContext {
+    /**
+     * Imperative handle to the workbench surface. Function (getter) so a
+     * late SurfaceShell mount, or any later swap, is picked up without
+     * restarting the transport. Returns null when the surface isn't ready.
+     */
+    surface: () => SurfaceShellApi | null;
+    /** Read the current open/closed state of the workbench pane. */
+    isWorkbenchOpen: () => boolean;
+    /** Toggle the workbench pane open. Must be a no-op when already open. */
+    openWorkbench: () => void;
+}
+
+export declare function DockviewShell({ layout, persistedLayout, onReady, onLayoutChange, allowedPanels, className, prefixHeaderActions, rightHeaderActions, watermarkComponent, }: DockviewShellProps): JSX.Element;
+
+export declare interface DockviewShellApi {
+    addPanel(groupId: string, config: {
+        id: string;
+        component: string;
+        title?: string;
+        params?: Record<string, unknown>;
+    }): void;
+    removePanel(panelId: string): void;
+    activatePanel(panelId: string): void;
+    movePanel(panelId: string, target: {
+        groupId: string;
+    } | {
+        direction: "left" | "right" | "above" | "below";
+        referencePanelId: string;
+    }): void;
+    updatePanelParams(panelId: string, params: Record<string, unknown>): void;
+    setPanelTitle(panelId: string, title: string): void;
+    findPanelsByParam(key: string, value: unknown): string[];
+    getActivePanel(): string | null;
+    toJSON(): SerializedLayout;
+}
+
+export declare interface DockviewShellProps {
+    layout: LayoutConfig;
+    persistedLayout?: SerializedLayout;
+    onReady?: (api: DockviewApi) => void;
+    onLayoutChange?: (layout: SerializedLayout) => void;
+    storageKey?: string;
+    allowedPanels?: string[];
+    className?: string;
+    /** Component rendered in the tab strip BEFORE the tabs. Useful for inline controls. */
+    prefixHeaderActions?: React.FunctionComponent<unknown>;
+    /** Component rendered in the tab strip on the far right. */
+    rightHeaderActions?: React.FunctionComponent<unknown>;
+    /** Component used as the empty-state watermark when a group has no panels. */
+    watermarkComponent?: React.FunctionComponent<unknown>;
+}
+
+export declare type DragPayload = {
+    mimeType: string;
+    value: string;
+};
+
+export declare interface DynamicPaneConfig {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+    title?: string;
+}
+
+export declare interface EditorLifecycleAdapter {
+    isDirty: () => boolean;
+    save: () => Promise<void>;
+    getContent: () => string;
+}
+
+export declare function emitAgentData(part: unknown): void;
+
+export declare function emitFilesystemAgentFileChange(part: unknown): void;
+
+export declare function EmptyPane({ className, onOpenFile }: EmptyPaneProps): JSX.Element;
+
+export declare interface EmptyPaneProps {
+    className?: string;
+    onOpenFile?: () => void;
+}
+
+/**
+ * Tiny typed event bus. ~30 lines, no runtime deps.
+ *
+ * Design constraints (locked by reviewer feedback in
+ * `docs/plans/UNIFIED_EVENT_BUS.md`):
+ *
+ * - Synchronous emit only. Slow subscribers fire-and-forget their own async work.
+ * - Snapshot listeners before iterating so subscribe / unsubscribe
+ *   during dispatch is safe.
+ * - One thrown listener does not stop the chain. Errors go to console.error.
+ * - Bus emits transitions only — no replay-on-subscribe.
+ */
+declare interface EventBus<TMap extends Record<string, any>> {
+    /** Subscribe to one event name. Returns an unsubscribe function. */
+    on<K extends keyof TMap>(name: K, fn: (payload: TMap[K]) => void): () => void;
+    /** Synchronously dispatch to every matching listener. */
+    emit<K extends keyof TMap>(name: K, payload: TMap[K]): void;
+    /** Test-only — never call from production code. Underscore-prefixed by convention. */
+    _reset(): void;
+}
+
+/** Common envelope on every payload. */
+export declare type EventMeta = Origin & {
+    ts: number;
+};
+
+export declare const events: EventBus<WorkspaceEventMap>;
+
+export declare const expandToFileSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+
+export declare const EXPLORER_PLUGIN_ID = "explorer";
+
+export declare type ExplorerAdapter = {
+    search(args: SearchArgs): Promise<SearchResult>;
+    /** Optional. When omitted, the explorer renders flat (no facet popover). */
+    fetchFacets?(args: FacetsArgs): Promise<Facets>;
+};
+
+declare type ExplorerAdapter_2 = {
+    search(args: SearchArgs_2): Promise<SearchResult_2>;
+    /** Optional. When omitted, the explorer renders flat (no facet popover). */
+    fetchFacets?(args: FacetsArgs_2): Promise<Facets_2>;
+};
+
+export declare interface ExplorerCatalogConfig {
+    id?: string;
+    label?: string;
+    onSelect?: (row: ExplorerRow) => void;
+}
+
+export declare interface ExplorerContributionConfig {
+    id?: string;
+    title?: string;
+    label?: string;
+    icon?: PanelConfig["icon"];
+}
+
+export declare type ExplorerMode = "flat" | "grouped" | "sectioned";
+
+export declare type ExplorerRow = {
+    id: string;
+    title: string;
+    /** Optional muted second line (truncates with title). */
+    subtitle?: string;
+    /** Group key — must match one of the facet values for `groupBy`. */
+    group?: string;
+    /** Leading mono chip (e.g. type code, frequency). */
+    leading?: Badge;
+    /** Trailing mono chips for status flags (e.g. [D] derived, [LIVE]). */
+    trailing?: Badge[];
+    /** Right-aligned plain text for numeric metadata (e.g. "1.2M", "2.4s"). */
+    meta?: string;
+};
+
+declare type ExplorerRow_2 = {
+    id: string;
+    title: string;
+    /** Optional muted second line (truncates with title). */
+    subtitle?: string;
+    /** Group key — must match one of the facet values for `groupBy`. */
+    group?: string;
+    /** Leading mono chip (e.g. type code, frequency). */
+    leading?: Badge_2;
+    /** Trailing mono chips for status flags (e.g. [D] derived, [LIVE]). */
+    trailing?: Badge_2[];
+    /** Right-aligned plain text for numeric metadata (e.g. "1.2M", "2.4s"). */
+    meta?: string;
+};
+
+export declare interface ExplorerSection {
+    id: string;
+    title: string;
+    subtitle?: string;
+    count?: number;
+    filters?: ExplorerSectionFilter[];
+    defaultExpanded?: boolean;
+}
+
+export declare interface ExplorerSectionFilter extends FacetConfig {
+    values?: FacetValue[];
+}
+
+export declare function ExplorerView(props: ExplorerViewProps): JSX.Element;
+
+export declare type ExplorerViewProps = (Omit<DataExplorerProps, "groupBy"> & {
+    mode?: "flat";
+    groupBy?: never;
+    sectionedAdapter?: never;
+}) | (DataExplorerProps & {
+    mode: "grouped";
+    groupBy: string;
+    sectionedAdapter?: never;
+}) | (Omit<SectionedExplorerProps, "adapter"> & {
+    mode: "sectioned";
+    adapter?: never;
+    sectionedAdapter: SectionedExplorerAdapter;
+    facets?: never;
+    groupBy?: never;
+});
+
+export declare type FacetConfig = {
+    /** Filter key sent to the adapter (e.g. "frequency"). */
+    key: string;
+    /** Display label (e.g. "Frequency"). */
+    label: string;
+    /** Explicit display order; unknown values go after in adapter order. */
+    order?: string[];
+    /** Display formatter for raw values (e.g. "M" → "Monthly"). */
+    formatValue?: (value: string) => string;
+};
+
+export declare type Facets = Record<string, FacetValue[]>;
+
+declare type Facets_2 = Record<string, FacetValue_2[]>;
+
+export declare type FacetsArgs = {
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+};
+
+declare type FacetsArgs_2 = {
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+};
+
+export declare type FacetValue = {
+    value: string;
+    count: number;
+};
+
+declare type FacetValue_2 = {
+    value: string;
+    count: number;
+};
+
+declare const FILESYSTEM_FILE_CHANGED_EVENT = "filesystem:file.changed";
+
+declare const FILESYSTEM_FILE_CREATED_EVENT = "filesystem:file.created";
+
+declare const FILESYSTEM_FILE_DELETED_EVENT = "filesystem:file.deleted";
+
+declare const FILESYSTEM_FILE_MOVED_EVENT = "filesystem:file.moved";
+
+export declare interface FilesystemEventMap {
+    [FILESYSTEM_FILE_MOVED_EVENT]: FilesystemEventMeta & {
+        from: string;
+        to: string;
+    };
+    [FILESYSTEM_FILE_DELETED_EVENT]: FilesystemEventMeta & {
+        path: string;
+    };
+    [FILESYSTEM_FILE_CREATED_EVENT]: FilesystemEventMeta & {
+        path: string;
+        kind: "file" | "dir";
+    };
+    [FILESYSTEM_FILE_CHANGED_EVENT]: FilesystemEventMeta & {
+        path: string;
+    };
+}
+
+export declare type FilesystemEventMeta = ({
+    cause: "user";
+} | {
+    cause: "agent";
+    toolCallId: string;
+} | {
+    cause: "remote";
+    toolCallId?: string;
+}) & {
+    ts: number;
+};
+
+export declare const filesystemEvents: {
+    readonly changed: "filesystem:file.changed";
+    readonly created: "filesystem:file.created";
+    readonly moved: "filesystem:file.moved";
+    readonly deleted: "filesystem:file.deleted";
+};
+
+export declare const filesystemPlugin: WorkspaceFrontPlugin;
+
+export declare function FileTree({ files, selectedPath, searchQuery, height, editing, revealPath, pendingPaths, onSelect, onExpand, onCollapse, onContextMenu, onSubmitEdit, onCancelEdit, onDragDrop, className, }: FileTreeProps): JSX.Element;
+
+declare interface FileTreeEditState {
+    /** Path of the row currently being edited (rename target or draft path). */
+    path: string;
+    /** When true, treat blank/Esc as cancel-without-error (new-file/folder flow). */
+    isDraft: boolean;
+    /** Pre-filled value (for rename). */
+    initialValue?: string;
+}
+
+export declare interface FileTreeNode {
+    name: string;
+    kind: "file" | "dir";
+    path: string;
+    children?: FileTreeNode[];
+    /**
+     * Internal: marks a placeholder row used for inline new-file/new-folder
+     * input. Consumers (FileTreeView) inject this when the user starts a
+     * create action; FileTree renders an <input> instead of a name.
+     */
+    isDraft?: boolean;
+}
+
+/**
+ * Default "Files" panel: `PanelChrome` + always-visible search input wired to
+ * `<FileTreeView>`. Drop into a dockview registry as-is, or compose
+ * `FileTreeView` directly when you want different chrome/search UX.
+ */
+export declare function FileTreePane({ params, rootDir, searchQuery: controlledSearchQuery, panelApi, bridge, api, chromeless, className, }: FileTreePaneProps): JSX.Element;
+
+declare interface FileTreePaneParams extends LeftTabParams {
+    rootDir?: string;
+    searchQuery?: string;
+    query?: string;
+    bridge?: unknown;
+    chromeless?: boolean;
+}
+
+export declare interface FileTreePaneProps extends Partial<PaneProps<FileTreePaneParams>> {
+    rootDir?: string;
+    searchQuery?: string;
+    panelApi?: DockviewPanelApi;
+    bridge?: WorkspaceBridge;
+    chromeless?: boolean;
+    className?: string;
+}
+
+export declare interface FileTreeProps {
+    files: FileTreeNode[];
+    selectedPath?: string | null;
+    searchQuery?: string;
+    height?: number;
+    /** Path of the row whose name should render as an <input>. */
+    editing?: FileTreeEditState | null;
+    /** Path that should be scrolled into view, opening parent folders if needed. */
+    revealPath?: string | null;
+    /** Paths currently being mutated — render a small spinner on those rows. */
+    pendingPaths?: ReadonlySet<string>;
+    onSelect?: (path: string) => void;
+    onExpand?: (path: string) => void;
+    onCollapse?: (path: string) => void;
+    onContextMenu?: (event: React.MouseEvent, node: FileTreeNode) => void;
+    onDragDrop?: (sourcePath: string, targetDirPath: string) => void;
+    /** Called when the user presses Enter on an inline-edit input. */
+    onSubmitEdit?: (path: string, value: string) => void;
+    /** Called when the user presses Esc or blurs without submitting. */
+    onCancelEdit?: () => void;
+    className?: string;
+}
+
+/**
+ * File tree with the full workbench actions: tracks container height,
+ * routes selects through `bridge.openFile`, and provides a right-click
+ * context menu (new file/folder, rename, delete, copy path) plus a
+ * delete-confirmation dialog.
+ *
+ * The chrome (PanelChrome, search input) is the consumer's responsibility.
+ * `FileTreePane` (below) is the default chromed wrapper for hosts that just
+ * want a "Files" panel; `WorkbenchLeftPane` uses this primitive directly to
+ * share its search input with the Data tab.
+ */
+export declare function FileTreeView({ rootDir, searchQuery, bridge, ignoreNames, className, }: FileTreeViewProps): JSX.Element;
+
+export declare interface FileTreeViewProps {
+    rootDir?: string;
+    /** Already-debounced query. Empty/undefined means no filter. */
+    searchQuery?: string;
+    bridge?: Pick<WorkspaceBridge, "openFile" | "getActiveFile" | "select">;
+    /**
+     * Names (or regex patterns) to hide from the tree. Defaults to
+     * `DEFAULT_TREE_IGNORE` (node_modules, .git, dist, …). Pass `[]` to
+     * show everything; pass your own array to override entirely. Patterns
+     * match on file/folder NAME, not the full path.
+     */
+    ignoreNames?: ReadonlyArray<string | RegExp>;
+    /** Forwarded to the inner <FileTree>. */
+    className?: string;
+}
+
+export declare function formatShortcut(binding: Pick<ShortcutBinding, "key" | "mod" | "shift">): string;
+
+export declare function getFileIcon(filename: string): LucideIcon;
+
+export declare interface GroupConfig {
+    id: string;
+    position: "left" | "center" | "right" | "bottom";
+    panel?: string;
+    params?: Record<string, unknown>;
+    locked?: boolean;
+    hideHeader?: boolean;
+    dynamic?: boolean;
+    placeholder?: string;
+    collapsible?: boolean;
+    collapsedWidth?: number;
+    constraints?: {
+        minWidth?: number;
+        maxWidth?: number;
+        maxWidthViewportRatio?: number;
+        minHeight?: number;
+        maxHeight?: number;
+    };
+}
+
+declare type GroupState = {
+    items: ExplorerRow[];
+    total: number;
+    hasMore: boolean;
+    loading: boolean;
+};
+
+export declare function IdeLayout(props: IdeLayoutProps): JSX.Element;
+
+export declare interface IdeLayoutProps {
+    sidebar?: string;
+    center?: string;
+    right?: string;
+    className?: string;
+}
+
+export declare type JSONSchema = Record<string, unknown>;
+
+export declare interface LayoutConfig {
+    version: string;
+    groups: GroupConfig[];
+}
+
+export declare type LeftTabComponent = ComponentType<PaneProps<LeftTabParams>>;
+
+export declare interface LeftTabOutput<T = LeftTabParams> {
+    type: "left-tab";
+    id: string;
+    title: string;
+    icon?: PanelConfig<T>["icon"];
+    component: PanelConfig<T>["component"];
+    lazy?: PanelConfig<T>["lazy"];
+    requiresCapabilities?: PanelConfig<T>["requiresCapabilities"];
+    source?: PanelConfig<T>["source"];
+    chromeless?: PanelConfig<T>["chromeless"];
+}
+
+export declare interface LeftTabParams {
+    rootDir?: string;
+    query?: string;
+    searchQuery?: string;
+    bridge?: unknown;
+    chromeless?: boolean;
+}
+
+export declare function MarkdownEditor({ content, onChange, readOnly, placeholder, className, }: MarkdownEditorProps): JSX.Element;
+
+export declare function MarkdownEditorPane({ params, api, className }: MarkdownEditorPaneProps): JSX.Element;
+
+export declare type MarkdownEditorPaneProps = PaneProps<{
+    path?: string;
+}>;
+
+export declare interface MarkdownEditorProps {
+    content: string;
+    onChange?: (content: string) => void;
+    readOnly?: boolean;
+    placeholder?: string;
+    className?: string;
+}
+
+export declare const MAX_PANELS = 50;
+
+export declare const navigateToLineSchema: z.ZodObject<{
+    file: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    line: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    line: number;
+    file: string;
+}, {
+    line: number;
+    file: string;
+}>;
+
+declare interface Notification_2 {
+    id: string;
+    message: string;
+    type: "info" | "warning" | "error";
+    timestamp: number;
+}
+export { Notification_2 as Notification }
+
+export declare const notificationSchema: z.ZodObject<{
+    msg: z.ZodString;
+    level: z.ZodOptional<z.ZodEnum<["info", "warn", "error"]>>;
+}, "strip", z.ZodTypeAny, {
+    msg: string;
+    level?: "error" | "info" | "warn" | undefined;
+}, {
+    msg: string;
+    level?: "error" | "info" | "warn" | undefined;
+}>;
+
+/** Subscribe to file-changed events. Returns the unsubscribe function. */
+export declare function onFilesystemChanged(handler: (payload: FilesystemEventMeta & {
+    path: string;
+}) => void): () => void;
+
+export declare type OpenArtifactHandler = (path: string) => void;
+
+export declare function openDataCatalogVisualization(row: ExplorerRow, options: OpenDataCatalogVisualizationOptions): void;
+
+export declare interface OpenDataCatalogVisualizationOptions {
+    catalogId: string;
+    surfaceKind?: string;
+    title?: string;
+    params?: Record<string, unknown>;
+}
+
+export declare const openFileSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    mode: z.ZodOptional<z.ZodEnum<["view", "edit", "diff"]>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    mode?: "view" | "edit" | "diff" | undefined;
+}, {
+    path: string;
+    mode?: "view" | "edit" | "diff" | undefined;
+}>;
+
+export declare interface OpenPanelConfig {
+    /** Panel instance id. If a panel with this id is already open, it's re-activated instead of duplicated. */
+    id: string;
+    /** Registered component id (must match a `PanelConfig.id` in WorkspaceProvider's panel registry). */
+    component: string;
+    /** Tab title. Defaults to `id`. */
+    title?: string;
+    /** Arbitrary params passed to the pane component. */
+    params?: Record<string, unknown>;
+}
+
+export declare const openPanelSchema: z.ZodObject<{
+    id: z.ZodString;
+    component: z.ZodString;
+    params: z.ZodEffects<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>, Record<string, unknown> | undefined, Record<string, unknown> | undefined>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    component: string;
+    title?: string | undefined;
+    params?: Record<string, unknown> | undefined;
+}, {
+    id: string;
+    component: string;
+    title?: string | undefined;
+    params?: Record<string, unknown> | undefined;
+}>;
+
+/**
+ * Discriminated origin metadata. Encoded as a union (rather than a
+ * flat `cause` + optional `toolCallId`) so the type system enforces
+ * that agent-originated events always carry a tool call id.
+ */
+export declare type Origin = {
+    cause: "user";
+} | {
+    cause: "agent";
+    toolCallId: string;
+}
+/**
+* Anything observed via the server-side fs watcher: a collaborator
+* editing the same workspace, a git pull, an external editor, the
+* agent in another tab. Carries the tool call id ONLY when the
+* server can attribute the change (sandbox emits its own writes
+* with attribution; chokidar can't). Consumers that want to
+* suppress UX side-effects on self-echo compare `actorClientId` (a
+* future field) against their own.
+*/
+| {
+    cause: "remote";
+    toolCallId?: string;
+};
+
+export declare interface PanelConfig<T = any> {
+    id: string;
+    title: string;
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** Placement hint: "left" | "center" | "right" | "bottom" | "left-tab" | "right-tab" */
+    placement?: string;
+    requiresCapabilities?: string[];
+    essential?: boolean;
+    chromeless?: boolean;
+    /** Source: "builtin" | "app" */
+    source?: string;
+    pluginId?: string;
+    /**
+     * Whether to wrap the component with React.lazy + Suspense. Omit to let
+     * the registry auto-detect: zero-arg functions (factories) are treated as
+     * lazy; components that accept a props argument are treated as eager.
+     */
+    lazy?: boolean;
+    component: ComponentType<PaneProps<T>> | (() => Promise<{
+        default: ComponentType<PaneProps<T>>;
+    }>);
+}
+
+export declare class PanelErrorBoundary extends Component<PanelErrorBoundaryProps, State_2> {
+    state: State_2;
+    static getDerivedStateFromError(error: Error): State_2;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    handleRetry: () => void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+}
+
+export declare interface PanelErrorBoundaryProps {
+    panelId: string;
+    onError?: (data: {
+        panelId: string;
+        error: string;
+        stack?: string;
+    }) => void;
+    children: ReactNode;
+}
+
+export declare interface PanelLifecycleApi {
+    panelId: string;
+    title: string;
+    setTitle(title: string): void;
+    close(): void;
+    focus(): void;
+    isActive: boolean;
+}
+
+export declare interface PanelOutput<T = any> {
+    type: "panel";
+    panel: PanelConfig<T>;
+}
+
+export declare type PanelRegistration<T = any> = Omit<PanelConfig<T>, 'id'>;
+
+export declare class PanelRegistry {
+    private panels;
+    private registrationOrder;
+    private capabilities;
+    private listeners;
+    private snapshotCache;
+    constructor(capabilities?: Record<string, boolean>);
+    register(id: string, config: PanelRegistration): void;
+    unregisterByPluginId(pluginId: string): void;
+    get(id: string): PanelConfig | undefined;
+    has(id: string): boolean;
+    list(): PanelConfig[];
+    getComponents(): Record<string, ComponentType<any>>;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly PanelConfig[];
+    private emit;
+    private filteredPanels;
+    private satisfiesCapabilities;
+}
+
+export declare interface PanelRegistryLike {
+    register(id: string, config: PanelRegistration): void;
+}
+
+export declare interface PanelState {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+    groupId?: string;
+    essential?: boolean;
+}
+
+/**
+ * Unified prop shape for panel components rendered inside DockviewShell.
+ *
+ * Structurally mirrors dockview's `IDockviewPanelProps<T>` so dockview
+ * can render registered components directly — no wrapper, no field
+ * renaming, no `as` casts. We re-state the shape (rather than re-export
+ * dockview's type) so the workspace package owns its public contract:
+ * if dockview's type ever drifts, only the wiring inside DockviewShell
+ * needs to change.
+ *
+ * Use {@link definePanel} for type-safe registration.
+ *
+ * @typeParam T - Shape of the panel-specific `params` payload. Defaults
+ *   to `unknown` because layouts restored from JSON are inherently
+ *   un-typed at runtime; use a generic param when you control the
+ *   addPanel call site, otherwise read defensively.
+ */
+export declare interface PaneProps<T = unknown> {
+    /** App-supplied data for this panel instance (e.g. `{ path: string }`). */
+    params: T;
+    /** Per-panel control surface (close, setActive, setTitle, …). */
+    api: DockviewPanelApi;
+    /** Top-level dockview API (groups, addPanel, removePanel, fromJSON, …). */
+    containerApi: DockviewApi;
+    /** Optional className forwarded to the pane's root element. */
+    className?: string;
+}
+
+export declare type PluginBinding = ComponentType<unknown>;
+
+export declare interface PluginContributionError {
+    kind: "contribution";
+    pluginId: string;
+    contributionKind: "panel" | "catalog-row" | "chat-suggestion";
+    contributionId?: string;
+    error: Error;
+    componentStack?: string | null;
+}
+
+export declare class PluginError extends Error {
+    readonly kind: PluginErrorKind;
+    constructor(kind: PluginErrorKind, message: string);
+}
+
+export declare class PluginErrorBoundary extends Component<Props, State> {
+    static contextType: Context<PluginErrorContextValue | null>;
+    context: React.ContextType<typeof PluginErrorContext>;
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | JSX.Element | null | undefined;
+}
+
+declare const PluginErrorContext: Context<PluginErrorContextValue | null>;
+
+declare interface PluginErrorContextValue {
+    errors: PluginContributionError[];
+    reportPluginError: (error: PluginContributionError) => void;
+}
+
+export declare type PluginErrorKind = "validation" | "duplicate-id" | "mount" | "contribution";
+
+export declare function PluginErrorProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+export declare type PluginOutput = LeftTabOutput | PanelOutput | CommandOutput | CatalogOutput | BindingOutput | ProviderOutput | SurfaceResolverOutput | AgentToolOutput;
+
+export declare type PluginProvider = ComponentType<PluginProviderProps>;
+
+export declare interface PluginProviderProps {
+    apiBaseUrl: string;
+    authHeaders?: Record<string, string>;
+    onAuthError?: (statusCode: number) => void;
+    apiTimeout?: number;
+    children: ReactNode;
+}
+
+export declare function postUiCommand(command: UiCommand): void;
+
+declare interface Props {
+    pluginId: string;
+    contributionKind: "panel" | "catalog-row" | "chat-suggestion";
+    contributionId?: string;
+    children?: ReactNode;
+}
+
+export declare interface ProviderOutput {
+    type: "provider";
+    id: string;
+    component: PluginProvider;
+}
+
+export declare function readDataCatalogRow(value: unknown): ExplorerRow | undefined;
+
+declare interface RegisteredPluginMeta {
+    id: string;
+    label?: string;
+    systemPrompt?: string;
+}
+
+export declare function RegistryProvider({ panelRegistry, commandRegistry, catalogRegistry, surfaceResolverRegistry, children, }: RegistryProviderProps): JSX.Element;
+
+declare interface RegistryProviderProps {
+    panelRegistry: PanelRegistry;
+    commandRegistry: CommandRegistry;
+    catalogRegistry?: CatalogRegistry;
+    surfaceResolverRegistry?: SurfaceResolverRegistry;
+    children: ReactNode;
+}
+
+export declare function resolveDataCatalogControlledQuery(params: LeftTabParams | DataCatalogVisualizationParams | undefined): DataCatalogResolvedQuery;
+
+export declare function resolveDataCatalogQuery(params: LeftTabParams | DataCatalogVisualizationParams | undefined): string | undefined;
+
+export declare function resolveDataCatalogVisualizationState(params: DataCatalogVisualizationParams | undefined, fallbackTitle: string): DataCatalogVisualizationState;
+
+export declare function ResponsiveDockviewShell({ layout, className, }: ResponsiveDockviewShellProps): JSX.Element;
+
+export declare interface ResponsiveDockviewShellProps {
+    layout: LayoutConfig;
+    className?: string;
+}
+
+export declare type SearchArgs = {
+    query: string;
+    filters: Record<string, string[]>;
+    /** Scope to a single group's value (only set when paginating inside a group). */
+    group?: {
+        key: string;
+        value: string;
+    };
+    limit: number;
+    offset: number;
+    signal?: AbortSignal;
+};
+
+declare type SearchArgs_2 = {
+    query: string;
+    filters: Record<string, string[]>;
+    /** Scope to a single group's value (only set when paginating inside a group). */
+    group?: {
+        key: string;
+        value: string;
+    };
+    limit: number;
+    offset: number;
+    signal?: AbortSignal;
+};
+
+export declare type SearchResult = {
+    items: ExplorerRow[];
+    /** Total count for the current scope (query + filters + optional group). */
+    total: number;
+    hasMore: boolean;
+};
+
+declare type SearchResult_2 = {
+    items: ExplorerRow_2[];
+    /** Total count for the current scope (query + filters + optional group). */
+    total: number;
+    hasMore: boolean;
+};
+
+export declare interface SectionedExplorerAdapter {
+    sections(args: SectionedExplorerSectionsArgs): Promise<ExplorerSection[]>;
+    searchSection(sectionId: string, args: SectionedExplorerSearchArgs): Promise<SearchResult>;
+    fetchSectionFacets?(sectionId: string, args: SectionedExplorerFacetArgs): Promise<Facets>;
+}
+
+export declare interface SectionedExplorerFacetArgs {
+    query: string;
+    globalFilters: Record<string, string[]>;
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+}
+
+export declare interface SectionedExplorerProps {
+    adapter: SectionedExplorerAdapter;
+    onActivate?: (row: ExplorerRow) => void;
+    getDragPayload?: (row: ExplorerRow) => DragPayload | null | undefined;
+    emptyState?: ReactNode;
+    searchPlaceholder?: string;
+    searchable?: boolean;
+    query?: string;
+    pageSize?: number;
+    className?: string;
+}
+
+export declare interface SectionedExplorerSearchArgs {
+    query: string;
+    globalFilters: Record<string, string[]>;
+    filters: Record<string, string[]>;
+    limit: number;
+    offset: number;
+    signal?: AbortSignal;
+}
+
+export declare interface SectionedExplorerSectionsArgs {
+    query: string;
+    globalFilters: Record<string, string[]>;
+    signal?: AbortSignal;
+}
+
+export declare type SerializedLayout = Parameters<DockviewApi["fromJSON"]>[0];
+
+export declare function SessionBrowser({ sessions, activeId, onSwitch, onCreate, onDelete, onClose, className, }: SessionBrowserProps): JSX.Element;
+
+export declare interface SessionBrowserProps {
+    sessions: SessionItem[];
+    activeId?: string | null;
+    onSwitch?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onClose?: () => void;
+    className?: string;
+}
+
+export declare interface SessionItem {
+    id: string;
+    title: string;
+    updatedAt?: string | number;
+}
+
+export declare function SessionList({ sessions, activeId, onSwitch, onCreate, onDelete, className, }: SessionListProps): JSX.Element;
+
+export declare interface SessionListProps {
+    sessions: SessionItem[];
+    activeId?: string | null;
+    onSwitch?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onRename?: (id: string, newTitle: string) => void;
+    className?: string;
+}
+
+export declare interface ShortcutBinding {
+    key: string;
+    mod?: boolean;
+    shift?: boolean;
+    allowInEditable?: boolean;
+    handler: () => void;
+}
+
+export declare interface SidebarState {
+    collapsed: boolean;
+    width: number;
+}
+
+declare interface State {
+    error: Error | null;
+}
+
+declare interface State_2 {
+    hasError: boolean;
+    error: Error | null;
+}
+
+declare type StoreApi = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prev: WorkspaceStore) => void) => () => void;
+};
+
+declare type StoreApi_2 = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prev: WorkspaceStore) => void) => () => void;
+};
+
+export declare interface SurfaceOpenRequest {
+    kind: string;
+    target: string;
+    meta?: Record<string, unknown>;
+}
+
+export declare interface SurfacePanelResolution {
+    component: string;
+    id?: string;
+    title?: string;
+    params?: Record<string, unknown>;
+    score?: number;
+}
+
+export declare interface SurfaceResolverConfig {
+    id: string;
+    resolve: (request: SurfaceOpenRequest) => SurfacePanelResolution | undefined;
+    source?: string;
+    pluginId?: string;
+}
+
+export declare interface SurfaceResolverOutput {
+    type: "surface-resolver";
+    resolver: SurfaceResolverConfig;
+}
+
+export declare type SurfaceResolverRegistration = Omit<SurfaceResolverConfig, "id">;
+
+export declare class SurfaceResolverRegistry {
+    private resolvers;
+    private registrationOrder;
+    private listeners;
+    private snapshotCache;
+    register(id: string, config: SurfaceResolverRegistration): void;
+    unregisterByPluginId(pluginId: string): void;
+    get(id: string): SurfaceResolverConfig | undefined;
+    has(id: string): boolean;
+    list(): SurfaceResolverConfig[];
+    resolve(request: SurfaceOpenRequest): SurfacePanelResolution | undefined;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly SurfaceResolverConfig[];
+    private emit;
+}
+
+export declare interface SurfaceResolverRegistryLike {
+    register(id: string, config: SurfaceResolverRegistration): void;
+}
+
+export declare function SurfaceShell({ rootDir, sidebarDefaultWidth, sidebarMinWidth, sidebarMaxWidth, storageKey, onReady, onChange, onClose, extraPanels, className, }: SurfaceShellProps): JSX.Element;
+
+export declare interface SurfaceShellApi {
+    /** Open a file in the workbench. Idempotent — re-activates an existing pane for the same path. */
+    openFile: (path: string) => void;
+    /** Open a plugin-defined surface target through the registered surface resolvers. */
+    openSurface: (request: SurfaceOpenRequest) => void;
+    /**
+     * Open a non-file pane in the workbench. Idempotent on `id` —
+     * re-activates an existing panel with the same id rather than duplicating.
+     * Use this for app-specific panes (charts, dashboards, log viewers, …) that
+     * aren't anchored to a filesystem path.
+     */
+    openPanel: (config: OpenPanelConfig) => void;
+    /** Hide the workbench's left sources/files pane while leaving the workbench open. */
+    closeWorkbenchLeftPane: () => void;
+    /** Current snapshot of open tabs + active tab. */
+    getSnapshot: () => SurfaceShellSnapshot;
+}
+
+export declare interface SurfaceShellProps {
+    rootDir?: string;
+    sidebarDefaultWidth?: number;
+    sidebarMinWidth?: number;
+    sidebarMaxWidth?: number;
+    storageKey?: string;
+    /** Called once when the surface dockview becomes ready, with an imperative handle. */
+    onReady?: (api: SurfaceShellApi) => void;
+    /** Called on every panel add/remove/active-change with the current snapshot. */
+    onChange?: (snapshot: SurfaceShellSnapshot) => void;
+    /** Optional close action for hosts that model the workbench as collapsible. */
+    onClose?: () => void;
+    /**
+     * Extra panel ids (registered via WorkspaceProvider's `panels` prop) that
+     * this workbench is allowed to render. Defaults to the built-in
+     * editor/viewer panels only. Pass app-specific pane ids here so calls
+     * like `surface.openPanel({ component: "chart-canvas" })` actually
+     * instantiate — without this, dockview's components map filters them
+     * out and you get an empty tab. Two-layer defense: SurfaceShell.openPanel
+     * validates against the registry (loud throw on unknown), AND the
+     * dockview allowlist below filters which registered panels can mount
+     * inside THIS surface (so a host can gate panels per shell instance).
+     */
+    extraPanels?: string[];
+    className?: string;
+}
+
+export declare interface SurfaceShellSnapshot {
+    openTabs: SurfaceShellTab[];
+    activeTab: string | null;
+}
+
+export declare interface SurfaceShellTab {
+    id: string;
+    title: string;
+    params?: Record<string, unknown>;
+}
+
+export declare function ThemeProvider({ children, defaultTheme, onThemeChange }: ThemeProviderProps): JSX.Element;
+
+export declare interface ThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: "light" | "dark";
+    onThemeChange?: (theme: "light" | "dark") => void;
+}
+
+export { toast }
+
+export { ToastApi }
+
+export { Toaster }
+
+export { ToasterProps }
+
+export { ToastInput }
+
+export { ToastRecord }
+
+export { ToastVariant }
+
+export declare interface ToolExecContext {
+    abortSignal: AbortSignal;
+    toolCallId: string;
+    onUpdate?: (partial: string) => void;
+}
+
+export declare interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+    details?: unknown;
+}
+
+export declare function TopBar({ appTitle, sessionTitle, onCommandPalette, onNewChat, topBarLeft, topBarRight, className, }: TopBarProps): JSX.Element;
+
+export declare interface TopBarProps {
+    appTitle?: string;
+    sessionTitle?: string;
+    onCommandPalette?: () => void;
+    onNewChat?: () => void;
+    /** Override the brand/title block on the left. Hosts pass workspace
+     *  switchers, breadcrumbs, etc. here. When set, the default
+     *  `[B] appTitle / sessionTitle` block is replaced entirely. */
+    topBarLeft?: ReactNode;
+    /** Override the avatar on the right. The new-chat (+) button stays —
+     *  it's session-mechanic, not host chrome. Hosts pass theme toggles,
+     *  user menus, etc. here. */
+    topBarRight?: ReactNode;
+    className?: string;
+}
+
+export declare interface UiCommand {
+    v?: number;
+    seq?: number;
+    kind: string;
+    params: Record<string, unknown>;
+}
+
+export declare interface UIStatePut {
+    v: 1;
+    causedBy: CausedBy;
+    openPanels: PanelState[];
+    activePanel: string | null;
+    activeFile: string | null;
+    visibleFiles: string[];
+    dirtyFiles: string[];
+}
+
+export declare type Unsubscribe = () => void;
+
+export declare function useActiveFile(): string | null;
+
+export declare function useActivePanel(): string | null;
+
+export declare function useActivePanels(): readonly PanelConfig[];
+
+export declare function useArtifactPanels(surfaceApi: DockviewShellApi | null): UseArtifactPanelsReturn;
+
+export declare interface UseArtifactPanelsReturn {
+    panels: ArtifactPanel[];
+    open: (panel: ArtifactPanel) => void;
+    close: (panelId: string) => void;
+    activate: (panelId: string) => void;
+    isOpen: (panelId: string) => boolean;
+}
+
+export declare function useArtifactRouting(artifactPanels: UseArtifactPanelsReturn, opts?: UseArtifactRoutingOptions): UseArtifactRoutingReturn;
+
+export declare interface UseArtifactRoutingOptions {
+    toolPanelMap?: Record<string, string>;
+}
+
+export declare interface UseArtifactRoutingReturn {
+    openForTool: (toolName: string, params: {
+        path: string;
+        [key: string]: unknown;
+    }) => void;
+    resolvePanel: (toolName: string) => string | undefined;
+}
+
+export declare function useAutoOpenAgentFiles(onOpen: (path: string) => void, options?: UseAutoOpenAgentFilesOptions): void;
+
+export declare interface UseAutoOpenAgentFilesOptions {
+    skip?: (path: string) => boolean;
+    filesOnly?: boolean;
+}
+
+export declare function useCatalogRegistry(): CatalogRegistry;
+
+export declare function useCatalogs(): readonly CatalogConfig[];
+
+export declare function useCommandRegistry(): CommandRegistry;
+
+export declare function useCommands(): readonly CommandConfig[];
+
+export declare function useDataCatalogOpenVisualization(options: OpenDataCatalogVisualizationOptions): (row: ExplorerRow) => void;
+
+export declare function useDataCatalogQuery(params: LeftTabParams | DataCatalogVisualizationParams | undefined): DataCatalogResolvedQuery;
+
+export declare function useDataCatalogVisualizationState(params: DataCatalogVisualizationParams | undefined, fallbackTitle: string): DataCatalogVisualizationState;
+
+export declare function useDirtyFiles(): Record<string, {
+    panelId: string;
+    savedAt: number | null;
+}>;
+
+export declare function useDockviewApi(): DockviewShellApi;
+
+export declare function useEditorLifecycle(path: string | null, opts: UseEditorLifecycleOptions): UseEditorLifecycleReturn;
+
+export declare interface UseEditorLifecycleOptions {
+    adapter: EditorLifecycleAdapter | null;
+    panelId: string;
+    onDirtyChange?: (path: string, dirty: boolean) => void;
+    serverMtime?: number | null;
+}
+
+export declare interface UseEditorLifecycleReturn {
+    isDirty: boolean;
+    isSaving: boolean;
+    lastSavedAt: number | null;
+    markDirty: () => void;
+    flushSave: () => Promise<void>;
+    shouldSync: boolean;
+    ackSync: () => void;
+    /** True when the file was modified externally while the editor has unsaved changes. */
+    externalChangeWhileDirty: boolean;
+    ackExternalChange: () => void;
+    /** Call after a successful save with the mtime the server returned. */
+    notifySaved: (mtime: number) => void;
+}
+
+/**
+ * React hook: subscribe to a workspace event for the lifetime of the
+ * component. The handler ref is stable across renders so changing the
+ * handler doesn't tear down and re-subscribe.
+ */
+export declare function useEvent<K extends keyof WorkspaceEventMap>(name: K, handler: (payload: WorkspaceEventMap[K]) => void): void;
+
+export declare function useExplorerState(options: UseExplorerStateOptions): {
+    query: string;
+    filters: Record<string, string[]>;
+    facets: Facets | null;
+    topItems: ExplorerRow[];
+    topTotal: number;
+    topHasMore: boolean;
+    loading: boolean;
+    getGroup: (value: string) => GroupState;
+    isExpanded: (value: string) => boolean;
+    setQuery: (q: string) => void;
+    toggleFilter: (key: string, value: string) => void;
+    clearFilters: () => void;
+    expandGroup: (value: string) => void;
+    collapseGroup: (value: string) => void;
+    loadMoreTop: () => void;
+    loadMoreGroup: (value: string) => void;
+};
+
+export declare type UseExplorerStateOptions = {
+    adapter: ExplorerAdapter;
+    /** Facets shown in the toolbar popover. Adapter must implement fetchFacets. */
+    facets?: FacetConfig[];
+    /** Facet key used as the single grouping axis (tree mode). */
+    groupBy?: string;
+    /** Page size for both top-level and per-group pagination. */
+    pageSize?: number;
+    /** Debounce window (ms) applied to setQuery. */
+    debounceMs?: number;
+    /**
+     * Controlled query. When set, the hook bypasses internal debounce and
+     * `setQuery` becomes a no-op — the caller owns the value (and any debounce
+     * the caller wants to apply). Searches re-run when this prop changes.
+     */
+    query?: string;
+};
+
+export declare type UseExplorerStateReturn = ReturnType<typeof useExplorerState>;
+
+export declare function useHydrationComplete(): boolean;
+
+export declare function useKeyboardShortcuts({ shortcuts, enabled }: UseKeyboardShortcutsOptions): void;
+
+export declare interface UseKeyboardShortcutsOptions {
+    shortcuts: ShortcutBinding[];
+    enabled?: boolean;
+}
+
+export declare function useOpenPanels(): PanelState[];
+
+export declare function usePluginErrors(): PluginErrorContextValue;
+
+export declare function useRegistry(): PanelRegistry;
+
+export declare function useResetLayout(): () => void;
+
+export declare function useResponsiveSidebarCollapse({ isNarrowViewport, isCollapsed, setCollapsed, }: UseResponsiveSidebarCollapseOptions): () => void;
+
+export declare interface UseResponsiveSidebarCollapseOptions {
+    isNarrowViewport: boolean;
+    isCollapsed: boolean;
+    setCollapsed: (collapsed: boolean) => void;
+}
+
+/** Helper for emitting a user-originated event payload. */
+export declare function userMeta(): {
+    cause: "user";
+    ts: number;
+};
+
+export declare function useSetSidebar(): (sidebar: Partial<SidebarState>) => void;
+
+export declare function useSidebarState(): SidebarState;
+
+export declare function useSurfaceResolverRegistry(): SurfaceResolverRegistry;
+
+export declare function useTheme(): {
+    theme: "light" | "dark";
+    setTheme: (theme: "light" | "dark") => void;
+    toggleTheme: () => void;
+};
+
+export declare function useThemePreference(): "light" | "dark";
+
+export declare function useViewportBreakpoint(maxWidth?: number): boolean;
+
+export declare function useWorkspaceBridge(): WorkspaceBridgeContextValue;
+
+export declare function useWorkspaceChatPanel(): WorkspaceChatPanelComponent;
+
+export declare function useWorkspaceContext(): WorkspaceContextValue;
+
+export declare function useWorkspaceContextOptional(): WorkspaceContextValue | null;
+
+export declare function WorkbenchLeftPane({ rootDir, bridge, defaultTab, onCollapse, className, }: WorkbenchLeftPaneProps): JSX.Element;
+
+export declare interface WorkbenchLeftPaneProps {
+    rootDir?: string;
+    bridge?: WorkspaceBridge;
+    defaultTab?: WorkbenchLeftTabId;
+    onCollapse?: () => void;
+    className?: string;
+}
+
+export declare type WorkbenchLeftTabId = string;
+
+declare const WORKSPACE_AGENT_DATA_EVENT = "workspace:agent.data";
+
+declare const WORKSPACE_EDITOR_SAVE_END_EVENT = "workspace:editor.save.end";
+
+declare const WORKSPACE_EDITOR_SAVE_START_EVENT = "workspace:editor.save.start";
+
+export declare const WORKSPACE_OPEN_PATH_SURFACE_KIND = "workspace.open.path";
+
+declare const WORKSPACE_PANEL_CLOSE_EVENT = "workspace:panel.close";
+
+declare const WORKSPACE_PANEL_UPDATE_EVENT = "workspace:panel.update";
+
+declare const WORKSPACE_UI_COMMAND_EVENT = "workspace:ui.command";
+
+export declare interface WorkspaceActions {
+    setHydrationComplete: (complete: boolean) => void;
+    setLayout: (layout: unknown) => void;
+    setSidebar: (sidebar: Partial<SidebarState>) => void;
+    setPanelSize: (panelId: string, size: number) => void;
+    setTheme: (theme: "light" | "dark") => void;
+    openPanel: (panel: PanelState) => void;
+    closePanel: (panelId: string) => void;
+    activatePanel: (panelId: string) => void;
+    openFile: (file: string, panelId?: string) => void;
+    markDirty: (file: string, panelId: string) => void;
+    markClean: (file: string) => void;
+    showNotification: (notification: Omit<Notification_2, "id" | "timestamp">) => void;
+    dismissNotification: (id: string) => void;
+    navigateToLine: (file: string, line: number) => void;
+    resetLayout: () => void;
+}
+
+export declare interface WorkspaceBridge {
+    getOpenPanels(): PanelState[];
+    getActiveFile(): string | null;
+    getDirtyFiles(): string[];
+    getVisibleFiles(): string[];
+    openFile(path: string, opts?: {
+        mode?: "view" | "edit" | "diff";
+    }): Promise<CommandResult>;
+    openPanel(config: DynamicPaneConfig): Promise<CommandResult>;
+    closePanel(id: string): Promise<CommandResult>;
+    closeWorkbenchLeftPane(): Promise<CommandResult>;
+    showNotification(msg: string, level?: "info" | "warn" | "error"): Promise<CommandResult>;
+    navigateToLine(file: string, line: number): Promise<CommandResult>;
+    expandToFile(path: string): Promise<CommandResult>;
+    markDirty(path: string): void;
+    markClean(path: string): void;
+    subscribe<K extends keyof BridgeEventMap>(event: K, handler: (data: BridgeEventMap[K]) => void): Unsubscribe;
+    select<T>(selector: (state: WorkspaceState) => T, handler: (value: T) => void): Unsubscribe;
+}
+
+export declare interface WorkspaceBridgeContextValue {
+    connected: boolean;
+}
+
+export declare type WorkspaceChatPanelComponent = ComponentType<any>;
+
+export declare interface WorkspaceChatPanelProps {
+    sessionId: string;
+    onData?: (part: unknown) => void;
+    requestHeaders?: Record<string, string>;
+    onOpenArtifact?: OpenArtifactHandler;
+    className?: string;
+    /** Endpoint base for agent → visible-workbench UI commands. */
+    bridgeEndpoint?: string | null;
+    /** Imperative handle getter for the visible workbench surface. */
+    getSurface?: () => SurfaceShellApi | null;
+    /** Reads whether the visible workbench surface should be open. */
+    isWorkbenchOpen?: () => boolean;
+    /** Opens the visible workbench surface before dispatching a command. */
+    openWorkbench?: () => void;
+    [key: string]: unknown;
+}
+
+export declare interface WorkspaceContextValue {
+    chatPanel: WorkspaceChatPanelComponent | null;
+    registeredPlugins: RegisteredPluginMeta[];
+}
+
+export declare interface WorkspaceEventMap extends WorkspaceHostEventMap, WorkspacePluginEventMap {
+}
+
+/** Names that share a prefix can be filtered with `startsWith`. */
+export declare type WorkspaceEventName = keyof WorkspaceEventMap;
+
+export declare interface WorkspaceFrontPlugin {
+    id: string;
+    label?: string;
+    /**
+     * Context prepended to the agent's system prompt at boot. Concatenated
+     * across all registered plugins (in registration order) and joined with
+     * double-newlines. Plain Markdown. ~200-500 chars recommended.
+     */
+    systemPrompt?: string;
+    panels?: PanelConfig[];
+    commands?: CommandConfig[];
+    catalogs?: CatalogConfig[];
+    bindings?: PluginBinding[];
+    /**
+     * @deprecated Executable agent tools should be contributed by server
+     * plugins. This field remains for migration only.
+     */
+    agentTools?: AgentTool[];
+    outputs?: PluginOutput[];
+}
+
+declare interface WorkspaceHostEventMap {
+    /** Shared UI manipulation contract used by the agent stream and plugin bindings. */
+    [WORKSPACE_UI_COMMAND_EVENT]: EventMeta & {
+        command: UiCommand;
+    };
+    [WORKSPACE_EDITOR_SAVE_START_EVENT]: {
+        panelId: string;
+    };
+    [WORKSPACE_EDITOR_SAVE_END_EVENT]: {
+        panelId: string;
+        ok?: boolean;
+        error?: string;
+    };
+    [WORKSPACE_PANEL_UPDATE_EVENT]: EventMeta & {
+        match: WorkspacePanelMatch | WorkspacePanelMatch[];
+        params?: Record<string, unknown>;
+        title?: string;
+    };
+    [WORKSPACE_PANEL_CLOSE_EVENT]: EventMeta & {
+        match: WorkspacePanelMatch | WorkspacePanelMatch[];
+    };
+    /**
+     * Raw agent stream data observed by ChatPanelHost. Core treats this as an
+     * opaque packet; plugins translate packets they understand into their own
+     * plugin-keyed events.
+     */
+    [WORKSPACE_AGENT_DATA_EVENT]: {
+        ts: number;
+        part: unknown;
+    };
+}
+
+export declare function WorkspaceLoadingState({ title, description, status, fullscreen, className, }: WorkspaceLoadingStateProps): JSX.Element;
+
+export declare interface WorkspaceLoadingStateProps {
+    title?: string;
+    description?: string;
+    status?: string;
+    fullscreen?: boolean;
+    className?: string;
+}
+
+declare type WorkspacePanelMatch = {
+    id: string;
+} | {
+    param: string;
+    value: unknown;
+};
+
+/**
+ * Built-in plugin events baked into the public workspace event map.
+ *
+ * Filesystem events are declared inline (using EventMeta which is structurally
+ * identical to FilesystemEventMeta) so the keys survive vite's rollupTypes
+ * bundling without importing plugin-domain modules.
+ *
+ * Third-party plugins can extend this interface via declare module augmentation,
+ * though that only works in source compilation — it does not survive dist bundling.
+ */
+export declare interface WorkspacePluginEventMap {
+    "filesystem:file.changed": EventMeta & {
+        path: string;
+    };
+    "filesystem:file.created": EventMeta & {
+        path: string;
+        kind: "file" | "dir";
+    };
+    "filesystem:file.moved": EventMeta & {
+        from: string;
+        to: string;
+    };
+    "filesystem:file.deleted": EventMeta & {
+        path: string;
+    };
+}
+
+export declare function WorkspaceProvider({ children, chatPanel, plugins, excludeDefaults, panels, commands, catalogs, capabilities, apiBaseUrl, authHeaders, apiTimeout, defaultTheme, onThemeChange, workspaceId, storageKey, persistenceEnabled, bridgeEndpoint, onAuthError, onOpenFile, }: WorkspaceProviderProps): JSX.Element;
+
+export declare interface WorkspaceProviderProps {
+    children: ReactNode;
+    chatPanel?: WorkspaceChatPanelComponent;
+    plugins?: WorkspaceFrontPlugin[];
+    excludeDefaults?: string[];
+    panels?: PanelConfig[];
+    commands?: CommandConfig[];
+    catalogs?: CatalogConfig[];
+    capabilities?: Record<string, boolean>;
+    apiBaseUrl?: string;
+    authHeaders?: Record<string, string>;
+    /** Per-request timeout for the data layer's FetchClient, in ms. */
+    apiTimeout?: number;
+    defaultTheme?: "light" | "dark" | undefined;
+    onThemeChange?: (theme: "light" | "dark") => void;
+    workspaceId?: string;
+    storageKey?: string;
+    persistenceEnabled?: boolean;
+    bridgeEndpoint?: string | null;
+    onAuthError?: (statusCode: number) => void;
+    onOpenFile?: (path: string) => void;
+}
+
+export declare interface WorkspaceState {
+    hydrationComplete: boolean;
+    layout: unknown | null;
+    sidebar: SidebarState;
+    panelSizes: Record<string, number>;
+    preferences: {
+        theme: "light" | "dark";
+    };
+    panels: PanelState[];
+    activePanel: string | null;
+    activeFile: string | null;
+    visibleFiles: string[];
+    dirtyFiles: Record<string, {
+        panelId: string;
+        savedAt: number | null;
+    }>;
+    notifications: Notification_2[];
+}
+
+export declare type WorkspaceStore = WorkspaceState & WorkspaceActions;
+
+declare type WorkspaceStoreApi = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prevState: WorkspaceStore) => void) => () => void;
+    setState: (partial: Partial<WorkspaceStore>) => void;
+    getInitialState: () => WorkspaceStore;
+};
+
+export { }