pmx-canvas 0.1.0

package/dist/types/server/index.d.ts

@@ -0,0 +1,243 @@
+import { EventEmitter } from 'node:events';
+import type { CanvasNodeState, CanvasEdge, CanvasLayout } from './canvas-state.js';
+import { searchNodes } from './spatial-analysis.js';
+import { diffLayouts } from './mutation-history.js';
+import { type WebArtifactBuildInput, type WebArtifactCanvasBuildResult } from './web-artifacts.js';
+import { type ExternalMcpTransportConfig } from './mcp-app-runtime.js';
+import { type DiagramPresetOpenInput } from './diagram-presets.js';
+import { type GraphNodeInput, type JsonRenderNodeInput, type JsonRenderSpec } from '../json-render/server.js';
+import type { CanvasAutomationWebViewOptions, CanvasAutomationWebViewStatus } from './server.js';
+export declare class PmxCanvas extends EventEmitter {
+    private _port;
+    private _server;
+    constructor(options?: {
+        port?: number;
+    });
+    start(options?: {
+        open?: boolean;
+        automationWebView?: boolean | CanvasAutomationWebViewOptions;
+    }): Promise<void>;
+    stop(): void;
+    addNode(input: {
+        type: CanvasNodeState['type'];
+        title?: string;
+        content?: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    }): string;
+    addWebpageNode(input: {
+        title?: string;
+        url: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    }): Promise<{
+        ok: boolean;
+        id: string;
+        error?: string;
+        fetch: {
+            ok: boolean;
+            error?: string;
+        };
+    }>;
+    refreshWebpageNode(id: string, url?: string): Promise<{
+        ok: boolean;
+        id: string;
+        error?: string;
+    }>;
+    updateNode(id: string, patch: Partial<CanvasNodeState>): void;
+    removeNode(id: string): void;
+    addEdge(input: {
+        from?: string;
+        to?: string;
+        fromSearch?: string;
+        toSearch?: string;
+        type: CanvasEdge['type'];
+        label?: string;
+        style?: CanvasEdge['style'];
+        animated?: boolean;
+    }): string;
+    removeEdge(id: string): void;
+    /**
+     * Create a group node and optionally add child nodes to it.
+     * If childIds are provided, the group auto-sizes to contain them with padding.
+     */
+    createGroup(input: {
+        title?: string;
+        childIds?: string[];
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        color?: string;
+        childLayout?: 'grid' | 'column' | 'flow';
+    }): string;
+    /** Add nodes to an existing group. */
+    groupNodes(groupId: string, childIds: string[], options?: {
+        childLayout?: 'grid' | 'column' | 'flow';
+    }): boolean;
+    /** Remove all children from a group (the group node remains). */
+    ungroupNodes(groupId: string): boolean;
+    clear(): void;
+    arrange(layout?: 'grid' | 'column' | 'flow'): void;
+    focusNode(id: string): void;
+    getLayout(): CanvasLayout;
+    getNode(id: string): CanvasNodeState | undefined;
+    search(query: string): ReturnType<typeof searchNodes>;
+    getSpatialContext(): import("./spatial-analysis.js").SpatialContext;
+    undo(): Promise<{
+        ok: boolean;
+        description?: string;
+    }>;
+    redo(): Promise<{
+        ok: boolean;
+        description?: string;
+    }>;
+    getHistory(): {
+        text: string;
+        entries: import("./mutation-history.js").MutationSummary[];
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+    applyUpdates(updates: Array<{
+        id: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+        size?: {
+            width: number;
+            height: number;
+        };
+        collapsed?: boolean;
+        dockPosition?: 'left' | 'right' | null;
+    }>): {
+        applied: number;
+        skipped: number;
+    };
+    setContextPins(nodeIds: string[], mode?: 'set' | 'add' | 'remove'): {
+        count: number;
+        nodeIds: string[];
+    };
+    listSnapshots(): import("./canvas-state.js").CanvasSnapshot[];
+    saveSnapshot(name: string): import("./canvas-state.js").CanvasSnapshot | null;
+    restoreSnapshot(id: string): Promise<{
+        ok: boolean;
+    }>;
+    deleteSnapshot(id: string): {
+        ok: boolean;
+    };
+    diffSnapshot(idOrName: string): {
+        ok: boolean;
+        text?: string;
+        diff?: ReturnType<typeof diffLayouts>;
+        error?: string;
+    };
+    getCodeGraph(): {
+        text: string;
+        summary: import("./code-graph.js").CodeGraphSummary;
+    };
+    validate(): import("./canvas-validation.js").CanvasValidationResult;
+    private findCanvasExtAppNodeId;
+    describeSchema(): {
+        ok: true;
+        source: "running-server";
+        version: string | null;
+        nodeTypes: import("./canvas-schema.js").CanvasCreateTypeSchema[];
+        jsonRender: {
+            rootShape: Record<string, string>;
+            components: import("../json-render/catalog.js").JsonRenderComponentDescriptor[];
+        };
+        graph: {
+            graphTypes: ("line" | "bar" | "pie" | "area" | "scatter" | "radar" | "composed" | "stacked-bar")[];
+        };
+        mcp: {
+            tools: string[];
+            resources: string[];
+        };
+    };
+    validateSpec(input: {
+        type: 'json-render' | 'graph';
+        spec?: unknown;
+        graph?: GraphNodeInput;
+    }): import("./canvas-schema.js").StructuredValidationResult;
+    runBatch(operations: Array<{
+        op: string;
+        assign?: string;
+        args?: Record<string, unknown>;
+    }>): Promise<{
+        ok: boolean;
+        results: Array<Record<string, unknown>>;
+        refs: Record<string, unknown>;
+        failedIndex?: number;
+        error?: string;
+    }>;
+    buildWebArtifact(input: WebArtifactBuildInput & {
+        openInCanvas?: boolean;
+    }): Promise<WebArtifactCanvasBuildResult>;
+    openMcpApp(input: {
+        transport: ExternalMcpTransportConfig;
+        toolName: string;
+        toolArguments?: Record<string, unknown>;
+        serverName?: string;
+        title?: string;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    }): Promise<{
+        ok: true;
+        nodeId: string | null;
+        toolCallId: string;
+        sessionId: string;
+        resourceUri: string;
+    }>;
+    addDiagram(input: DiagramPresetOpenInput): Promise<{
+        ok: true;
+        nodeId: string | null;
+        toolCallId: string;
+        sessionId: string;
+        resourceUri: string;
+    }>;
+    addJsonRenderNode(input: JsonRenderNodeInput): {
+        id: string;
+        url: string;
+        spec: JsonRenderSpec;
+    };
+    addGraphNode(input: GraphNodeInput): {
+        id: string;
+        url: string;
+        spec: JsonRenderSpec;
+    };
+    get port(): number;
+    startAutomationWebView(options?: CanvasAutomationWebViewOptions): Promise<CanvasAutomationWebViewStatus>;
+    stopAutomationWebView(): Promise<boolean>;
+    getAutomationWebViewStatus(): CanvasAutomationWebViewStatus;
+    evaluateAutomationWebView(expression: string): Promise<unknown>;
+    resizeAutomationWebView(width: number, height: number): Promise<CanvasAutomationWebViewStatus>;
+    screenshotAutomationWebView(options?: Record<string, unknown>): Promise<Uint8Array>;
+}
+export declare function createCanvas(options?: {
+    port?: number;
+}): PmxCanvas;
+export type { CanvasNodeState, CanvasEdge, CanvasLayout, ViewportState } from './canvas-state.js';
+export type { CanvasAutomationWebViewOptions, CanvasAutomationWebViewStatus, PrimaryWorkbenchCanvasPromptRequest, PrimaryWorkbenchIntent, } from './server.js';
+export { emitPrimaryWorkbenchEvent, consumePrimaryWorkbenchIntents, setPrimaryWorkbenchAutoOpenEnabled, setPrimaryWorkbenchCanvasPromptHandler, startCanvasServer, stopCanvasServer, getCanvasServerPort, openUrlInExternalBrowser, getCanvasAutomationWebViewStatus, startCanvasAutomationWebView, stopCanvasAutomationWebView, evaluateCanvasAutomationWebView, resizeCanvasAutomationWebView, screenshotCanvasAutomationWebView, } from './server.js';
+export { canvasState } from './canvas-state.js';
+export type { CanvasSnapshot } from './canvas-state.js';
+export { findOpenCanvasPosition } from './placement.js';
+export { searchNodes, buildSpatialContext, detectClusters, findNeighborhoods } from './spatial-analysis.js';
+export type { SpatialCluster, SpatialContext, SpatialNeighbor, NodeSpatialInfo } from './spatial-analysis.js';
+export { mutationHistory, diffLayouts, formatDiff } from './mutation-history.js';
+export { recomputeCodeGraph, buildCodeGraphSummary, formatCodeGraph } from './code-graph.js';
+export { describeCanvasSchema, validateStructuredCanvasPayload } from './canvas-schema.js';
+export { buildWebArtifactOnCanvas, executeWebArtifactBuild, openWebArtifactInCanvas, resolveWebArtifactScriptPath, resolveWorkspacePath, } from './web-artifacts.js';
+export { buildGraphSpec, buildJsonRenderViewerHtml, createJsonRenderNodeData, GRAPH_NODE_SIZE, JSON_RENDER_NODE_SIZE, normalizeAndValidateJsonRenderSpec, } from '../json-render/server.js';
+export type { CodeGraphSummary, CodeGraphEdge } from './code-graph.js';
+export type { MutationEntry, MutationSummary, SnapshotDiffResult } from './mutation-history.js';
+export type { WebArtifactBuildInput, WebArtifactBuildOutput, WebArtifactCanvasBuildResult, WebArtifactCanvasOpenResult, } from './web-artifacts.js';
+export type { GraphNodeInput, JsonRenderNodeInput, JsonRenderSpec } from '../json-render/server.js';
+export { traceManager } from './trace-manager.js';

package/dist/types/server/mcp-app-candidate.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MCP app candidate detection — standalone version.
+ *
+ * Removed PMX-specific imports (inferServerNameFromToolName, excalidraw-url helpers).
+ * Inlined the necessary URL detection logic.
+ */
+export interface McpAppToolCompletionInput {
+    name: string;
+    mcpServerName?: string;
+    mcpToolName?: string;
+    result: unknown;
+    content?: string;
+    detailedContent?: string;
+}
+export interface McpAppToolCandidate {
+    url: string;
+    inferredType: string;
+    keyHint: string;
+    sourceServer: string | null;
+    sourceTool: string;
+}
+export declare function inferMcpAppType(url: string): string;
+export declare function isLikelyMcpAppWebUrl(url: string): boolean;
+export declare function inferMcpAppSourceServer(input: Pick<McpAppToolCompletionInput, 'name' | 'mcpServerName'>, url: string): string | null;
+export declare function getMcpAppCandidateFromToolCompletion(data: McpAppToolCompletionInput): McpAppToolCandidate | null;

package/dist/types/server/mcp-app-host.d.ts

@@ -0,0 +1,65 @@
+export type McpAppHostCapabilityState = 'supported' | 'unsupported' | 'degraded';
+export interface McpAppHostCapability {
+    serverName: string;
+    state: McpAppHostCapabilityState;
+    reasonCode: string;
+    runtimeReady: boolean;
+    serverSupportsHost: boolean;
+    updatedAt: string;
+}
+export type McpAppHostSessionState = 'active' | 'background' | 'closed';
+export interface McpAppHostSession {
+    sessionId: string;
+    sourceServer: string | null;
+    sourceTool: string;
+    url: string;
+    inferredType: string;
+    trustedDomain: boolean;
+    state: McpAppHostSessionState;
+    createdAt: string;
+    lastSeenAt: string;
+    fallbackReason: string | null;
+    lastExternalOpenAt: string | null;
+}
+export interface McpAppHostSnapshot {
+    runtimeEnabled: boolean;
+    activeSessionId: string | null;
+    sessions: McpAppHostSession[];
+    capabilities: McpAppHostCapability[];
+    metrics: {
+        hostedOpens: number;
+        fallbackTotal: number;
+        fallbackByReason: Record<string, number>;
+    };
+}
+export interface McpAppCandidateInput {
+    sourceServer: string | null;
+    sourceTool: string;
+    url: string;
+    inferredType: string;
+    keyHint: string;
+}
+export interface McpAppHostRoutingResult {
+    mode: 'hosted' | 'fallback';
+    reasonCode: string;
+    trustedDomain: boolean;
+    capability: McpAppHostCapability;
+    session: McpAppHostSession | null;
+}
+export declare function isTrustedMcpAppDomain(url: string): boolean;
+export declare function registerMcpAppHostCapability(input: {
+    serverName: string;
+    state: McpAppHostCapabilityState;
+    reasonCode: string;
+    runtimeReady: boolean;
+    serverSupportsHost: boolean;
+}): McpAppHostCapability;
+export declare function preRegisterKnownMcpAppHostCapabilities(serverNames: string[]): void;
+export declare function routeMcpAppCandidateToHost(input: McpAppCandidateInput): McpAppHostRoutingResult;
+export declare function focusMcpAppHostSession(sessionId: string): McpAppHostSession | null;
+export declare function closeMcpAppHostSession(sessionId: string): McpAppHostSession | null;
+export declare function markMcpAppHostSessionOpenedExternally(sessionId: string): McpAppHostSession | null;
+export declare function listMcpAppHostSessions(options?: {
+    includeClosed?: boolean;
+}): McpAppHostSession[];
+export declare function getMcpAppHostSnapshot(): McpAppHostSnapshot;

package/dist/types/server/mcp-app-runtime.d.ts

@@ -0,0 +1,47 @@
+import type { CallToolResult, ListPromptsResult, ListResourcesResult, ListResourceTemplatesResult, ListToolsResult, ReadResourceResult, Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { McpUiResourceMeta } from '@modelcontextprotocol/ext-apps';
+export interface ExternalMcpHttpTransportConfig {
+    type: 'http';
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface ExternalMcpStdioTransportConfig {
+    type: 'stdio';
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export type ExternalMcpTransportConfig = ExternalMcpHttpTransportConfig | ExternalMcpStdioTransportConfig;
+export interface OpenMcpAppInput {
+    transport: ExternalMcpTransportConfig;
+    toolName: string;
+    toolArguments?: Record<string, unknown>;
+    serverName?: string;
+}
+export interface OpenMcpAppResult {
+    sessionId: string;
+    serverName: string;
+    toolName: string;
+    tool: Tool;
+    toolInput: Record<string, unknown>;
+    toolResult: CallToolResult;
+    resourceUri: string;
+    html: string;
+    resourceMeta?: McpUiResourceMeta;
+}
+export interface ExtAppModelContextUpdateInput {
+    content?: unknown[];
+    structuredContent?: Record<string, unknown>;
+}
+export declare function openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResult>;
+export declare function callMcpAppTool(sessionId: string, toolName: string, args?: Record<string, unknown>): Promise<CallToolResult>;
+export declare function readMcpAppResource(sessionId: string, uri: string): Promise<ReadResourceResult>;
+export declare function listMcpAppTools(sessionId: string): Promise<ListToolsResult>;
+export declare function listMcpAppResources(sessionId: string): Promise<ListResourcesResult>;
+export declare function listMcpAppResourceTemplates(sessionId: string): Promise<ListResourceTemplatesResult>;
+export declare function listMcpAppPrompts(sessionId: string): Promise<ListPromptsResult>;
+export declare function closeMcpAppSession(sessionId: string): void;
+export declare function closeAllMcpAppSessions(): void;
+export declare function hasMcpAppSession(sessionId: string): boolean;
+export declare function listMcpAppSessionIds(): string[];

package/dist/types/server/mutation-history.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Canvas Mutation History — Time Travel for PMX Canvas
+ *
+ * Records every canvas mutation in an in-memory ring buffer with forward/inverse
+ * closures for undo/redo. Provides a human-readable history timeline and
+ * snapshot diff capabilities.
+ *
+ * Design decisions:
+ * - In-memory only (not persisted) — history is session-scoped
+ * - Ring buffer caps at 200 entries to bound memory
+ * - forward/inverse closures capture cloned state at record time
+ * - _replaying flag prevents undo/redo from recording new entries
+ */
+import type { CanvasNodeState, CanvasEdge } from './canvas-state.js';
+export type MutationOp = 'addNode' | 'updateNode' | 'removeNode' | 'addEdge' | 'removeEdge' | 'clear' | 'arrange' | 'restoreSnapshot' | 'setPins' | 'batch' | 'viewport' | 'groupNodes' | 'ungroupNodes';
+export interface MutationEntry {
+    id: string;
+    timestamp: string;
+    description: string;
+    operationType: MutationOp;
+    forward: () => void;
+    inverse: () => void;
+}
+export interface MutationSummary {
+    id: string;
+    timestamp: string;
+    description: string;
+    operationType: MutationOp;
+    isCurrent: boolean;
+    isUndone: boolean;
+}
+export interface SnapshotDiffResult {
+    snapshotName: string;
+    addedNodes: {
+        id: string;
+        type: string;
+        title: string | null;
+    }[];
+    removedNodes: {
+        id: string;
+        type: string;
+        title: string | null;
+    }[];
+    modifiedNodes: {
+        id: string;
+        type: string;
+        title: string | null;
+        changes: string[];
+    }[];
+    addedEdges: {
+        id: string;
+        from: string;
+        to: string;
+        type: string;
+    }[];
+    removedEdges: {
+        id: string;
+        from: string;
+        to: string;
+        type: string;
+    }[];
+}
+declare class MutationHistory {
+    private entries;
+    /** Index of the last applied mutation. -1 means nothing applied / all undone. */
+    private cursor;
+    /** When true, mutations triggered by undo/redo are not recorded. */
+    private _replaying;
+    get isReplaying(): boolean;
+    /**
+     * Record a new mutation. Truncates any redo-able future, then appends.
+     * If called while replaying (undo/redo), the call is silently ignored.
+     */
+    record(entry: Omit<MutationEntry, 'id' | 'timestamp'>): void;
+    /** Undo the last applied mutation. Returns the entry that was undone, or null. */
+    undo(): MutationEntry | null;
+    /** Redo the next undone mutation. Returns the entry that was redone, or null. */
+    redo(): MutationEntry | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Get all entries with current/undone status for display. */
+    getSummaries(): MutationSummary[];
+    /** Human-readable timeline for the canvas://history resource. */
+    toHumanReadable(): string;
+    /** Number of recorded entries. */
+    get length(): number;
+    /** Clear all recorded mutations. Useful for isolated test runs. */
+    reset(): void;
+}
+/**
+ * Compare two canvas layouts and produce a structured diff.
+ */
+export declare function diffLayouts(snapshotName: string, snapshotLayout: {
+    nodes: CanvasNodeState[];
+    edges: CanvasEdge[];
+}, currentLayout: {
+    nodes: CanvasNodeState[];
+    edges: CanvasEdge[];
+}): SnapshotDiffResult;
+/**
+ * Format a diff result as human-readable text for MCP.
+ */
+export declare function formatDiff(diff: SnapshotDiffResult): string;
+export declare const mutationHistory: MutationHistory;
+export {};

package/dist/types/server/placement.d.ts

@@ -0,0 +1,37 @@
+import { type CanvasPlacementRect } from '../shared/placement.js';
+export { findOpenCanvasPosition, type CanvasPlacementRect } from '../shared/placement.js';
+export declare const GROUP_PAD = 40;
+export declare const GROUP_TITLEBAR_HEIGHT = 32;
+/**
+ * Compute bounding box for a group that should contain the given child rects.
+ * Returns position and size with padding, or null if no valid children.
+ */
+export declare function computeGroupBounds(children: CanvasPlacementRect[], defaultWidth?: number, defaultHeight?: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+export declare function computePackedGroupLayout<T extends CanvasPlacementRect & {
+    id: string;
+}>(children: T[]): {
+    positions: Map<string, {
+        x: number;
+        y: number;
+    }>;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+};
+export declare function resolveGroupCollision(bounds: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, existing: CanvasPlacementRect[]): {
+    x: number;
+    y: number;
+};

package/dist/types/server/server.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Standalone canvas server — extracted from PMX web-canvas/server.ts.
+ *
+ * Provides:
+ * - GET  /workbench              -> canvas SPA HTML
+ * - GET  /api/file?path=...      -> read markdown content
+ * - POST /api/file/save          -> persist markdown edits
+ * - POST /api/render             -> server-side markdown render (marked)
+ * - GET  /api/canvas/state       -> canvas layout
+ * - POST /api/canvas/update      -> batch node updates
+ * - POST /api/canvas/edge        -> add edge
+ * - DELETE /api/canvas/edge      -> remove edge
+ * - POST /api/canvas/prompt      -> canvas prompt
+ * - POST /api/canvas/context-pins -> update context pins
+ * - GET  /api/canvas/pinned-context -> get pinned context preamble
+ * - GET  /api/canvas/spatial-context -> spatial analysis (clusters, reading order, neighborhoods)
+ * - GET  /api/canvas/search?q=...  -> full-text search across nodes
+ * - GET  /api/canvas/code-graph   -> auto-detected file dependency graph
+ * - POST /api/canvas/undo         -> undo last mutation
+ * - POST /api/canvas/redo         -> redo last undone mutation
+ * - GET  /api/canvas/history      -> mutation history timeline
+ * - POST /api/canvas/json-render  -> create a native json-render node
+ * - POST /api/canvas/graph        -> create a native graph node
+ * - GET  /api/canvas/json-render/view?nodeId=... -> local json-render viewer
+ * - POST /api/canvas/web-artifact -> build bundled HTML artifact + optional canvas node
+ * - GET  /api/workbench/events   -> SSE event stream
+ * - GET  /api/workbench/state    -> workbench state snapshot
+ * - POST /api/workbench/intent   -> workbench intents
+ * - GET  /api/workbench/webview  -> Bun.WebView automation status
+ * - POST /api/workbench/webview/start -> start Bun.WebView automation session
+ * - POST /api/workbench/webview/evaluate -> evaluate JS in Bun.WebView automation session
+ * - POST /api/workbench/webview/resize -> resize Bun.WebView automation viewport
+ * - POST /api/workbench/webview/screenshot -> capture Bun.WebView automation screenshot
+ * - DELETE /api/workbench/webview -> stop Bun.WebView automation session
+ */
+export interface PrimaryWorkbenchEventPayload {
+    [key: string]: unknown;
+}
+export interface CanvasAutomationWebViewOptions {
+    backend?: 'webkit' | 'chrome';
+    width?: number;
+    height?: number;
+    chromePath?: string;
+    chromeArgv?: string[];
+    dataStoreDir?: string;
+}
+export interface CanvasAutomationWebViewStatus {
+    supported: boolean;
+    active: boolean;
+    headlessOnly: true;
+    url: string | null;
+    backend: 'webkit' | 'chrome' | null;
+    width: number | null;
+    height: number | null;
+    dataStoreDir: string | null;
+    startedAt: string | null;
+    lastError: string | null;
+}
+export declare function getCanvasAutomationWebViewStatus(): CanvasAutomationWebViewStatus;
+export declare function stopCanvasAutomationWebView(): Promise<boolean>;
+export declare function startCanvasAutomationWebView(url: string, options?: CanvasAutomationWebViewOptions): Promise<CanvasAutomationWebViewStatus>;
+export declare function evaluateCanvasAutomationWebView(expression: string): Promise<unknown>;
+export declare function resizeCanvasAutomationWebView(width: number, height: number): Promise<CanvasAutomationWebViewStatus>;
+export declare function screenshotCanvasAutomationWebView(options?: Record<string, unknown>): Promise<Uint8Array>;
+export interface PrimaryWorkbenchIntent {
+    id: number;
+    type: 'focus-primary' | 'refresh-artifact' | 'review-artifact' | 'focus-approval' | 'open-aux' | 'close-aux' | 'mcp-app-focus' | 'mcp-app-close' | 'trace-toggle' | 'trace-clear' | 'canvas-prompt';
+    payload: PrimaryWorkbenchEventPayload;
+    createdAt: string;
+}
+export interface PrimaryWorkbenchCanvasPromptRequest {
+    nodeId: string;
+    text: string;
+    displayText: string;
+    parentNodeId?: string;
+    contextNodeIds: string[];
+}
+type PrimaryWorkbenchCanvasPromptHandler = (request: PrimaryWorkbenchCanvasPromptRequest) => Promise<void>;
+export declare function setPrimaryWorkbenchAutoOpenEnabled(enabled: boolean): void;
+export declare function isPrimaryWorkbenchAutoOpenEnabled(): boolean;
+export declare function hasWorkbenchSubscribers(): boolean;
+export declare function setPrimaryWorkbenchCanvasPromptHandler(handler: PrimaryWorkbenchCanvasPromptHandler | null): void;
+export declare function buildMacBrowserOpenScript(appName: string, url: string): string;
+export declare function openUrlInExternalBrowser(url: string): boolean;
+export declare function emitPrimaryWorkbenchEvent(event: string, payload?: PrimaryWorkbenchEventPayload): void;
+export declare function consumePrimaryWorkbenchIntents(limit?: number): PrimaryWorkbenchIntent[];
+export declare function getPrimaryWorkbenchUrl(workspaceRoot?: string): string | null;
+export declare function syncCanvasBrowserOpenedFromSubscribers(): void;
+export declare function isCanvasBrowserOpened(): boolean;
+export declare function isCanvasBrowserOpening(): boolean;
+export declare function markCanvasBrowserOpened(): void;
+export declare function markCanvasBrowserOpening(): void;
+export declare function openPrimaryWorkbenchPath(pathLike: string, workspaceRoot?: string): string | null;
+export interface CanvasServerOptions {
+    port?: number;
+    workspaceRoot?: string;
+    autoOpenBrowser?: boolean;
+}
+export declare function startCanvasServer(options?: CanvasServerOptions): string | null;
+export declare function stopCanvasServer(): void;
+export declare function getCanvasServerPort(): number | null;
+export { closeMcpAppHostSession, focusMcpAppHostSession, getMcpAppHostSnapshot, isTrustedMcpAppDomain, listMcpAppHostSessions, markMcpAppHostSessionOpenedExternally, preRegisterKnownMcpAppHostCapabilities, registerMcpAppHostCapability, routeMcpAppCandidateToHost, } from './mcp-app-host.js';
+export type { McpAppCandidateInput, McpAppHostCapability, McpAppHostCapabilityState, McpAppHostRoutingResult, McpAppHostSession, McpAppHostSnapshot, } from './mcp-app-host.js';