@hachej/boring-workspace 0.1.70 → 0.1.72

package/dist/src/front/plugin/__tests__/useWorkspacePluginClient.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/plugin/index.d.ts

@@ -0,0 +1,10 @@
+export { useCommands } from './useCommands';
+export { useActivePanels } from './useActivePanels';
+export { useCatalogs } from './useCatalogs';
+export { PluginErrorBoundary } from './PluginErrorBoundary';
+export { PluginErrorProvider, usePluginErrors } from './PluginErrorContext';
+export type { PluginError } from './PluginErrorContext';
+export { PluginInspector } from './PluginInspector';
+export type { PluginMeta } from './PluginInspector';
+export { WorkspacePluginClientProvider, createWorkspacePluginClient, useWorkspacePluginClient } from './useWorkspacePluginClient';
+export type { WorkspacePluginClient } from './useWorkspacePluginClient';

package/dist/src/front/plugin/useActivePanels.d.ts

@@ -0,0 +1,2 @@
+import { PanelConfig } from '../registry/types';
+export declare function useActivePanels(): readonly PanelConfig[];

package/dist/src/front/plugin/useCatalogs.d.ts

@@ -0,0 +1,2 @@
+import { CatalogConfig } from '../../shared/plugins/types';
+export declare function useCatalogs(): readonly CatalogConfig[];

package/dist/src/front/plugin/useCommands.d.ts

@@ -0,0 +1,2 @@
+import { CommandConfig } from '../registry/types';
+export declare function useCommands(): readonly CommandConfig[];

package/dist/src/front/plugin/useWorkspacePluginClient.d.ts

@@ -0,0 +1,29 @@
+import { ReactNode, FunctionComponentElement, ProviderProps } from 'react';
+export interface WorkspacePluginClient {
+    apiBaseUrl: string;
+    workspaceId?: string;
+    workspaceHeaders(): Record<string, string>;
+    getJson<T = unknown>(path: string, options?: {
+        missingMessage?: string;
+    }): Promise<T>;
+    readJsonFile<T>(path: string, options?: {
+        missingMessage?: string;
+    }): Promise<T>;
+    postJson<T = unknown>(path: string, body?: unknown, options?: {
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    sendAgentPrompt(message: string, options?: {
+        title?: string;
+        noncePrefix?: string;
+    }): Promise<void>;
+}
+interface WorkspacePluginClientProviderProps {
+    apiBaseUrl: string;
+    workspaceId?: string;
+    authHeaders?: Record<string, string>;
+    children: ReactNode;
+}
+export declare function createWorkspacePluginClient(apiBaseUrl: string, workspaceId?: string, authHeaders?: Record<string, string>): WorkspacePluginClient;
+export declare function WorkspacePluginClientProvider({ apiBaseUrl, workspaceId, authHeaders, children, }: WorkspacePluginClientProviderProps): FunctionComponentElement<ProviderProps<WorkspacePluginClient | null>>;
+export declare function useWorkspacePluginClient(): WorkspacePluginClient;
+export {};

package/dist/src/front/provider/WorkspaceProvider.d.ts

@@ -0,0 +1,84 @@
+import { ReactNode } from 'react';
+import { CommandPaletteSessionSearchConfig } from '../components/CommandPalette';
+import { BoringFrontFactoryWithId, CapturedFrontPlugin } from '../../shared/plugins/frontFactory';
+import { CommandConfig, PanelConfig } from '../registry/types';
+import { CatalogConfig } from '../../shared/plugins/types';
+import { WorkspaceChatPanelComponent } from '../chrome/chat/types';
+export type FrontPluginHotReloadMode = "vite" | false;
+export declare function useTheme(): {
+    theme: "light" | "dark";
+    setTheme: (theme: "light" | "dark") => void;
+    toggleTheme: () => void;
+};
+export interface ThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: "light" | "dark";
+    onThemeChange?: (theme: "light" | "dark") => void;
+}
+export declare function ThemeProvider({ children, defaultTheme, onThemeChange }: ThemeProviderProps): import("react").JSX.Element;
+export interface WorkspaceBridgeContextValue {
+    connected: boolean;
+}
+export declare function useWorkspaceBridge(): WorkspaceBridgeContextValue;
+export interface RegisteredPluginMeta {
+    id: string;
+    label?: string;
+}
+export interface WorkspaceContextValue {
+    chatPanel: WorkspaceChatPanelComponent | null;
+    registeredPlugins: RegisteredPluginMeta[];
+    workspaceId?: string;
+    debug: boolean;
+}
+export declare function useWorkspaceContext(): WorkspaceContextValue;
+export declare function useWorkspaceContextOptional(): WorkspaceContextValue | null;
+export declare function useWorkspaceChatPanel(): WorkspaceChatPanelComponent;
+export interface WorkspaceProviderProps {
+    children: ReactNode;
+    chatPanel?: WorkspaceChatPanelComponent;
+    /**
+     * Front plugin entries produced by `definePlugin({ id, ... })` from
+     * `@hachej/boring-workspace/plugin`.
+     */
+    plugins?: BoringFrontFactoryWithId[];
+    capturedPlugins?: CapturedFrontPlugin[];
+    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;
+    /** Active chat/session scope shared with plugin providers that need session-scoped data. */
+    activeSessionId?: string | null;
+    /** Session ids that are currently open in chat panes, for plugins that must avoid opening closed-session UI. */
+    openSessionIds?: readonly string[];
+    /** Authoritative chat session ids used to drop stale session-scoped Inbox/attention entries. */
+    attentionSessionIds?: readonly string[];
+    /** False while session data is loading or paginated; prevents pruning valid off-page attention entries. */
+    attentionSessionsAuthoritative?: boolean;
+    defaultTheme?: "light" | "dark" | undefined;
+    onThemeChange?: (theme: "light" | "dark") => void;
+    workspaceId?: string;
+    workspaceLabel?: string;
+    appTitle?: string;
+    storageKey?: string;
+    persistenceEnabled?: boolean;
+    manageDocumentTitle?: boolean;
+    bridgeEndpoint?: string | null;
+    onAuthError?: (statusCode: number) => void;
+    onOpenFile?: (path: string) => void;
+    debug?: boolean;
+    /**
+     * Hot-load dynamically discovered front plugin modules. The current
+     * implementation relies on Vite's /@fs transform endpoint, so it defaults to
+     * dev-only. Production hosts should keep this false until they provide their
+     * own module asset endpoint.
+     */
+    frontPluginHotReload?: FrontPluginHotReloadMode;
+    fullPageBasePath?: string;
+    commandPaletteSessionSearch?: CommandPaletteSessionSearchConfig;
+}
+export declare function WorkspaceProvider({ children, chatPanel, plugins, capturedPlugins, excludeDefaults, panels, commands, catalogs, capabilities, apiBaseUrl, authHeaders, apiTimeout, activeSessionId, openSessionIds, attentionSessionIds, attentionSessionsAuthoritative, defaultTheme, onThemeChange, workspaceId, workspaceLabel, appTitle, storageKey, persistenceEnabled, manageDocumentTitle, bridgeEndpoint, onAuthError, onOpenFile, debug, frontPluginHotReload, fullPageBasePath, commandPaletteSessionSearch, }: WorkspaceProviderProps): import("react").JSX.Element;

package/dist/src/front/provider/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @hachej/boring-workspace/front/provider — Provider components.
+ */
+export { WorkspaceProvider, ThemeProvider, useTheme, useWorkspaceBridge, useWorkspaceContext, useWorkspaceContextOptional, useWorkspaceChatPanel, } from './WorkspaceProvider';
+export type { WorkspaceProviderProps, FrontPluginHotReloadMode, ThemeProviderProps, WorkspaceBridgeContextValue, WorkspaceContextValue, } from './WorkspaceProvider';
+export { formatWorkspaceDocumentTitle } from './workspaceTitle';
+export { WORKSPACE_ATTENTION_ACTION_EVENT, WorkspaceAttentionProvider, emitWorkspaceAttentionAction, useWorkspaceAttention, workspaceAttentionSessionBadgeForBlocker, } from '../attention';
+export type { WorkspaceAttentionActionDetail, WorkspaceAttentionBlocker, WorkspaceAttentionBlockerAction, WorkspaceAttentionContextValue, WorkspaceAttentionProviderProps, WorkspaceAttentionSessionBadge, WorkspaceAttentionFocusMetadata, } from '../attention';
+export type { OpenArtifactHandler, WorkspaceChatPanelComponent, WorkspaceChatPanelProps, } from '../chrome/chat/types';

package/dist/src/front/provider/workspaceTitle.d.ts

@@ -0,0 +1,5 @@
+export declare function formatWorkspaceDocumentTitle(input: {
+    appTitle?: string | null;
+    workspaceLabel?: string | null;
+    workspaceId?: string | null;
+}): string;

package/dist/src/front/registry/PanelRegistry.d.ts

@@ -0,0 +1,39 @@
+import { ComponentType } from 'react';
+import { PanelConfig, PanelRegistration } from './types';
+export declare class PanelRegistry {
+    private panels;
+    private registrationOrder;
+    private capabilities;
+    private listeners;
+    private snapshotCache;
+    private lazyComponentCache;
+    private wrapperComponentCache;
+    private generation;
+    constructor(capabilities?: Record<string, boolean>);
+    register(id: string, config: PanelRegistration): void;
+    unregister(id: string): void;
+    /**
+     * Atomic replace: unregister all panels owned by `pluginId`, then register
+     * the new set, in one emit cycle. Subscribers see exactly one intermediate
+     * state — never an empty registry between unregister and re-register.
+     *
+     * Collision policy: a new registration whose id is already owned by a
+     * DIFFERENT pluginId is skipped with a warning. Preserves cross-plugin
+     * isolation during reload — a renamed plugin can't silently steal another
+     * plugin's panel id. Teardown + rebuild as a single observable transition,
+     * driven by the front-side SSE reload subscriber.
+     */
+    replaceByPluginId(pluginId: string, panels: PanelConfig[]): void;
+    get(id: string): PanelConfig | undefined;
+    has(id: string): boolean;
+    list(): PanelConfig[];
+    listAll(): PanelConfig[];
+    getComponents(): Record<string, ComponentType<any>>;
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly PanelConfig[];
+    private getWrappedComponent;
+    private getLazyComponent;
+    private emit;
+    private filteredPanels;
+    private satisfiesCapabilities;
+}

package/dist/src/front/registry/PanelRenderStatusBoundary.d.ts

@@ -0,0 +1,38 @@
+import { ReactNode, FunctionComponentElement, ProviderProps, DetailedReactHTMLElement } from 'react';
+export type PanelRenderState = "loading" | "ready" | "error" | "missing";
+export interface PanelRenderStatusReport {
+    pluginId: string;
+    panelId: string;
+    panelInstanceId: string;
+    revision?: number;
+    state: PanelRenderState;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+interface PanelRenderStatusReporter {
+    report(status: PanelRenderStatusReport): void;
+}
+export interface PanelRenderStatusProviderProps {
+    apiBaseUrl?: string;
+    workspaceId?: string;
+    authHeaders?: Record<string, string>;
+    children: ReactNode;
+}
+export declare function PanelRenderStatusProvider(props: PanelRenderStatusProviderProps): FunctionComponentElement<ProviderProps<PanelRenderStatusReporter>>;
+interface PanelRenderStatusBoundaryProps {
+    pluginId: string;
+    panelId: string;
+    panelInstanceId?: string;
+    revision?: number;
+    children: ReactNode;
+}
+export declare function PanelRenderStatusBoundary(props: PanelRenderStatusBoundaryProps): DetailedReactHTMLElement<{
+    "data-boring-plugin-revision"?: string | undefined;
+    "data-boring-panel-instance-id"?: string | undefined;
+    className: string;
+    "data-boring-plugin-id": string;
+    "data-boring-panel-component-id": string;
+}, HTMLElement>;
+export {};

package/dist/src/front/registry/RegistryProvider.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { PanelRegistry } from './PanelRegistry';
+import { WorkspaceSourceRegistry } from './WorkspaceSourceRegistry';
+import { CommandRegistry } from '../../shared/plugins/CommandRegistry';
+import { SurfaceResolverRegistry } from '../../shared/plugins/SurfaceResolverRegistry';
+import { CatalogRegistry } from '../../shared/plugins/CatalogRegistry';
+interface RegistryProviderProps {
+    panelRegistry: PanelRegistry;
+    workspaceSourceRegistry?: WorkspaceSourceRegistry;
+    commandRegistry: CommandRegistry;
+    catalogRegistry?: CatalogRegistry;
+    surfaceResolverRegistry?: SurfaceResolverRegistry;
+    children: ReactNode;
+}
+export declare function RegistryProvider({ panelRegistry, workspaceSourceRegistry, commandRegistry, catalogRegistry, surfaceResolverRegistry, children, }: RegistryProviderProps): import("react").JSX.Element;
+export declare function useRegistry(): PanelRegistry;
+export declare function useWorkspaceSourceRegistry(): WorkspaceSourceRegistry;
+export declare function useCommandRegistry(): CommandRegistry;
+export declare function useCatalogRegistry(): CatalogRegistry;
+export declare function useSurfaceResolverRegistry(): SurfaceResolverRegistry;
+export {};

package/dist/src/front/registry/WorkspaceSourceRegistry.d.ts

@@ -0,0 +1,25 @@
+import { ComponentType } from 'react';
+import { WorkspaceSourceConfig, WorkspaceSourceRegistration } from './types';
+export declare class WorkspaceSourceRegistry {
+    private sources;
+    private registrationOrder;
+    private capabilities;
+    private listeners;
+    private snapshotCache;
+    private lazyComponentCache;
+    constructor(capabilities?: Record<string, boolean>);
+    register(id: string, config: WorkspaceSourceRegistration): void;
+    unregister(id: string): void;
+    replaceByPluginId(pluginId: string, sources: WorkspaceSourceConfig[]): void;
+    get(id: string): WorkspaceSourceConfig | undefined;
+    has(id: string): boolean;
+    getComponent(sourceId: string): ComponentType<any> | undefined;
+    list(): WorkspaceSourceConfig[];
+    listAll(): WorkspaceSourceConfig[];
+    subscribe: (cb: () => void) => (() => void);
+    getSnapshot: () => readonly WorkspaceSourceConfig[];
+    private getLazyComponent;
+    private emit;
+    private filteredSources;
+    private satisfiesCapabilities;
+}

package/dist/src/front/registry/__tests__/registry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/registry/__tests__/replaceByPluginId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/registry/__tests__/subscribe.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/registry/coreRegistrations.d.ts

@@ -0,0 +1,2 @@
+import { PanelConfig } from './types';
+export declare const coreWorkspacePanels: PanelConfig[];

package/dist/src/front/registry/getFileIcon.d.ts

@@ -0,0 +1,2 @@
+import { LucideIcon } from 'lucide-react';
+export declare function getFileIcon(filename: string): LucideIcon;

package/dist/src/front/registry/index.d.ts

@@ -0,0 +1,7 @@
+export { PanelRegistry } from './PanelRegistry';
+export { WorkspaceSourceRegistry } from './WorkspaceSourceRegistry';
+export { RegistryProvider, useRegistry, useWorkspaceSourceRegistry, useCommandRegistry, useCatalogRegistry, useSurfaceResolverRegistry, } from './RegistryProvider';
+export { getFileIcon } from './getFileIcon';
+export type { PanelConfig, PanelRegistration, CommandConfig, PaneProps, WorkspaceSourceConfig, WorkspaceSourceOpenPanelConfig, WorkspaceSourceProps, WorkspaceSourceRegistration, } from './types';
+export type { SurfaceOpenRequest, SurfacePanelResolution, SurfaceResolverConfig, SurfaceResolverRegistration, } from '../../shared/types/surface';
+export { WORKSPACE_OPEN_PATH_SURFACE_KIND } from '../../shared/types/surface';

package/dist/src/front/registry/types.d.ts

@@ -0,0 +1,2 @@
+export type { PaneProps, PanelConfig, CommandConfig, PanelRegistration, WorkspaceSourceConfig, WorkspaceSourceOpenPanelConfig, WorkspaceSourceProps, WorkspaceSourceRegistration, } from '../../shared/types/panel';
+export { definePanel } from '../../shared/types/panel';

package/dist/src/front/shell/WorkspaceShellCapabilitiesContext.d.ts

@@ -0,0 +1 @@
+export { WorkspaceShellCapabilitiesProvider, useWorkspaceShellCapabilities, type WorkspaceShellArtifactTarget, type WorkspaceShellCapabilityResult, type WorkspaceShellCapabilities, } from '../../shared/plugins/workspaceShellCapabilities';

package/dist/src/front/store/__tests__/store.property.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/store/__tests__/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/store/index.d.ts

@@ -0,0 +1,35 @@
+import { WorkspaceStore, SidebarState } from './types';
+import { StoreApi } from 'zustand';
+import { PersistOptions } from 'zustand/middleware';
+export interface CreateWorkspaceStoreOptions {
+    workspaceId?: string;
+    storageKey?: string;
+    persistenceEnabled?: boolean;
+    onLayoutVersionMismatch?: () => void;
+}
+export declare function createWorkspaceStore(options?: CreateWorkspaceStoreOptions): {
+    (): WorkspaceStore;
+    <U>(selector: (state: WorkspaceStore) => U): U;
+} & Omit< StoreApi<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;
+};

package/dist/src/front/store/localStorageValues.d.ts

@@ -0,0 +1,4 @@
+export declare function readStoredBoolean(key: string, fallback: boolean, enabled?: boolean): boolean;
+export declare function writeStoredBoolean(key: string, value: boolean, enabled?: boolean): void;
+export declare function readStoredNumber(key: string, fallback: number, enabled?: boolean): number;
+export declare function writeStoredNumber(key: string, value: number, enabled?: boolean): void;

package/dist/src/front/store/selectors.d.ts

@@ -0,0 +1,21 @@
+import { WorkspaceStore, SidebarState, PanelState } from './types';
+type WorkspaceStoreApi = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prevState: WorkspaceStore) => void) => () => void;
+    setState: (partial: Partial<WorkspaceStore>) => void;
+    getInitialState: () => WorkspaceStore;
+};
+export declare function bindStore(store: WorkspaceStoreApi): void;
+export declare function useActiveFile(): string | null;
+export declare function useActivePanel(): string | null;
+export declare function useSidebarState(): SidebarState;
+export declare function useSetSidebar(): (sidebar: Partial< SidebarState>) => void;
+export declare function useOpenPanels(): PanelState[];
+export declare function useDirtyFiles(): Record<string, {
+    panelId: string;
+    savedAt: number | null;
+}>;
+export declare function useThemePreference(): "light" | "dark";
+export declare function useHydrationComplete(): boolean;
+export declare function useResetLayout(): () => void;
+export {};

package/dist/src/front/store/types.d.ts

@@ -0,0 +1,53 @@
+export interface PanelState {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+    groupId?: string;
+    essential?: boolean;
+}
+export interface Notification {
+    id: string;
+    message: string;
+    type: "info" | "warning" | "error";
+    timestamp: number;
+}
+export interface SidebarState {
+    collapsed: boolean;
+    width: number;
+}
+export 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[];
+}
+export 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, "id" | "timestamp">) => void;
+    dismissNotification: (id: string) => void;
+    navigateToLine: (file: string, line: number) => void;
+    resetLayout: () => void;
+}
+export type WorkspaceStore = WorkspaceState & WorkspaceActions;

package/dist/src/front/testing/TestWorkspaceProvider.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { PanelRegistry } from '../registry/PanelRegistry';
+import { MockDataFixtures } from './mockApi';
+export interface TestWorkspaceProviderProps {
+    children: ReactNode;
+    fixtures?: MockDataFixtures;
+    registry?: PanelRegistry;
+    apiBaseUrl?: string;
+    authHeaders?: Record<string, string>;
+    defaultTheme?: "light" | "dark";
+    timeout?: number;
+}
+export declare function TestWorkspaceProvider({ children, fixtures, registry, apiBaseUrl, authHeaders, defaultTheme, timeout, }: TestWorkspaceProviderProps): import("react").JSX.Element;

package/dist/src/front/testing/__tests__/testing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/front/testing/createLocalStorageSessions.d.ts

@@ -0,0 +1,16 @@
+import { MockSessionsState as State, MockSessionsStore as Store } from './createMockSessions';
+export interface CreateLocalStorageSessionsOptions {
+    /** localStorage key prefix. Defaults to `"workspace:sessions"`. */
+    storageKey?: string;
+    /**
+     * Seed used the first time we run (no value at `storageKey` yet).
+     * Defaults to a single "New session" row with `id = "s${Date.now()}"`.
+     */
+    initial?: () => State;
+}
+export declare function createLocalStorageSessions(opts?: CreateLocalStorageSessionsOptions): Store;
+/**
+ * React hook bound to a specific store instance. Identical signature to
+ * `useMockSessions` — both stores share the `MockSessionsStore` type.
+ */
+export declare function useLocalStorageSessions(store: Store): State;

package/dist/src/front/testing/createMockBridge.d.ts

@@ -0,0 +1,20 @@
+import { BridgeEventMap, WorkspaceBridge } from '../bridge/types';
+import { PanelState } from '../store/types';
+type SpyFactory = <T extends (...args: any[]) => any>(implementation?: T) => any;
+export interface MockBridgeState {
+    openPanels: PanelState[];
+    activeFile: string | null;
+    dirtyFiles: string[];
+    visibleFiles: string[];
+}
+export interface CreateMockBridgeOptions {
+    state?: Partial<MockBridgeState>;
+    fn?: SpyFactory;
+}
+export type MockWorkspaceBridge = WorkspaceBridge & {
+    emit<K extends keyof BridgeEventMap>(event: K, payload: BridgeEventMap[K]): void;
+    setState(next: Partial<MockBridgeState>): void;
+    getStateSnapshot(): MockBridgeState;
+};
+export declare function createMockBridge(options?: CreateMockBridgeOptions): MockWorkspaceBridge;
+export {};

package/dist/src/front/testing/createMockPaneProps.d.ts

@@ -0,0 +1,11 @@
+import { PaneProps } from '../registry/types';
+export interface CreateMockPaneOptions<T> {
+    params: T;
+    panelId?: string;
+    className?: string;
+    /** Override individual `api` fields without re-stubbing the whole surface. */
+    apiOverrides?: Partial<PaneProps<T>["api"]>;
+    /** Override individual `containerApi` fields. */
+    containerApiOverrides?: Partial<PaneProps<T>["containerApi"]>;
+}
+export declare function createMockPaneProps<T>(optsOrParams: T | CreateMockPaneOptions<T>): PaneProps<T>;

package/dist/src/front/testing/createMockRegistry.d.ts

@@ -0,0 +1,7 @@
+import { PanelRegistry } from '../registry/PanelRegistry';
+import { PanelConfig } from '../registry/types';
+export interface CreateMockRegistryOptions {
+    panels?: PanelConfig[];
+    capabilities?: Record<string, boolean>;
+}
+export declare function createMockRegistry(options?: CreateMockRegistryOptions): PanelRegistry;

package/dist/src/front/testing/createMockSessions.d.ts

@@ -0,0 +1,24 @@
+import { SessionItem } from '../components/SessionList';
+export interface MockSessionsState {
+    sessions: SessionItem[];
+    activeId: string;
+}
+export interface MockSessionsStore {
+    getState: () => MockSessionsState;
+    subscribe: (fn: () => void) => () => void;
+    switchTo: (id: string) => void;
+    create: () => void;
+    remove: (id: string) => void;
+}
+export interface CreateMockSessionsOptions {
+    /** Initial sessions. Defaults to a 5-row demo set with descending updatedAt. */
+    initial?: SessionItem[];
+    /** Initial active session id. Defaults to the first session's id. */
+    activeId?: string;
+}
+export declare function createMockSessions(opts?: CreateMockSessionsOptions): MockSessionsStore;
+/**
+ * Convenience hook bound to a specific store instance. Subscribes via
+ * useSyncExternalStore so React only re-renders on actual state changes.
+ */
+export declare function useMockSessions(store: MockSessionsStore): MockSessionsState;

package/dist/src/front/testing/e2e.d.ts

@@ -0,0 +1,61 @@
+import { Page } from '@playwright/test';
+export interface BootCleanOptions {
+    /**
+     * Storage prefix used by declarative chat shells. The
+     * bootClean default is to pre-seed `${shellKey}:surface=1` so the
+     * workbench mounts at boot — required for any test that posts an
+     * openPanel via the bridge (the dispatcher early-returns when no
+     * surface is mounted).
+     */
+    shellKey: string;
+    /** Extra localStorage entries to seed after the clear. */
+    seed?: Record<string, string>;
+    /**
+     * If false, surface=1 is NOT pre-seeded — the test starts with the
+     * workbench closed. Default: true.
+     */
+    openWorkbenchAtBoot?: boolean;
+    /** Vite + dockview cold-mount allowance. Default 2500ms. */
+    mountSettleMs?: number;
+}
+/**
+ * Land on the app with a clean localStorage so persistence-sensitive tests
+ * start from defaults. Pre-opens the workbench surface unless told
+ * otherwise — see `openWorkbenchAtBoot`.
+ *
+ * Also drains the server-side bridge command queue. The bridge is process-
+ * global on a shared dev server (E2E_EXTERNAL_SERVER=1); without an
+ * explicit drain, a leftover command from a previous test (e.g. an
+ * openPanel posted just before that test ended) gets re-delivered to the
+ * next test's SSE subscriber and mounts an unexpected pane. The drain is
+ * a no-op when the queue is already empty.
+ */
+export declare function bootClean(page: Page, opts: BootCleanOptions): Promise<void>;
+/**
+ * Ensure the workbench surface is OPEN. Idempotent — checks the persisted
+ * flag rather than blindly toggling, so it's safe to call after bootClean
+ * (which pre-seeds the open flag by default) or independently.
+ */
+export declare function openWorkbench(page: Page, opts: {
+    shellKey: string;
+}): Promise<void>;
+export interface OpenPaneViaBridgeConfig {
+    /** Tab/panel instance id (e.g. `"chart:CPIAUCSL"`, `"deck:intro.md"`). */
+    id: string;
+    /** Registered panel component id. Must appear in `extraPanels`. */
+    component: string;
+    /** Tab title to wait for. */
+    title: string;
+    /** Forwarded to the panel component as its `params`. */
+    params: Record<string, unknown>;
+    /** Override the dockview-tab wait timeout. Default 10s. */
+    paneMountTimeoutMs?: number;
+}
+/**
+ * Push an openPanel command through the workspace UI bridge, then poll
+ * until the corresponding dockview tab actually appears. The chat shell
+ * receives commands over an SSE stream; subscribe latency is
+ * non-deterministic (cold Vite, ClickHouse warm-up, EventSource reconnect
+ * budget), so we wait on the rendered tab rather than a fixed sleep.
+ */
+export declare function openPaneViaBridge(page: Page, cfg: OpenPaneViaBridgeConfig): Promise<void>;

package/dist/src/front/testing/index.d.ts

@@ -0,0 +1,17 @@
+export { TestWorkspaceProvider } from './TestWorkspaceProvider';
+export type { TestWorkspaceProviderProps } from './TestWorkspaceProvider';
+export { createMockBridge } from './createMockBridge';
+export type { CreateMockBridgeOptions, MockBridgeState, MockWorkspaceBridge, } from './createMockBridge';
+export { createMockRegistry } from './createMockRegistry';
+export type { CreateMockRegistryOptions } from './createMockRegistry';
+export { renderPane } from './renderPane';
+export type { RenderPaneOptions, RenderPaneResult } from './renderPane';
+export type { MockDataFixtures, MockFileFixture } from './mockApi';
+export { createMockSessions, useMockSessions } from './createMockSessions';
+export type { CreateMockSessionsOptions, MockSessionsState, MockSessionsStore, } from './createMockSessions';
+export { createLocalStorageSessions, useLocalStorageSessions, } from './createLocalStorageSessions';
+export type { CreateLocalStorageSessionsOptions } from './createLocalStorageSessions';
+export { bootClean, openWorkbench, openPaneViaBridge, } from './e2e';
+export type { BootCleanOptions, OpenPaneViaBridgeConfig, } from './e2e';
+export { createMockPaneProps } from './createMockPaneProps';
+export type { CreateMockPaneOptions } from './createMockPaneProps';

package/dist/src/front/testing/mockApi.d.ts

@@ -0,0 +1,9 @@
+export interface MockFileFixture {
+    path: string;
+    content: string;
+    mtimeMs?: number;
+}
+export interface MockDataFixtures {
+    files?: MockFileFixture[];
+}
+export declare function createMockApiFetch(fixtures?: MockDataFixtures, fallbackFetch?: typeof fetch): typeof fetch;