@hachej/boring-workspace 0.1.0

package/dist/shared.d.ts

@@ -0,0 +1,113 @@
+export { C as CommandResult, E as ExplorerAdapter, c as ExplorerRow, S as SearchResult, U as UiBridge, a as UiCommand, b as UiState } from './explorer-DtLUnuah.js';
+import { ComponentType } from 'react';
+import { DockviewPanelApi, DockviewApi } from 'dockview-react';
+export { A as AgentTool, J as JSONSchema, T as ToolExecContext, a as ToolResult } from './agent-tool-NvxKfist.js';
+
+/**
+ * Shared panel and command types — no runtime deps beyond React/dockview.
+ *
+ * Importable from BOTH front and server bundles without dragging in
+ * platform-specific code.
+ */
+
+/**
+ * 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.
+ */
+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;
+}
+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>>;
+    }>);
+}
+type PanelRegistration<T = any> = Omit<PanelConfig<T>, 'id'>;
+/**
+ * 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",
+ * })
+ * ```
+ */
+declare function definePanel<T = unknown>(config: PanelConfig<T>): PanelConfig<T>;
+interface CommandConfig {
+    id: string;
+    title: string;
+    run: () => void;
+    keywords?: string[];
+    shortcut?: string;
+    when?: () => boolean;
+    pluginId?: string;
+}
+
+declare const WORKSPACE_OPEN_PATH_SURFACE_KIND = "workspace.open.path";
+interface SurfaceOpenRequest {
+    kind: string;
+    target: string;
+    meta?: Record<string, unknown>;
+}
+interface SurfacePanelResolution {
+    component: string;
+    id?: string;
+    title?: string;
+    params?: Record<string, unknown>;
+    score?: number;
+}
+interface SurfaceResolverConfig {
+    id: string;
+    resolve: (request: SurfaceOpenRequest) => SurfacePanelResolution | undefined;
+    source?: string;
+    pluginId?: string;
+}
+type SurfaceResolverRegistration = Omit<SurfaceResolverConfig, "id">;
+
+export { type CommandConfig, type PaneProps, type PanelConfig, type PanelRegistration, type SurfaceOpenRequest, type SurfacePanelResolution, type SurfaceResolverConfig, type SurfaceResolverRegistration, WORKSPACE_OPEN_PATH_SURFACE_KIND, definePanel };

package/dist/shared.js

@@ -0,0 +1,11 @@
+// src/shared/types/surface.ts
+var WORKSPACE_OPEN_PATH_SURFACE_KIND = "workspace.open.path";
+
+// src/shared/types/panel.ts
+function definePanel(config) {
+  return config;
+}
+export {
+  WORKSPACE_OPEN_PATH_SURFACE_KIND,
+  definePanel
+};

package/dist/testing-e2e.d.ts

@@ -0,0 +1,68 @@
+import { Page } from '@playwright/test';
+
+/**
+ * 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>;
+
+export declare 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;
+}
+
+/**
+ * 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>;
+
+export declare 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;
+}
+
+/**
+ * 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 { }

package/dist/testing-e2e.js

@@ -0,0 +1,45 @@
+async function r(t, e) {
+  try {
+    await t.context().request.get("/api/v1/ui/commands/next?poll=true", {
+      timeout: 2e3
+    });
+  } catch {
+  }
+  const a = { ...e.seed ?? {} };
+  e.openWorkbenchAtBoot !== !1 && (a[`${e.shellKey}:surface`] = "1"), await t.addInitScript((o) => {
+    try {
+      localStorage.clear();
+      for (const [n, i] of Object.entries(o))
+        localStorage.setItem(n, i);
+    } catch {
+    }
+  }, a), await t.goto("/", { waitUntil: "domcontentloaded" }), await t.waitForTimeout(e.mountSettleMs ?? 2500);
+}
+async function c(t, e) {
+  await t.evaluate(
+    (o) => localStorage.getItem(`${o}:surface`) === "1",
+    e.shellKey
+  ) || (await t.locator("body").click({ position: { x: 750, y: 300 } }), await t.keyboard.press("Meta+2"), await t.waitForTimeout(800));
+}
+async function l(t, e) {
+  if (await t.waitForTimeout(700), !await t.evaluate(async (o) => (await fetch("/api/v1/ui/commands", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ kind: "openPanel", params: o })
+  })).ok, e)) throw new Error(`bridge openPanel failed for ${e.id}`);
+  await t.waitForFunction(
+    (o) => {
+      const n = document.querySelectorAll(".dv-tab");
+      for (const i of n)
+        if ((i.textContent ?? "").includes(o)) return !0;
+      return !1;
+    },
+    e.title,
+    { timeout: e.paneMountTimeoutMs ?? 1e4 }
+  ), await t.waitForTimeout(800);
+}
+export {
+  r as bootClean,
+  l as openPaneViaBridge,
+  c as openWorkbench
+};

package/dist/testing.d.ts

@@ -0,0 +1,464 @@
+import { ComponentType } from 'react';
+import { DockviewApi } from 'dockview-react';
+import { DockviewPanelApi } from 'dockview-react';
+import { JSX } from 'react/jsx-runtime';
+import { Page } from '@playwright/test';
+import { ReactElement } from 'react';
+import { ReactNode } from 'react';
+import { RenderOptions } from '@testing-library/react';
+import { RenderResult } from '@testing-library/react';
+
+declare type Badge = {
+    /** 1–4 char mono code rendered as a chip. */
+    code: string;
+    tooltip?: string;
+};
+
+/**
+ * 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>;
+
+export declare 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;
+}
+
+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;
+    };
+}
+
+declare interface CommandResult {
+    seq: number;
+    status: "ok" | "error";
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+
+export declare function createLocalStorageSessions(opts?: CreateLocalStorageSessionsOptions): MockSessionsStore;
+
+export declare 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?: () => MockSessionsState;
+}
+
+export declare function createMockBridge(options?: CreateMockBridgeOptions): MockWorkspaceBridge;
+
+export declare interface CreateMockBridgeOptions {
+    state?: Partial<MockBridgeState>;
+    fn?: SpyFactory;
+}
+
+export declare 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>;
+
+export declare function createMockRegistry(options?: CreateMockRegistryOptions): PanelRegistry;
+
+export declare interface CreateMockRegistryOptions {
+    panels?: PanelConfig[];
+    capabilities?: Record<string, boolean>;
+}
+
+export declare function createMockSeriesAdapter(): ExplorerAdapter;
+
+export declare function createMockSessions(opts?: CreateMockSessionsOptions): MockSessionsStore;
+
+export declare 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 createMockTablesAdapter(): ExplorerAdapter;
+
+declare interface DynamicPaneConfig {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+    title?: string;
+}
+
+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 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 Facets = Record<string, FacetValue[]>;
+
+declare type FacetsArgs = {
+    filters: Record<string, string[]>;
+    signal?: AbortSignal;
+};
+
+declare type FacetValue = {
+    value: string;
+    count: number;
+};
+
+export declare interface MockBridgeState {
+    openPanels: PanelState[];
+    activeFile: string | null;
+    dirtyFiles: string[];
+    visibleFiles: string[];
+}
+
+export declare interface MockDataFixtures {
+    files?: MockFileFixture[];
+}
+
+export declare interface MockFileFixture {
+    path: string;
+    content: string;
+    mtimeMs?: number;
+}
+
+export declare interface MockSessionsState {
+    sessions: SessionItem[];
+    activeId: string;
+}
+
+export declare interface MockSessionsStore {
+    getState: () => MockSessionsState;
+    subscribe: (fn: () => void) => () => void;
+    switchTo: (id: string) => void;
+    create: () => void;
+    remove: (id: string) => void;
+}
+
+export declare type MockWorkspaceBridge = WorkspaceBridge & {
+    emit<K extends keyof BridgeEventMap>(event: K, payload: BridgeEventMap[K]): void;
+    setState(next: Partial<MockBridgeState>): void;
+    getStateSnapshot(): MockBridgeState;
+};
+
+declare interface Notification_2 {
+    id: string;
+    message: string;
+    type: "info" | "warning" | "error";
+    timestamp: 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>;
+
+export declare 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;
+}
+
+/**
+ * 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>;
+
+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>>;
+    }>);
+}
+
+declare type PanelRegistration<T = any> = Omit<PanelConfig<T>, 'id'>;
+
+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;
+}
+
+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.
+ */
+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 function renderPane(ui: ReactElement, options?: RenderPaneOptions): RenderPaneResult;
+
+export declare interface RenderPaneOptions extends Omit<RenderOptions, "wrapper"> {
+    fixtures?: MockDataFixtures;
+    bridge?: MockWorkspaceBridge;
+    registry?: PanelRegistry;
+    apiBaseUrl?: string;
+    authHeaders?: Record<string, string>;
+    defaultTheme?: "light" | "dark";
+    timeout?: number;
+    injectBridgeProp?: boolean;
+}
+
+export declare type RenderPaneResult = RenderResult & {
+    bridge: MockWorkspaceBridge;
+    registry: PanelRegistry;
+};
+
+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 SearchResult = {
+    items: ExplorerRow[];
+    /** Total count for the current scope (query + filters + optional group). */
+    total: number;
+    hasMore: boolean;
+};
+
+declare interface SessionItem {
+    id: string;
+    title: string;
+    updatedAt?: string | number;
+}
+
+declare interface SidebarState {
+    collapsed: boolean;
+    width: number;
+}
+
+declare type SpyFactory = <T extends (...args: any[]) => any>(implementation?: T) => any;
+
+export declare function TestWorkspaceProvider({ children, fixtures, registry, apiBaseUrl, authHeaders, defaultTheme, timeout, }: TestWorkspaceProviderProps): JSX.Element;
+
+export declare interface TestWorkspaceProviderProps {
+    children: ReactNode;
+    fixtures?: MockDataFixtures;
+    registry?: PanelRegistry;
+    apiBaseUrl?: string;
+    authHeaders?: Record<string, string>;
+    defaultTheme?: "light" | "dark";
+    timeout?: number;
+}
+
+declare type Unsubscribe = () => void;
+
+/**
+ * React hook bound to a specific store instance. Identical signature to
+ * `useMockSessions` — both stores share the `MockSessionsStore` type.
+ */
+export declare function useLocalStorageSessions(store: MockSessionsStore): MockSessionsState;
+
+/**
+ * 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;
+
+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;
+}
+
+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 { }