@hachej/boring-workspace 0.1.71 → 0.1.72

package/dist/src/app/front/workspacePreload.d.ts

@@ -0,0 +1,64 @@
+export declare const DEFAULT_BOOT_PRELOAD_PATHS: string[];
+export type WorkspaceRuntimeDependenciesWarmupStatus = {
+    state: "preparing" | "ready" | "failed";
+    message?: string;
+    requirement?: string;
+};
+export type WorkspaceWarmupStatus = {
+    status: "preparing";
+    requirement?: "workspace-fs" | "sandbox-exec" | "ui-bridge";
+    message?: string;
+    runtimeDependencies?: WorkspaceRuntimeDependenciesWarmupStatus;
+} | {
+    status: "ready";
+    runtimeDependencies?: WorkspaceRuntimeDependenciesWarmupStatus;
+} | {
+    status: "failed";
+    message: string;
+    requirement?: "workspace-fs" | "sandbox-exec" | "ui-bridge";
+    runtimeDependencies?: WorkspaceRuntimeDependenciesWarmupStatus;
+};
+/**
+ * Convert an absolute filesystem path into a workspace-relative one when it
+ * lives inside `workspaceRoot`. The workspace HTTP file API (`/api/v1/files`,
+ * tree, etc.) is relative-only and rejects absolute paths with a 403 — but the
+ * agent's tool inputs (read/write/edit) surface absolute paths. Clicking such
+ * a path to open it in the workbench therefore needs this translation.
+ *
+ * Already-relative paths and absolute paths that fall outside the root are
+ * returned unchanged (the latter will legitimately 403). The workspace root
+ * itself maps to ".".
+ */
+export declare function relativizeWorkspacePath(path: string, workspaceRoot: string | null | undefined): string;
+export declare function preloadUrl(apiBaseUrl: string | null | undefined, path: string): string;
+export declare function workspaceRequestHeaders(workspaceId: string, headers?: Record<string, string>): Record<string, string>;
+export declare function treePreloadDir(path: string): string | null;
+export declare function seedTreePreloadFromBody(apiBaseUrl: string | null | undefined, workspaceId: string, path: string, body: {
+    entries?: unknown;
+} | null): void;
+export interface WorkspaceReadyError {
+    code?: unknown;
+    retryable?: unknown;
+    requirement?: unknown;
+}
+export interface WarmupPreparingResult {
+    requirement?: "workspace-fs" | "sandbox-exec" | "ui-bridge";
+}
+export declare function parseWorkspaceReadyError(payload: unknown): WorkspaceReadyError | null;
+export declare function parseRetryableWarmupPreparing(payload: unknown): WarmupPreparingResult | null;
+export declare function isAgentRuntimeWarmupPath(path: string): boolean;
+export declare function isReadyStatusPath(path: string): boolean;
+export declare function resolveBootPreloadPaths(preloadPaths: string[], provisionWorkspace: boolean): string[];
+export declare function errorMessageFromPayload(payload: unknown): string | null;
+export interface ReadyStatusWarmupSnapshot {
+    state?: string;
+    message?: string;
+    chatState?: string;
+    workspaceState?: string;
+    runtimeDependenciesState?: string;
+    runtimeDependenciesMessage?: string;
+    runtimeDependenciesRequirement?: string;
+}
+export declare function parseReadyStatusSse(payload: unknown): ReadyStatusWarmupSnapshot | null;
+export declare function readyStatusSupportsWorkspaceUse(status: ReadyStatusWarmupSnapshot | null): boolean;
+export declare function readResponsePayload(response: Response): Promise<unknown>;

package/dist/src/bridge-client/__tests__/client.test.d.ts

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

package/dist/src/bridge-client/index.d.ts

@@ -0,0 +1,65 @@
+import { WORKSPACE_BRIDGE_DISABLED_ENV, WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV, WORKSPACE_BRIDGE_TOKEN_ENV, WORKSPACE_BRIDGE_TOKEN_URL_ENV, WORKSPACE_BRIDGE_URL_ENV, WorkspaceBridgeErrorCode, WorkspaceBridgeCallFailure, WorkspaceBridgeCallRequest, WorkspaceBridgeCallResponse, WorkspaceBridgeCallSuccess, WorkspaceBridgeError } from '../shared/workspace-bridge-rpc';
+export { WORKSPACE_BRIDGE_DISABLED_ENV, WORKSPACE_BRIDGE_REFRESH_TOKEN_ENV, WORKSPACE_BRIDGE_TOKEN_ENV, WORKSPACE_BRIDGE_TOKEN_URL_ENV, WORKSPACE_BRIDGE_URL_ENV, WorkspaceBridgeErrorCode, type WorkspaceBridgeCallFailure, type WorkspaceBridgeCallRequest, type WorkspaceBridgeCallResponse, type WorkspaceBridgeCallSuccess, type WorkspaceBridgeError, };
+export declare enum WorkspaceBridgeClientErrorCode {
+    Config = "WORKSPACE_BRIDGE_CLIENT_CONFIG_ERROR",
+    InvalidResponse = "WORKSPACE_BRIDGE_INVALID_RESPONSE",
+    Transport = "WORKSPACE_BRIDGE_TRANSPORT_ERROR",
+    Timeout = "WORKSPACE_BRIDGE_TIMEOUT",
+    Aborted = "WORKSPACE_BRIDGE_ABORTED",
+    HttpError = "WORKSPACE_BRIDGE_HTTP_ERROR"
+}
+export interface WorkspaceBridgeTokenProviderContext {
+    /** True when the previous attempt failed with a 401 and the client is retrying once. */
+    refresh: boolean;
+    /** Aborts when the per-attempt timeout or caller AbortSignal fires. */
+    signal?: AbortSignal;
+}
+export type WorkspaceBridgeTokenProvider = (context: WorkspaceBridgeTokenProviderContext) => string | Promise<string>;
+export type WorkspaceBridgeClientToken = string | WorkspaceBridgeTokenProvider;
+export interface WorkspaceBridgeClientOptions {
+    url: string;
+    token: WorkspaceBridgeClientToken;
+    fetch?: typeof fetch;
+    /** Default per-attempt timeout. Defaults to 30s. */
+    defaultTimeoutMs?: number;
+}
+export interface WorkspaceBridgeClientCallOptions {
+    requestId?: string;
+    idempotencyKey?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export declare class WorkspaceBridgeClientConfigError extends Error {
+    readonly code = WorkspaceBridgeClientErrorCode.Config;
+    readonly missingVar?: string;
+    constructor(message: string, options?: {
+        missingVar?: string;
+    });
+}
+export declare class WorkspaceBridgeClientError extends Error {
+    readonly code: WorkspaceBridgeErrorCode | WorkspaceBridgeClientErrorCode;
+    readonly status?: number;
+    readonly requestId?: string;
+    constructor(message: string, options: {
+        code: WorkspaceBridgeErrorCode | WorkspaceBridgeClientErrorCode;
+        status?: number;
+        requestId?: string;
+        cause?: unknown;
+    });
+}
+export declare class WorkspaceBridgeClient {
+    readonly url: string;
+    private readonly token;
+    private readonly fetchImpl;
+    private readonly defaultTimeoutMs;
+    constructor(options: WorkspaceBridgeClientOptions);
+    static fromEnv(env?: Record<string, string | undefined>, options?: {
+        fetch?: typeof fetch;
+        token?: WorkspaceBridgeClientToken;
+        defaultTimeoutMs?: number;
+    }): WorkspaceBridgeClient;
+    call<TOutput = unknown, TInput = unknown>(op: string, input: TInput, options?: WorkspaceBridgeClientCallOptions): Promise<TOutput>;
+    private callOnce;
+    private resolveToken;
+    private shouldRetryWithFreshToken;
+}

package/dist/src/front/agentPlugins/__tests__/registerAgentPlugin.test.d.ts

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

package/dist/src/front/agentPlugins/registerAgentPlugin.d.ts

@@ -0,0 +1,26 @@
+import { BoringFrontFactoryWithId } from '../../shared/plugins/frontFactory';
+declare global {
+    var __BORING_RUNTIME_SINGLETONS__: Record<string, unknown> | undefined;
+}
+export interface RegisterAgentPluginOptions {
+    apiBaseUrl?: string;
+    workspaceId?: string;
+    enabled?: boolean;
+    authHeaders?: Record<string, string>;
+    importFront?: (frontUrl: string, revision: number) => Promise<{
+        default?: BoringFrontFactoryWithId;
+    }>;
+    frontImportRetry?: {
+        attempts?: number;
+        delayMs?: number;
+    };
+    reportFrontError?: (report: FrontErrorReport) => void;
+}
+export interface FrontErrorReport {
+    pluginId: string;
+    revision: number;
+    message: string;
+    url?: string;
+}
+export declare function appendFrontImportRevision(frontUrl: string, revision: number, cacheBust?: string | number): string;
+export declare function useAgentPluginHotReload(options: RegisterAgentPluginOptions): void;

package/dist/src/front/agentPlugins/reloadEvent.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Browser event emitted after the runtime plugin registry applies a load/unload
+ * event. Keep literal in sync with @hachej/boring-agent's composer listener;
+ * do not import from agent here because workspace base front code must stay
+ * agent-free.
+ */
+export declare const WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT = "boring-ui:agent-plugins-reloaded";

package/dist/src/front/attention/WorkspaceAttentionProvider.d.ts

@@ -0,0 +1,71 @@
+import { ReactNode } from 'react';
+export declare const WORKSPACE_ATTENTION_ACTION_EVENT: "boring-workspace:attention-action";
+export type WorkspaceAttentionBlockerAction = {
+    id: string;
+    label: string;
+};
+export type WorkspaceAttentionSessionBadge = {
+    /** Stable badge kind for data attributes and plugin-specific styling hooks. */
+    kind: string;
+    /** Short text rendered on the session row, e.g. "question", "review", "approval". */
+    label: string;
+    /** Visual tone only; semantics are owned by the plugin-specific kind/reason. */
+    tone?: "attention" | "danger" | "neutral" | "warning";
+    /** Higher priority wins when several plugins mark the same session. */
+    priority?: number;
+};
+export type WorkspaceAttentionInboxMetadata = {
+    kind: "question" | "review" | "approval" | "notice";
+    sourceLabel: string;
+    createdAt?: string | number | Date;
+    updatedAt?: string | number | Date;
+    priority?: number;
+};
+export type WorkspaceAttentionFocusMetadata = {
+    /** Close the workbench left pane when this blocker becomes active for the current session. */
+    closeWorkbenchLeftPane?: boolean;
+};
+export type WorkspaceAttentionBlocker = {
+    id: string;
+    /** Plugin/domain-specific reason, e.g. "ask-user.question" or "pr-review.review". */
+    reason: string;
+    surfaceKind?: string;
+    target?: string;
+    label?: string;
+    sessionId?: string;
+    /** Optional generic session-row badge contributed by the plugin that owns this attention. */
+    sessionBadge?: WorkspaceAttentionSessionBadge;
+    /**
+     * Remove this blocker once its workspace chat session disappears from the
+     * authoritative session list. Leave unset for external inbox items whose
+     * `sessionId` is a source/thread identifier rather than a local chat id.
+     */
+    pruneWhenSessionMissing?: boolean;
+    /** Explicit inbox projection metadata. New inbox-aware plugins should provide this instead of relying on reason parsing. */
+    inbox?: WorkspaceAttentionInboxMetadata;
+    /** Optional shell focus behavior requested by the plugin that owns this blocker. */
+    focus?: WorkspaceAttentionFocusMetadata;
+    actions?: WorkspaceAttentionBlockerAction[];
+};
+export type WorkspaceAttentionActionDetail = {
+    blockerId: string;
+    actionId: string;
+    blocker: WorkspaceAttentionBlocker;
+    sessionId?: string;
+};
+export declare function emitWorkspaceAttentionAction(detail: WorkspaceAttentionActionDetail): void;
+export declare function workspaceAttentionSessionBadgeForBlocker(blocker: Pick<WorkspaceAttentionBlocker, "reason" | "sessionBadge">): WorkspaceAttentionSessionBadge | null;
+export interface WorkspaceAttentionContextValue {
+    blockers: WorkspaceAttentionBlocker[];
+    addBlocker: (blocker: WorkspaceAttentionBlocker) => void;
+    removeBlocker: (id: string) => void;
+}
+export type WorkspaceAttentionProviderProps = {
+    children: ReactNode;
+    /** Authoritative set of existing chat sessions. Blockers that opt into pruning outside this set are stale and removed. */
+    knownSessionIds?: readonly string[];
+    /** Keep false while sessions are still loading/paginated so valid blockers are not pruned early. */
+    knownSessionsAuthoritative?: boolean;
+};
+export declare function useWorkspaceAttention(): WorkspaceAttentionContextValue;
+export declare function WorkspaceAttentionProvider({ children, knownSessionIds, knownSessionsAuthoritative }: WorkspaceAttentionProviderProps): import("react").JSX.Element;

package/dist/src/front/attention/__tests__/WorkspaceAttentionProvider.test.d.ts

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

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

@@ -0,0 +1,2 @@
+export { WORKSPACE_ATTENTION_ACTION_EVENT, WorkspaceAttentionProvider, emitWorkspaceAttentionAction, useWorkspaceAttention, workspaceAttentionSessionBadgeForBlocker, } from './WorkspaceAttentionProvider';
+export type { WorkspaceAttentionActionDetail, WorkspaceAttentionBlocker, WorkspaceAttentionBlockerAction, WorkspaceAttentionContextValue, WorkspaceAttentionProviderProps, WorkspaceAttentionSessionBadge, WorkspaceAttentionFocusMetadata, } from './WorkspaceAttentionProvider';

package/dist/src/front/bridge/WorkspaceLink.d.ts

@@ -0,0 +1,35 @@
+import { MouseEvent, ReactElement, ReactNode } from 'react';
+import { FilesystemId } from '../../shared/types/filesystem';
+import { UiCommand } from './types';
+export type WorkspaceLinkTarget = {
+    kind: "openFile";
+    path: string;
+    mode?: "view" | "edit" | "diff";
+    filesystem?: FilesystemId;
+} | {
+    kind: "openSurface";
+    surfaceKind: string;
+    target: string;
+    filesystem?: FilesystemId;
+    meta?: Record<string, unknown>;
+} | {
+    kind: "openPanel";
+    id: string;
+    component: string;
+    title?: string;
+    params?: Record<string, unknown>;
+} | {
+    kind: "expandToFile";
+    path: string;
+};
+export interface WorkspaceLinkProps {
+    to: WorkspaceLinkTarget;
+    children: ReactNode;
+    className?: string;
+    title?: string;
+    href?: string;
+    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
+}
+export declare function workspaceLinkCommand(to: WorkspaceLinkTarget): UiCommand;
+export declare function workspaceLinkHref(to: WorkspaceLinkTarget): string;
+export declare function WorkspaceLink({ to, children, className, title, href, onClick }: WorkspaceLinkProps): ReactElement;

package/dist/src/front/bridge/__tests__/WorkspaceLink.test.d.ts

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

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

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

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

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

package/dist/src/front/bridge/__tests__/client.test.d.ts

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

package/dist/src/front/bridge/__tests__/uiCommandDispatcher.test.d.ts

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

package/dist/src/front/bridge/__tests__/uiCommandStream.test.d.ts

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

package/dist/src/front/bridge/client.d.ts

@@ -0,0 +1,33 @@
+import { WorkspaceBridge, CausedBy } from './types';
+import { WorkspaceStore, PanelState } from '../store/types';
+export interface UIStatePut {
+    v: 1;
+    causedBy: CausedBy;
+    openPanels: PanelState[];
+    activePanel: string | null;
+    activeFile: string | null;
+    visibleFiles: string[];
+    dirtyFiles: string[];
+}
+export interface BridgeClientOptions {
+    endpoint: string;
+    bridge: WorkspaceBridge;
+    store: StoreApi;
+    authToken?: string;
+    pollMode?: boolean;
+    pollInterval?: number;
+    onAuthError?: (statusCode: number) => void;
+    onVersionMismatch?: (version: number) => void;
+    onConnectionChange?: (connected: boolean) => void;
+}
+type StoreApi = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prev: WorkspaceStore) => void) => () => void;
+};
+export interface BridgeClient {
+    connect(): void;
+    disconnect(): void;
+    pushState(causedBy: CausedBy): void;
+}
+export declare function createBridgeClient(options: BridgeClientOptions): BridgeClient;
+export {};

package/dist/src/front/bridge/createBridge.d.ts

@@ -0,0 +1,8 @@
+import { WorkspaceStore } from '../store/types';
+import { WorkspaceBridge } from './types';
+type StoreApi = {
+    getState: () => WorkspaceStore;
+    subscribe: (listener: (state: WorkspaceStore, prev: WorkspaceStore) => void) => () => void;
+};
+export declare function createBridge(store: StoreApi): WorkspaceBridge;
+export {};

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

@@ -0,0 +1,12 @@
+export { createBridge } from './createBridge';
+export { createBridgeClient } from './client';
+export { dispatchUiCommand, WORKSPACE_COMMAND_NOTIFY_EVENT, WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT } from './uiCommandDispatcher';
+export { UI_COMMAND_EVENT, postUiCommand } from './uiCommandBus';
+export { WorkspaceLink, workspaceLinkCommand, workspaceLinkHref } from './WorkspaceLink';
+export type { WorkspaceLinkProps, WorkspaceLinkTarget } from './WorkspaceLink';
+export { startUiCommandStream } from './uiCommandStream';
+export type { BridgeClient, BridgeClientOptions, UIStatePut } from './client';
+export type { DispatchContext } from './uiCommandDispatcher';
+export type { UiCommand } from './types';
+export type { WorkspaceBridge, FileTreeBridge, BridgeEventMap, CommandResult, DynamicPaneConfig, Unsubscribe, CausedBy, } from './types';
+export { openFileSchema, openPanelSchema, closePanelSchema, notificationSchema, navigateToLineSchema, expandToFileSchema, MAX_PANELS, } from './validation';

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

@@ -0,0 +1,92 @@
+import { WorkspaceState, PanelState } from '../store/types';
+import { FilesystemId } from '../../shared/types/filesystem';
+export interface CommandResult {
+    seq: number;
+    status: "ok" | "error";
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface UiCommand {
+    v?: number;
+    seq?: number;
+    kind: string;
+    params: Record<string, unknown>;
+}
+export 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";
+        filesystem?: FilesystemId;
+    };
+    "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 type Unsubscribe = () => void;
+export interface DynamicPaneConfig {
+    id: string;
+    component: string;
+    params?: Record<string, unknown>;
+    title?: string;
+}
+export interface WorkspaceBridge {
+    getOpenPanels(): PanelState[];
+    getActiveFile(): string | null;
+    getDirtyFiles(): string[];
+    getVisibleFiles(): string[];
+    openFile(path: string, opts?: {
+        mode?: "view" | "edit" | "diff";
+        filesystem?: FilesystemId;
+    }): 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;
+}
+/**
+ * The minimal slice of {@link WorkspaceBridge} a file tree needs: click-to-open
+ * (`openFile`), initial selection (`getActiveFile`), reactive reveal (`select`,
+ * plus optional `subscribe`). Lives here (core bridge layer) — not in the
+ * filesystem plugin — so core chrome (WorkbenchLeftPane) can forward a
+ * surface-backed adapter without importing a plugin module.
+ */
+export type FileTreeBridge = Pick<WorkspaceBridge, "openFile" | "getActiveFile" | "select"> & Partial<Pick<WorkspaceBridge, "subscribe">>;
+export type CausedBy = "user" | "agent" | "restore";

package/dist/src/front/bridge/uiCommandBus.d.ts

@@ -0,0 +1,3 @@
+import { UiCommand } from './types';
+export declare const UI_COMMAND_EVENT = "boring-workspace:ui-command";
+export declare function postUiCommand(command: UiCommand): void;

package/dist/src/front/bridge/uiCommandDispatcher.d.ts

@@ -0,0 +1,44 @@
+import { SurfaceShellApi } from '../chrome/artifact-surface/SurfaceShell';
+import { UiCommand } from './types';
+import { SurfaceOpenRequest } from '../../shared/types/surface';
+/**
+ * Browser CustomEvent name dispatched on `window` when a `showNotification`
+ * UI command is dispatched from the server. Keep in sync with
+ * `WORKSPACE_COMMAND_NOTIFY_EVENT` in `@hachej/boring-agent/shared`.
+ */
+export declare const WORKSPACE_COMMAND_NOTIFY_EVENT = "boring-ui:command-notify";
+export declare const WORKSPACE_SURFACE_OPEN_SKIPPED_EVENT = "boring-workspace:surface-open-skipped";
+export 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;
+    /** Open the workbench sources/file-tree pane. Must be a no-op when already open. */
+    openWorkbenchSources?: () => void;
+    /** Close the workbench pane when a command opened it only for an ephemeral task. */
+    closeWorkbench?: () => void;
+    /**
+     * Park an op that couldn't run because the surface never mounted within the
+     * retry budget (collapsed surface / warmup overlay). The host flushes parked
+     * ops when the SurfaceShell next becomes ready. Without this the op is
+     * silently dropped.
+     */
+    enqueue?: (run: (surface: SurfaceShellApi) => void) => void;
+    /** Optional host policy hook for surface requests that are only relevant in a visible/open context. */
+    shouldOpenSurface?: (request: SurfaceOpenRequest) => boolean;
+}
+/**
+ * Apply a single agent-issued UI command. Pure function: takes a command
+ * + a context with the surface handle and returns nothing. Unknown kinds
+ * are silently ignored — the agent and frontend can drift on supported
+ * commands without breaking the chat. Known-but-unhandled kinds
+ * (navigateToLine, showNotification, closePanel) are accepted-but-no-op
+ * so the contract surface stays additive.
+ */
+export declare function dispatchUiCommand(cmd: UiCommand, ctx: DispatchContext): void;

package/dist/src/front/bridge/uiCommandStream.d.ts

@@ -0,0 +1,41 @@
+import { DispatchContext } from './uiCommandDispatcher';
+export type { DispatchContext } from './uiCommandDispatcher';
+export type { UiCommand } from './types';
+export { dispatchUiCommand } from './uiCommandDispatcher';
+export interface StreamOptions {
+    /** Endpoint base — usually "" for same-origin (vite proxy forwards). */
+    endpoint?: string;
+    /** Dispatch context — surface getter, workbench-open getter, opener. */
+    ctx: DispatchContext;
+    /** Query params appended to SSE/poll URLs, e.g. workspace scoping. */
+    query?: Record<string, string | number | boolean | null | undefined>;
+    /**
+     * Inject EventSource for tests. Defaults to `globalThis.EventSource`.
+     * Pass `null` to force the polling fallback unconditionally (useful when
+     * a test runner defines a broken stub).
+     */
+    eventSourceCtor?: typeof EventSource | null;
+    /** Inject fetch for the polling fallback. Defaults to global fetch. */
+    fetcher?: typeof fetch;
+    /** Polling cadence when on the fallback path. */
+    pollIntervalMs?: number;
+    /** Backoff between SSE reconnect attempts (linear). */
+    reconnectDelayMs?: number;
+    /** Max reconnect attempts before giving up and falling back to polling. */
+    maxReconnects?: number;
+}
+/**
+ * Open the bridge command channel. Returns a cleanup function that closes
+ * any active EventSource AND stops any pending poll. Safe to call from
+ * useEffect.
+ *
+ * Strategy:
+ * 1. If EventSource is available, open it and listen for `command` events.
+ * 2. On error, reconnect up to `maxReconnects` times with linear backoff.
+ * 3. If EventSource is unavailable OR reconnects exhausted, fall back to
+ *    polling. The fallback is sticky for the lifetime of this call —
+ *    we don't try to upgrade back to SSE because the most likely cause
+ *    of repeated SSE failure (proxy stripping event-stream) won't fix
+ *    itself in-session.
+ */
+export declare function startUiCommandStream(opts: StreamOptions): () => void;

package/dist/src/front/bridge/validation.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+declare const MAX_PANELS = 50;
+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"]>>;
+    filesystem: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    filesystem?: string | undefined;
+    mode?: "view" | "edit" | "diff" | undefined;
+}, {
+    path: string;
+    filesystem?: string | undefined;
+    mode?: "view" | "edit" | "diff" | undefined;
+}>;
+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;
+}>;
+export declare const closePanelSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+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;
+}>;
+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;
+}>;
+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 { MAX_PANELS };

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

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