pmx-canvas 0.1.0

package/dist/types/cli/agent.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env bun
+/**
+ * Agent-native CLI for pmx-canvas.
+ *
+ * Designed for non-interactive use by coding agents:
+ * - Every input is a flag (no interactive prompts)
+ * - JSON output by default
+ * - Progressive --help discovery
+ * - Fail fast with actionable errors
+ * - Idempotent operations where possible
+ * - --yes for destructive actions, --dry-run for preview
+ */
+export declare function runAgentCli(args: string[]): Promise<void>;

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/types/cli/watch.d.ts

@@ -0,0 +1,5 @@
+import { ALL_SEMANTIC_WATCH_EVENT_TYPES, formatCompactWatchEvent, SemanticWatchReducer, type SemanticWatchEvent, type SemanticWatchEventType, type SseMessage } from '../shared/semantic-attention.js';
+export { ALL_SEMANTIC_WATCH_EVENT_TYPES, formatCompactWatchEvent, SemanticWatchReducer, };
+export type { SemanticWatchEvent, SemanticWatchEventType, SseMessage, };
+export declare function parseSemanticEventFilter(raw: string | undefined): Set<SemanticWatchEventType>;
+export declare function parseSseStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseMessage>;

package/dist/types/client/App.d.ts

@@ -0,0 +1 @@
+export declare function App(): import("preact").JSX.Element;

package/dist/types/client/canvas/AttentionHistory.d.ts

@@ -0,0 +1 @@
+export declare function AttentionHistory(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/AttentionToast.d.ts

@@ -0,0 +1 @@
+export declare function AttentionToast(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/CanvasNode.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasNodeState } from '../types';
+interface CanvasNodeProps {
+    node: CanvasNodeState;
+    children: preact.ComponentChildren;
+    onContextMenu?: (e: MouseEvent, nodeId: string) => void;
+}
+export declare function CanvasNode({ node, children, onContextMenu }: CanvasNodeProps): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/canvas/CanvasViewport.d.ts

@@ -0,0 +1,8 @@
+import type { CanvasNodeState } from '../types';
+interface CanvasViewportProps {
+    onNodeContextMenu?: (e: MouseEvent, nodeId: string) => void;
+    onCanvasContextMenu?: (e: MouseEvent, canvasX: number, canvasY: number) => void;
+}
+export declare function getRenderableWorldNodes(allNodes: Iterable<CanvasNodeState>, focusedNodeId: string | null): CanvasNodeState[];
+export declare function CanvasViewport({ onNodeContextMenu, onCanvasContextMenu }: CanvasViewportProps): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/canvas/CommandPalette.d.ts

@@ -0,0 +1,4 @@
+export declare function CommandPalette({ onClose, onToggleMinimap, }: {
+    onClose: () => void;
+    onToggleMinimap: () => void;
+}): import("preact/src").JSX.Element;

package/dist/types/client/canvas/ContextMenu.d.ts

@@ -0,0 +1,24 @@
+export type MenuState = {
+    kind: 'node';
+    x: number;
+    y: number;
+    nodeId: string;
+} | {
+    kind: 'canvas';
+    x: number;
+    y: number;
+    canvasX: number;
+    canvasY: number;
+};
+export declare function useContextMenu(): {
+    menu: MenuState | null;
+    openNodeMenu: (e: MouseEvent, nodeId: string) => void;
+    openCanvasMenu: (e: MouseEvent, canvasX: number, canvasY: number) => void;
+    closeMenu: () => void;
+};
+interface ContextMenuProps {
+    menu: MenuState;
+    onClose: () => void;
+}
+export declare function ContextMenu({ menu, onClose }: ContextMenuProps): import("preact").JSX.Element | null;
+export {};

package/dist/types/client/canvas/ContextPinBar.d.ts

@@ -0,0 +1 @@
+export declare function ContextPinBar(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/ContextPinHud.d.ts

@@ -0,0 +1 @@
+export declare function ContextPinHud(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/DockedNode.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function DockedNode({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/canvas/EdgeLayer.d.ts

@@ -0,0 +1,8 @@
+import type { Signal } from '@preact/signals';
+import type { CanvasEdge, CanvasNodeState } from '../types';
+interface EdgeLayerProps {
+    nodes: Signal<Map<string, CanvasNodeState>>;
+    edges: Signal<Map<string, CanvasEdge>>;
+}
+export declare function EdgeLayer({ nodes, edges }: EdgeLayerProps): import("preact/src").JSX.Element | null;
+export {};

package/dist/types/client/canvas/ExpandedNodeOverlay.d.ts

@@ -0,0 +1 @@
+export declare function ExpandedNodeOverlay(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/FocusFieldLayer.d.ts

@@ -0,0 +1 @@
+export declare function FocusFieldLayer(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/Minimap.d.ts

@@ -0,0 +1,23 @@
+import type { Signal } from '@preact/signals';
+import type { CanvasEdge, CanvasNodeState, ViewportState } from '../types';
+interface MinimapBounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+interface MinimapFrame {
+    bounds: MinimapBounds;
+    scale: number;
+}
+export declare function computeMinimapFrame(nodeMap: Map<string, CanvasNodeState>, currentViewport: ViewportState, containerWidth: number, containerHeight: number): MinimapFrame;
+interface MinimapProps {
+    viewport: Signal<ViewportState>;
+    nodes: Signal<Map<string, CanvasNodeState>>;
+    edges: Signal<Map<string, CanvasEdge>>;
+    onNavigate: (x: number, y: number) => void;
+    containerWidth: number;
+    containerHeight: number;
+}
+export declare function Minimap({ viewport, nodes, edges, onNavigate, containerWidth, containerHeight, }: MinimapProps): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/canvas/SelectionBar.d.ts

@@ -0,0 +1 @@
+export declare function SelectionBar(): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/ShortcutOverlay.d.ts

@@ -0,0 +1,3 @@
+export declare function ShortcutOverlay({ onClose }: {
+    onClose: () => void;
+}): import("preact/src").JSX.Element;

package/dist/types/client/canvas/SnapshotPanel.d.ts

@@ -0,0 +1,7 @@
+export declare function SnapshotPanel({ open, onClose, anchorRef, }: {
+    open: boolean;
+    onClose: () => void;
+    anchorRef: {
+        current: HTMLButtonElement | null;
+    };
+}): import("preact/src").JSX.Element | null;

package/dist/types/client/canvas/snap-guides.d.ts

@@ -0,0 +1,23 @@
+import type { CanvasNodeState } from '../types';
+export interface GuideLine {
+    axis: 'x' | 'y';
+    pos: number;
+    from: number;
+    to: number;
+}
+export interface SnapResult {
+    x: number;
+    y: number;
+    guides: GuideLine[];
+}
+/** Active guide lines to render. Null when not dragging. */
+export declare const activeGuides: import("@preact/signals-core").Signal<GuideLine[] | null>;
+/** Call at drag-start to pre-compute reference edges from stationary nodes. */
+export declare function buildSnapCache(dragId: string, allNodes: Iterable<CanvasNodeState>): void;
+/** Call at drag-end to clear the cache. */
+export declare function clearSnapCache(): void;
+/**
+ * Snap a dragging node's proposed position to cached reference edges.
+ * Must call buildSnapCache() before the first call in a drag session.
+ */
+export declare function snapToGuides(proposedX: number, proposedY: number, nodeW: number, nodeH: number): SnapResult;

package/dist/types/client/canvas/use-node-drag.d.ts

@@ -0,0 +1,15 @@
+import type { Signal } from '@preact/signals';
+import type { ViewportState } from '../types';
+interface NodeDragOptions {
+    nodeId: string;
+    viewport: Signal<ViewportState>;
+    onMove: (id: string, x: number, y: number) => void;
+    onDragEnd: () => void;
+}
+/**
+ * Hook for dragging canvas nodes by their title bar.
+ * Converts screen-space pointer delta to canvas-space position delta
+ * (accounting for current viewport scale).
+ */
+export declare function useNodeDrag({ nodeId, viewport, onMove, onDragEnd }: NodeDragOptions): (e: PointerEvent, currentX: number, currentY: number) => void;
+export {};

package/dist/types/client/canvas/use-node-resize.d.ts

@@ -0,0 +1,15 @@
+import type { Signal } from '@preact/signals';
+import type { ViewportState } from '../types';
+interface NodeResizeOptions {
+    nodeId: string;
+    viewport: Signal<ViewportState>;
+    onResize: (id: string, width: number, height: number) => void;
+    onResizeEnd: () => void;
+}
+/**
+ * Hook for resizing canvas nodes via a corner drag handle.
+ * Converts screen-space pointer delta to canvas-space size delta
+ * (accounting for current viewport scale).
+ */
+export declare function useNodeResize({ nodeId, viewport, onResize, onResizeEnd }: NodeResizeOptions): (e: PointerEvent, currentWidth: number, currentHeight: number) => void;
+export {};

package/dist/types/client/canvas/use-pan-zoom.d.ts

@@ -0,0 +1,16 @@
+import type { Signal } from '@preact/signals';
+import type { ViewportState } from '../types';
+interface PanZoomOptions {
+    viewport: Signal<ViewportState>;
+    onViewportChange: (v: ViewportState) => void;
+    onViewportCommit: (v: ViewportState) => void;
+}
+/**
+ * Hook that wires up pan/zoom interactions on a container element.
+ * - Wheel + Ctrl/Cmd: zoom centered on pointer
+ * - Wheel without modifier: pan
+ * - Pointer drag on background: pan
+ * - Pinch (touch): zoom
+ */
+export declare function usePanZoom({ viewport, onViewportChange, onViewportCommit }: PanZoomOptions): import("preact/src").RefObject<HTMLDivElement>;
+export {};

package/dist/types/client/ext-app/bridge.d.ts

@@ -0,0 +1,161 @@
+type JsonRpcId = string | number | null;
+interface JsonRpcBase {
+    jsonrpc: '2.0';
+}
+interface JsonRpcRequestMessage extends JsonRpcBase {
+    id: JsonRpcId;
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcNotificationMessage extends JsonRpcBase {
+    method: string;
+    params?: unknown;
+}
+interface JsonRpcSuccessResponse extends JsonRpcBase {
+    id: JsonRpcId;
+    result: unknown;
+}
+interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+interface JsonRpcErrorResponse extends JsonRpcBase {
+    id: JsonRpcId;
+    error: JsonRpcErrorObject;
+}
+type JsonRpcResponseMessage = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+type JsonRpcMessage = JsonRpcRequestMessage | JsonRpcNotificationMessage | JsonRpcResponseMessage;
+type DisplayMode = 'inline' | 'fullscreen' | 'pip';
+interface ImplementationInfo {
+    name: string;
+    version: string;
+}
+type HostCapabilities = Record<string, unknown>;
+interface HostContext {
+    theme?: 'light' | 'dark';
+    platform?: string;
+    displayMode?: DisplayMode;
+    containerDimensions?: {
+        maxHeight?: number;
+        width?: number;
+        height?: number;
+    };
+    [key: string]: unknown;
+}
+interface HostOptions {
+    hostContext?: HostContext;
+}
+interface RequestExtra {
+    signal: AbortSignal;
+    sessionId?: string;
+}
+interface SizeChangedParams {
+    width?: number;
+    height?: number;
+}
+interface OpenLinkParams {
+    url: string;
+}
+interface DownloadFileParams {
+    contents?: unknown[];
+}
+interface RequestDisplayModeParams {
+    mode: DisplayMode;
+}
+interface RequestDisplayModeResult {
+    mode: DisplayMode;
+}
+interface ToolCallParams {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+interface ToolInputParams {
+    arguments?: Record<string, unknown>;
+}
+interface ToolCancelledParams {
+    reason?: string;
+}
+interface SandboxReadyParams {
+    html?: string;
+    sandbox?: string;
+}
+interface LoggingMessageParams {
+    level?: string;
+    logger?: string;
+    data?: unknown;
+}
+type RequestHandler<TParams = unknown, TResult = unknown> = (params: TParams, extra: RequestExtra) => Promise<TResult> | TResult;
+export declare class PostMessageTransport {
+    private readonly eventTarget;
+    private readonly eventSource;
+    private messageListener;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JsonRpcMessage, extra?: {
+        sessionId?: string;
+    }) => void;
+    sessionId?: string;
+    setProtocolVersion?: (version: string) => void;
+    constructor(eventTarget: Window | undefined, eventSource: MessageEventSource | null);
+    start(): Promise<void>;
+    send(message: JsonRpcMessage): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class AppBridge {
+    private readonly client;
+    private readonly hostInfo;
+    private readonly capabilities;
+    private readonly requestHandlers;
+    private readonly notificationHandlers;
+    private readonly pendingRequests;
+    private transport;
+    private nextRequestId;
+    private appCapabilities?;
+    private hostContext;
+    private appInfo?;
+    onping?: (params: Record<string, never>, extra: RequestExtra) => void;
+    constructor(client: null, hostInfo: ImplementationInfo, capabilities: HostCapabilities, options?: HostOptions);
+    getAppCapabilities(): Record<string, unknown> | undefined;
+    getAppVersion(): ImplementationInfo | undefined;
+    private setNotificationHandler;
+    private setRequestHandler;
+    set onsizechange(callback: (params: SizeChangedParams) => void);
+    set onsandboxready(callback: (params: Record<string, never>) => void);
+    set oninitialized(callback: (params: Record<string, never>) => void);
+    set onmessage(callback: RequestHandler<Record<string, unknown>, Record<string, unknown>>);
+    set onopenlink(callback: RequestHandler<OpenLinkParams, Record<string, unknown>>);
+    set ondownloadfile(callback: RequestHandler<DownloadFileParams, Record<string, unknown>>);
+    set onrequestteardown(callback: (params: Record<string, never>) => void);
+    set onrequestdisplaymode(callback: RequestHandler<RequestDisplayModeParams, RequestDisplayModeResult>);
+    set onloggingmessage(callback: (params: LoggingMessageParams) => void);
+    set onupdatemodelcontext(callback: RequestHandler<Record<string, unknown>, Record<string, unknown>>);
+    set oncalltool(callback: RequestHandler<ToolCallParams, unknown>);
+    set onlisttools(callback: RequestHandler<Record<string, unknown>, unknown>);
+    set onlistresources(callback: RequestHandler<Record<string, unknown>, unknown>);
+    set onlistresourcetemplates(callback: RequestHandler<Record<string, unknown>, unknown>);
+    set onreadresource(callback: RequestHandler<Record<string, unknown>, unknown>);
+    set onlistprompts(callback: RequestHandler<Record<string, unknown>, unknown>);
+    getCapabilities(): HostCapabilities;
+    setHostContext(hostContext: HostContext): void;
+    sendHostContextChange(params: HostContext): Promise<void>;
+    sendToolInput(params: ToolInputParams): Promise<void>;
+    sendToolInputPartial(params: ToolInputParams): Promise<void>;
+    sendToolResult(params: unknown): Promise<void>;
+    sendToolCancelled(params: ToolCancelledParams): Promise<void>;
+    sendSandboxResourceReady(params: SandboxReadyParams): Promise<void>;
+    teardownResource(params: Record<string, never>): Promise<Record<string, unknown>>;
+    sendResourceTeardown: (params: Record<string, never>) => Promise<Record<string, unknown>>;
+    sendToolListChanged(params?: Record<string, unknown>): Promise<void>;
+    sendResourceListChanged(params?: Record<string, unknown>): Promise<void>;
+    sendPromptListChanged(params?: Record<string, unknown>): Promise<void>;
+    connect(transport: PostMessageTransport): Promise<void>;
+    private handleIncomingMessage;
+    private handleRequest;
+    private handleInitialize;
+    private sendSuccess;
+    private sendError;
+    private notification;
+    private request;
+}
+export {};

package/dist/types/client/icons.d.ts

@@ -0,0 +1,70 @@
+import type { JSX } from 'preact';
+interface IconProps {
+    size?: number;
+    class?: string;
+}
+/** Expand-arrows — fit all nodes */
+export declare function IconFitAll(p: IconProps): JSX.Element;
+/** Framed crosshair — reset view 1:1 */
+export declare function IconResetView(p: IconProps): JSX.Element;
+/** Magnifier with + */
+export declare function IconZoomIn(p: IconProps): JSX.Element;
+/** Magnifier with - */
+export declare function IconZoomOut(p: IconProps): JSX.Element;
+/** 2x2 grid with links — auto-arrange */
+export declare function IconArrange(p: IconProps): JSX.Element;
+/** Frame with focused inner corner — minimap */
+export declare function IconMinimap(p: IconProps): JSX.Element;
+/** Sun with rays */
+export declare function IconSun(p: IconProps): JSX.Element;
+/** Crescent moon */
+export declare function IconMoon(p: IconProps): JSX.Element;
+/** Camera — snapshots */
+export declare function IconSnapshot(p: IconProps): JSX.Element;
+/** Bullseye — trace toggle */
+export declare function IconTrace(p: IconProps): JSX.Element;
+/** X in circle — clear trace */
+export declare function IconClearTrace(p: IconProps): JSX.Element;
+/** Magnifying glass — search */
+export declare function IconSearch(p: IconProps): JSX.Element;
+/** Keyboard — shortcuts */
+export declare function IconShortcuts(p: IconProps): JSX.Element;
+/** Half-lit circle — theme toggle (generic). */
+export declare function IconTheme(p: IconProps): JSX.Element;
+/** Framed pin — context pinning. */
+export declare function IconPin(p: IconProps): JSX.Element;
+/** Focus Field — PMX Canvas brand mark (concentric rounded squares → lit core). */
+export declare function IconLogo({ size, class: className }: IconProps): JSX.Element;
+/** Framed document with lines — markdown */
+export declare function IconNodeMarkdown(p: IconProps): JSX.Element;
+/** Framed prompt with chevron and reply tail — prompt */
+export declare function IconNodePrompt(p: IconProps): JSX.Element;
+/** Framed response with three dots and reply tail — response */
+export declare function IconNodeResponse(p: IconProps): JSX.Element;
+/** Dog-eared document — file */
+export declare function IconNodeFile(p: IconProps): JSX.Element;
+/** Framed landscape with sun — image */
+export declare function IconNodeImage(p: IconProps): JSX.Element;
+/** Browser-chrome frame — webpage */
+export declare function IconNodeWebpage(p: IconProps): JSX.Element;
+/** Card with a pushpin — context */
+export declare function IconNodeContext(p: IconProps): JSX.Element;
+/** Dashed frame with three child cards — group */
+export declare function IconNodeGroup(p: IconProps): JSX.Element;
+/** Framed list with leading dot — status */
+export declare function IconNodeStatus(p: IconProps): JSX.Element;
+/** Framed spike chart with end dot — trace node */
+export declare function IconNodeTrace(p: IconProps): JSX.Element;
+/** Ledger book with spine — ledger */
+export declare function IconNodeLedger(p: IconProps): JSX.Element;
+/** Framed MCP wordmark — mcp-app */
+export declare function IconNodeMcpApp(p: IconProps): JSX.Element;
+/** Framed arrow-out — ext-app */
+export declare function IconNodeExtApp(p: IconProps): JSX.Element;
+/** Framed braces — json-render */
+export declare function IconNodeJsonRender(p: IconProps): JSX.Element;
+/** Framed nodes & edges — graph */
+export declare function IconNodeGraph(p: IconProps): JSX.Element;
+/** Map a node type → its Focus Field icon component. */
+export declare function getNodeIcon(type: string): (p: IconProps) => JSX.Element;
+export {};

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

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

package/dist/types/client/nodes/ContextNode.d.ts

@@ -0,0 +1,34 @@
+import type { CanvasNodeState } from '../types';
+interface ContextCard {
+    key?: string;
+    title?: string;
+    label?: string;
+    summary?: string;
+    path?: string;
+    pathDisplay?: string;
+    category?: string;
+    sourceKind?: string;
+    state?: string;
+    required?: boolean;
+}
+export interface ContextCardDisplay {
+    title: string;
+    summary: string;
+    pathDisplay: string;
+    category?: string;
+    sourceKind: string;
+    status: string;
+    required: boolean;
+}
+export interface ContextNodeFallbackDisplay {
+    title: string;
+    summary: string;
+    path: string;
+}
+export declare function normalizeContextCardDisplay(card: ContextCard): ContextCardDisplay;
+export declare function normalizeContextNodeFallback(nodeData: Record<string, unknown>): ContextNodeFallbackDisplay | null;
+export declare function ContextNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/nodes/ExtAppFrame.d.ts

@@ -0,0 +1,18 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { AppBridge } from '@modelcontextprotocol/ext-apps/app-bridge';
+import type { CanvasNodeState } from '../types';
+type IframeLoadTarget = Pick<HTMLIFrameElement, 'addEventListener' | 'removeEventListener' | 'contentDocument'>;
+type ExtAppBridgeNotifications = Pick<AppBridge, 'sendToolInput' | 'sendToolResult'>;
+type DisplayMode = 'inline' | 'fullscreen' | 'pip';
+export declare function waitForExtAppFrameLoad(target: IframeLoadTarget): Promise<void>;
+export declare function getExtAppBridgeInitKey(node: CanvasNodeState, retryKey: number): string;
+export declare function resolveExtAppDisplayModeRequest(requestedMode: DisplayMode, isExpanded: boolean): {
+    nextMode: DisplayMode;
+    shouldExpand: boolean;
+    shouldCollapse: boolean;
+};
+export declare function sendExtAppBootstrapState(bridge: ExtAppBridgeNotifications, toolInput: Record<string, unknown>, toolResult: CallToolResult | undefined): Promise<void>;
+export declare function ExtAppFrame({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/nodes/FileNode.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasNodeState } from '../types';
+export declare function FileNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/GroupNode.d.ts

@@ -0,0 +1,6 @@
+import type { CanvasNodeState } from '../types';
+interface GroupNodeProps {
+    node: CanvasNodeState;
+}
+export declare function GroupNode({ node }: GroupNodeProps): import("preact/src").JSX.Element;
+export {};

package/dist/types/client/nodes/ImageNode.d.ts

@@ -0,0 +1,10 @@
+import type { CanvasNodeState } from '../types';
+/**
+ * Image node renderer.
+ * Supports: file paths (served via /api/canvas/image/:nodeId), data URIs, and URLs.
+ * Features: fit-to-container, zoom in/out within node, pan when zoomed.
+ */
+export declare function ImageNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/InlineFormatBar.d.ts

@@ -0,0 +1,7 @@
+import type { RefObject } from 'preact';
+/** Floating selection toolbar for a contentEditable host. Mounts once; while
+ *  visible, positions itself above the current selection's viewport rect. */
+export declare function InlineFormatBar({ hostRef, onChange, }: {
+    hostRef: RefObject<HTMLElement>;
+    onChange: () => void;
+}): import("preact").JSX.Element | null;

package/dist/types/client/nodes/InlineMarkdownEditor.d.ts

@@ -0,0 +1,14 @@
+/** Fully inline WYSIWYG editor. The rendered HTML is the editor.
+ *
+ *  Two persistence signals:
+ *  - `onChange(md)` — fires on every input. Caller typically debounces.
+ *  - `onSave(md)`  — fires on ⌘S and blur. Caller should persist immediately
+ *    and cancel any pending debounced save, since `md` is the authoritative
+ *    latest content. Both receive freshly-serialized markdown so the caller
+ *    never reads a stale state snapshot. */
+export declare function InlineMarkdownEditor({ initialHtml, className, onChange, onSave, }: {
+    initialHtml: string;
+    className?: string;
+    onChange: (markdown: string) => void;
+    onSave?: (markdown: string) => void;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/LedgerNode.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function LedgerNode({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/MarkdownNode.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'preact';
+import type { CanvasNodeState } from '../types';
+export declare function MarkdownNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): JSX.Element;

package/dist/types/client/nodes/McpAppNode.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function McpAppNode({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/MdFormatBar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Floating format toolbar that appears above text selections in markdown textareas.
+ */
+export declare function MdFormatBar({ textareaRef }: {
+    textareaRef: {
+        current: HTMLTextAreaElement | null;
+    };
+}): import("preact/src").JSX.Element | null;

package/dist/types/client/nodes/PromptNode.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasNodeState } from '../types';
+export declare function PromptNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/ResponseNode.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasNodeState } from '../types';
+export declare function ResponseNode({ node, expanded, }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/StatusNode.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function StatusNode({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/StatusSummary.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function StatusSummary({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/TraceNode.d.ts

@@ -0,0 +1,4 @@
+import type { CanvasNodeState } from '../types';
+export declare function TraceNode({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element;

package/dist/types/client/nodes/WebpageNode.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasNodeState } from '../types';
+export declare function WebpageNode({ node, expanded }: {
+    node: CanvasNodeState;
+    expanded?: boolean;
+}): import("preact/src").JSX.Element;