pmx-canvas 0.9.3 → 0.11.0

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

@@ -7,11 +7,13 @@ export declare function BarPortal({ children }: {
  * Styled hover/focus tooltip for bar controls — the replacement for native
  * `title` hints, which are delay-gated and never render in embedded panes.
  */
-export declare function BarHint({ label, shortcut, body, align, side, tapToOpen, fitWithin, children, }: {
+export declare function BarHint({ id, label, shortcut, body, align, side, tapToOpen, fitWithin, children, }: {
+    /** Optional description target for the control's aria-describedby. */
+    id?: string;
     label: string;
     shortcut?: string;
-    /** One or two plain sentences under the label — the explanation a native `title` used to hide. */
-    body?: string;
+    /** Explanatory text, optionally split into readable paragraphs. */
+    body?: ComponentChildren;
     align?: 'start' | 'center' | 'end';
     /** Which way the tooltip opens. Bars at the bottom of the region open 'up'. */
     side?: 'down' | 'up';

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

@@ -4,17 +4,6 @@ export declare function nearestNodeInDirection(from: CanvasNodeState, dir: {
     dx: number;
     dy: number;
 }, candidates: Iterable<CanvasNodeState>): CanvasNodeState | null;
-/**
- * How much to enlarge node chrome (title bar, badges, icons) when zoomed out so
- * it stays legible. Full inverse compensation is capped at 2.2x — but the cap
- * alone ignored the node it is drawn on, so on SHORT nodes the growing bar ate
- * the body: a 116px-tall section label at 46% zoom gave the title bar 72% of the
- * node and left 14px for text that needed 41, so the markdown was simply cut off.
- * The scale is therefore also bounded by the node's own height, keeping the bar
- * under MAX_TITLEBAR_HEIGHT_RATIO of it. Tall nodes are unaffected (their height
- * never binds); pass height 0 for collapsed/auto-height nodes to skip the bound.
- */
-export declare function nodeChromeScale(viewportScale: number, nodeHeight: number, nodeWidth?: number): number;
 interface CanvasNodeProps {
     node: CanvasNodeState;
     children: preact.ComponentChildren;

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

@@ -22,7 +22,6 @@ export type EdgeLayerPart = 'lines' | 'pills' | 'pill-hits';
 interface EdgeLayerProps {
     nodes: Signal<Map<string, CanvasNodeState>>;
     edges: Signal<Map<string, CanvasEdge>>;
-    part: EdgeLayerPart;
 }
-export declare function EdgeLayer({ nodes, edges, part }: EdgeLayerProps): import("preact/src").JSX.Element | null;
+export declare function EdgeLayer({ nodes, edges }: EdgeLayerProps): import("preact/src").JSX.Element | null;
 export {};

package/dist/types/client/canvas/auto-fit.d.ts

@@ -2,7 +2,6 @@ import type { CanvasNodeState } from '../types';
 export declare const AUTO_FIT_TITLEBAR_HEIGHT = 37;
 export declare const AUTO_FIT_MAX_HEIGHT = 600;
 export declare const AUTO_FIT_MAX_HEIGHT_IFRAME = 1400;
-export declare const AUTO_FIT_BODY_PADDING = 24;
 /** DOM-content nodes (markdown/status/file/…) whose body scrollHeight is directly
  *  measurable — the one-shot ResizeObserver auto-fit in CanvasNode handles these. */
 export declare function shouldAutoFitNode(node: CanvasNodeState): boolean;
@@ -12,11 +11,11 @@ export declare function shouldContentFitIframeNode(node: CanvasNodeState): boole
 /**
  * Grow-only target height from a surface-reported content height. Returns null
  * when the node is exempt, the report is non-positive, or the node already fits
- * (so it never shrinks — monotonic growth can't oscillate). Adds the titlebar +
- * node-body padding so the content fully clears (no residual inner scrollbar),
- * capped at the iframe ceiling.
+ * (so it never shrinks). Callers measure the actual chrome in world pixels,
+ * including zoom-compensated headers and any captions. A fixed padding allowance
+ * makes a full-height viewer grow again on every content-height report.
  */
-export declare function computeContentGrowHeight(node: CanvasNodeState, contentHeight: number): number | null;
+export declare function computeContentGrowHeight(node: CanvasNodeState, contentHeight: number, chromeHeight: number): number | null;
 /** Keep an automatically growing card clear without moving its neighbors or
  * changing its column. Groups and screen-pinned cards retain authored placement. */
 export declare function contentFitPosition(node: CanvasNodeState, height: number, allNodes: CanvasNodeState[]): CanvasNodeState['position'];

package/dist/types/client/mermaid-entry.d.ts

@@ -5,7 +5,6 @@
  * HTML-escaped diagram source in `<pre class="mermaid-source">`; this script
  * reads it back via textContent, renders it to SVG, and re-renders when the
  * parent canvas live-switches the theme (the theme bridge toggles the document's
- * `data-theme` attribute). Keeping mermaid out of the main SPA bundle keeps the
- * canvas boot lean — only mermaid-node surfaces pay for the library.
+ * `data-theme` attribute). Standalone views and exports share the canvas renderer.
  */
 export {};

package/dist/types/client/mermaid-render.d.ts

@@ -0,0 +1 @@
+export declare function renderMermaid(source: string): Promise<string>;

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

@@ -1,5 +1,5 @@
 import type { CanvasNodeState } from '../types';
-/** Native text-only cross-board link. Target identity is the durable board id. */
+/** Target identity is the durable board id; a missing target can be relinked. */
 export declare function BoardNode({ node }: {
     node: CanvasNodeState;
 }): import("preact/src").JSX.Element;

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

@@ -1,100 +1,18 @@
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { AppBridge } from '@modelcontextprotocol/ext-apps/app-bridge';
 import type { CanvasNodeState } from '../types';
-type ExtAppBridgeNotifications = Pick<AppBridge, 'sendToolInput' | 'sendToolResult'>;
 type DisplayMode = 'inline' | 'fullscreen' | 'pip';
-/** Paint probe outcome: only a content-carrying tick counts as painted. */
-export type PaintProbeVerdict = 'content-verified' | 'tick-no-content' | 'timeout';
-interface ExtAppHostDimensionsTarget {
-    clientWidth?: number;
-    clientHeight?: number;
-    getBoundingClientRect(): Pick<DOMRectReadOnly, 'width' | 'height'>;
-}
-/**
- * Finding F (0.2.4): detect a WebKit-only host — Safari or a WKWebView (e.g. the
- * GitHub Copilot app's embedded panel). Blink engines (Chrome / Chromium / Edge /
- * the Codex browser, all of which carry a Chrome/Chromium/CriOS/Edg token) and
- * Android WebView are excluded, as is Gecko (no `AppleWebKit`). Used to gate the
- * one-time ext-app iframe repaint remount to the only engine that exhibits the
- * present-at-load black-tile paint race, so the remount is a strict no-op
- * everywhere we can test (Chrome / Codex / Playwright).
- */
-export declare function isWebKitOnlyHost(userAgent: string): boolean;
-/**
- * Finding N (0.4.7 report): the GitHub Copilot panel's WKWebView reports
- * `document.visibilityState === 'hidden'` CONTINUOUSLY — the workbench document
- * never transitions to 'visible' even with the panel open and on-screen. Two
- * things break as a result: the `visibilitychange` re-arm below can never fire
- * (there is no transition to listen for), and `paint-ok` becomes a false green —
- * the app document happily answers the double-rAF paint probe while the
- * compositor still shows black. The instrumented trail from that session carries
- * `visibility: "hidden"` on essentially every recovery event.
- *
- * So: when the document CLAIMS hidden but the frame is demonstrably on-screen,
- * do not trust the claim — spend one more recovery round as if visible. A host
- * that ever reports 'visible' has a working signal and is left to the
- * visibilitychange path, which keeps a genuinely backgrounded panel quiet.
- */
-export declare function shouldAssumeVisibleRearm(options: {
-    userAgent: string;
-    visibilityState: string;
-    rect: {
-        top: number;
-        left: number;
-        bottom: number;
-        right: number;
-        width: number;
-        height: number;
-    };
-    viewport: {
-        width: number;
-        height: number;
-    };
-    alreadyRearmed: boolean;
-}): boolean;
-export declare const WEBKIT_REMOUNT_SETTLE_MS = 1000;
-export interface WebkitRemountTask {
-    /** Perform the remount. Return false if the node no longer needs it (skips the boot wait). */
-    remount: () => boolean;
-    /** Resolves when the remounted app genuinely boots AND finishes its bootstrap replay, or after a bounded timeout. */
-    awaitBoot: () => Promise<void>;
-}
-export declare function extAppRecoveryLog(nodeId: string, event: string): void;
-export declare function enqueueWebkitRemount(task: WebkitRemountTask): 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 resolveExtAppSandbox(value: unknown): string;
 export declare function buildExtAppAxBridgeScript(axToken: string, nodeId: string): string;
-/**
- * Boot beacon injected into EVERY ext-app document (not gated on AX): posts one
- * parent message the moment the iframe's scripts execute. This is the liveness
- * signal the WebKit never-booted watchdog keys on — it distinguishes an app
- * that is alive but boots via the 1200ms bootstrap fallback (e.g. a non-SDK
- * widget that never sends ui/notifications/initialized) from a dead window
- * whose scripts never ran. Without it, the watchdog treated every
- * fallback-booted app as never-booted and remounted it up to the attempt cap —
- * a reboot/flicker loop for exactly the apps the fallback exists to support
- * (0.3.2 pre-release review). The token scopes the message to this component;
- * the host also checks event.source against the live iframe.
- */
-export declare function buildExtAppBootBeaconScript(frameToken: string, nodeId: string): string;
-/**
- * Base styles injected into every ext-app document (Finding Q, 0.3.4 report):
- * apps aspect-fit their drawn surface to the frame width, and on narrow/tall
- * tiles the leftover region shows the app document's own body background —
- * pure black for the hosted Excalidraw bundle, in every engine. Making the
- * app document transparent lets the host iframe's theme background
- * (var(--c-panel)) show through the letterbox instead. Background only — app
- * content, its drawn scene, and its own foreground styling are untouched.
- */
 export declare function buildExtAppSurfaceBaseStyles(): string;
-export declare function injectExtAppAxBridgeScript(html: string, axBridgeScript: string): string;
-export declare function resolveExtAppContainerDimensions(target: ExtAppHostDimensionsTarget | null | undefined, fallback: {
+export declare function injectExtAppAxBridgeScript(html: string, script: string): string;
+export declare function resolveExtAppContainerDimensions(target: {
+    clientWidth?: number;
+    clientHeight?: number;
+    getBoundingClientRect(): Pick<DOMRectReadOnly, 'width' | 'height'>;
+} | null | undefined, fallback: {
     width: number;
     height: number;
 }): {
@@ -102,9 +20,8 @@ export declare function resolveExtAppContainerDimensions(target: ExtAppHostDimen
     height: number;
 };
 export declare function shouldApplyExtAppSizeChange(height: unknown, isExpanded: boolean): height is number;
-export declare function resolveExtAppInlineFrameHeight(appHeight: number, hostHeight: number): number;
 export declare function ExtAppFrame({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;
-}): import("preact/src").JSX.Element;
+}): import("preact/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,30 +1,6 @@
-import type { RefObject } from 'preact';
 import type { CanvasNodeState } from '../types';
 export declare function isSameOriginFrameDocumentUrl(url: string, origin?: string): boolean;
-type ViewerFrameSource = {
-    src?: string;
-    srcdoc?: string;
-};
-/**
- * Keep the last painted viewer in front while its replacement navigates. Viewer
- * specs are immutable documents, so updates normally change `?v=` and reload the
- * iframe; putting the new document behind the old one conceals Chromium's white
- * navigation paint without suppressing rendering. Wait for restore and render commit,
- * then two animation frames before the old viewer is removed.
- */
-export declare function RefreshingViewerFrame({ source, iframeRef, onLoad, onDocumentLoad, title, className, sandbox, allow, tabIndex, }: {
-    source: ViewerFrameSource;
-    iframeRef: RefObject<HTMLIFrameElement>;
-    onLoad: () => void;
-    onDocumentLoad?: (frame: HTMLIFrameElement, signal: AbortSignal) => void | Promise<boolean | 'cancelled' | void>;
-    title: string;
-    className?: string;
-    sandbox?: string;
-    allow?: string;
-    tabIndex?: number;
-}): import("preact").JSX.Element;
 export declare function McpAppNode({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;
-}): import("preact").JSX.Element;
-export {};
+}): import("preact/jsx-runtime").JSX.Element;

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

@@ -1,12 +1,5 @@
 import type { CanvasNodeState } from '../types';
-/**
- * Mermaid diagram node — a display-only iframe surface. The server renders the
- * surface document (escaped diagram source + /canvas/mermaid-entry.js) at
- * /api/canvas/surface/:id; the iframe and "Open as site" share that one render
- * path, exactly like html nodes. Minimal subset of HtmlNode: theme push and
- * content-height growth, no AX bridge, no presentation mode.
- */
 export declare function MermaidNode({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;
-}): import("preact/jsx-runtime").JSX.Element;
+}): import("preact/src").JSX.Element;

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

@@ -0,0 +1,29 @@
+import type { JSX, RefObject } from 'preact';
+export declare const VIEWER_LOAD_DEADLINE_MS = 10000;
+export type ViewerSource = {
+    src?: string;
+    srcdoc?: string;
+    error?: boolean;
+    retry?: () => void;
+};
+type LoadDocument = (frame: HTMLIFrameElement, signal: AbortSignal) => Promise<boolean | 'cancelled' | undefined> | undefined;
+type MountFrame = (frame: HTMLIFrameElement, fail: () => void) => () => void;
+/** The document acknowledges mounting before its frame-gated paint signal. */
+export declare function waitForViewerPaint(frame: HTMLIFrameElement, token: string, signal: AbortSignal): Promise<boolean>;
+/** Preserve the painted document until its replacement restores and paints. */
+export declare function RefreshingViewerFrame({ source, identity, iframeRef, onLoad, onMount, onOpen, onDocumentLoad, title, className, sandbox, allow, tabIndex, referrerPolicy, }: {
+    source: ViewerSource;
+    identity?: string;
+    iframeRef: RefObject<HTMLIFrameElement>;
+    onLoad?: () => void;
+    onMount?: MountFrame;
+    onOpen?: () => void;
+    onDocumentLoad?: LoadDocument;
+    title: string;
+    className?: string;
+    sandbox?: string;
+    allow?: string;
+    tabIndex?: number;
+    referrerPolicy?: JSX.IntrinsicElements['iframe']['referrerPolicy'];
+}): JSX.Element;
+export {};

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

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

package/dist/types/client/nodes/iframe-document-url.d.ts

@@ -1,9 +1,3 @@
-export declare function createIframeDocumentUrl(html: string, sandbox: string): Promise<string>;
-export declare function useIframeDocument(html: string, sandbox: string): {
-    attributes: {
-        src?: string;
-        srcdoc?: string;
-    };
-    ready: boolean;
-    key: string;
-};
+import { type ViewerSource } from './ViewerFrame';
+export declare function createIframeDocumentUrl(html: string, sandbox: string, signal?: AbortSignal): Promise<string>;
+export declare function useIframeDocument(html: string, sandbox: string): ViewerSource;

package/dist/types/client/nodes/primitive-copy.d.ts

@@ -0,0 +1,5 @@
+import type { RefObject } from 'preact';
+import type { CanvasNodeState } from '../types';
+export declare function canCopyPrimitiveJson(node: CanvasNodeState): boolean;
+export declare function usePrimitiveJson(node: CanvasNodeState, token: string, frame: RefObject<HTMLIFrameElement>, expanded: boolean): void;
+export declare function copyPrimitiveJson(nodeId: string): Promise<void>;

package/dist/types/client/nodes/use-iframe-content-height.d.ts

@@ -13,4 +13,4 @@ import type { CanvasNodeState } from '../types';
  */
 export declare function useIframeContentHeight(node: CanvasNodeState, iframeRef: {
     current: HTMLIFrameElement | null;
-}, frameToken: string): void;
+}, frameToken: string): () => void;

package/dist/types/client/nodes/use-surface-frame.d.ts

@@ -1,13 +1,11 @@
+import { type ViewerSource } from './ViewerFrame';
 /**
  * Attributes for a surface iframe, honoring the boot-wide iframe mode
  * (state/iframe-mode.ts): `src` by default, fetch() + `srcdoc` when src-URL
  * iframes are blocked by the embedding context (nested-iframe hosts like Amp
  * orb portals). Cross-origin URLs always stay `src` — they cannot be fetched
  * from here. While the probe is pending, same-origin frames stay empty rather
- * than loading a src that may show the broken placeholder; a failed srcdoc
- * fetch falls back to `src` (no worse than before).
+ * than loading a src that may show the broken placeholder. Preparation failures
+ * use the shared host's Retry, never a second load path the embed probe rejected.
  */
-export declare function useSurfaceFrame(url: string): {
-    src?: string;
-    srcdoc?: string;
-};
+export declare function useSurfaceFrame(url: string): ViewerSource;

package/dist/types/client/nodes/viewer-runtime-state.d.ts

@@ -1 +1,2 @@
-export declare function restoreViewerRuntimeState(nodeId: string, token: string, source: Window, signal?: AbortSignal): Promise<boolean | 'cancelled'>;
+import type { CanvasNodeState } from '../types';
+export declare function restoreViewerRuntimeState(authored: CanvasNodeState, token: string, source: Window, signal?: AbortSignal): Promise<boolean | 'cancelled'>;

package/dist/types/client/state/canvas-store.d.ts

@@ -120,7 +120,7 @@ export declare function resizeNode(id: string, size: {
     width: number;
     height: number;
 }): void;
-export declare function bringToFront(id: string): void;
+export declare function bringToFront(id: string, persist?: boolean): void;
 export declare function toggleCollapsed(id: string): void;
 export declare function setViewport(v: Partial<ViewportState>): void;
 export declare function replaceViewport(next: ViewportState): void;
@@ -161,11 +161,13 @@ export declare function animateCameraPath(frameAt: (t: number) => ViewportState,
 export declare function cancelViewportAnimation(): void;
 export declare function persistLayout(options?: {
     recordHistory?: boolean;
+    raisedNodeId?: string;
 }): void;
 export declare function restoreLayout(): Map<string, Partial<CanvasNodeState>> | null;
 export declare function fitAll(containerW: number, containerH: number): void;
 export declare function focusNode(id: string, options?: {
     recordHistory?: boolean;
+    persistStacking?: boolean;
 }): void;
 export declare function cycleActiveNode(direction?: 1 | -1): void;
 export declare function walkGraph(direction: 'up' | 'down' | 'left' | 'right'): void;

package/dist/types/client/state/intent-bridge.d.ts

@@ -76,6 +76,7 @@ export declare function pushCanvasUpdate(updates: Array<{
         height: number;
     };
     collapsed?: boolean;
+    zIndex?: number;
 }>, options?: {
     recordHistory?: boolean;
 }): Promise<void>;

package/dist/types/client/state/presentation.d.ts

@@ -4,6 +4,11 @@ export declare const presenting: import("@preact/signals-core").Signal<boolean>;
 export declare const recordingCamera: import("@preact/signals-core").Signal<boolean>;
 /** Why the current stop cannot be shown (missing target, no stops, server unreachable). */
 export declare const presentationError: import("@preact/signals-core").Signal<string>;
+/** Read-only mirror of the server's shared cursor, never advanced optimistically. */
+export declare const presentationCursor: import("@preact/signals-core").Signal<{
+    index: number;
+    total: number;
+} | null>;
 export declare function ownsCamera(): boolean;
 /**
  * Ease this viewer's camera to a stop: log-space zoom, optional pull-back.
@@ -16,16 +21,22 @@ export declare function playStop(stop: TourStop, onDone?: (end: ViewportState) =
  * committed (two frames); the latest step always wins.
  */
 export declare function presentStop(stop: TourStop): void;
-/**
- * Move the server's shared tour cursor. The `canvas-tour-step` echo does the
- * animating, here and in every other presenting viewer, so a human's keys and
- * an agent's `tour.go` always agree on where the tour is.
- */
+/** Apply either delivery of the server's shared cursor, without replaying its echo. */
+export declare function applyTourStep(data: Record<string, unknown>): void;
+export declare function applyTourExit(data: Record<string, unknown>): void;
+/** Move the shared cursor. A successful response also works while events are delayed or disconnected. */
 export declare function stepTour(to: {
     stop: number;
 } | {
     step: 'next' | 'previous';
-}): Promise<void>;
+}, presenter?: {
+    clientId: string;
+    intent: number;
+    catalogEpoch: string;
+    boardGeneration: number;
+} | null): Promise<void>;
 /** Present from the first stop, or resume where the tour already is (`?present=1`). */
 export declare function startPresentation(resume?: boolean): Promise<void>;
+/** Local cancellation also fences pending requests from this presentation. */
+export declare function dismissPresentation(): void;
 export declare function endPresentation(): void;

package/dist/types/json-render/server.d.ts

@@ -1,3 +1,4 @@
+import type { CanvasThemeName } from '../shared/themes.js';
 export interface JsonRenderSpec {
     root: string;
     elements: Record<string, unknown>;
@@ -95,7 +96,7 @@ export declare function readJsonRenderBundle(): Promise<{
 export declare function buildJsonRenderViewerHtml(options: {
     title: string;
     spec: JsonRenderSpec;
-    theme?: 'dark' | 'light' | 'high-contrast';
+    theme?: CanvasThemeName | 'dark' | 'light';
     display?: 'expanded' | 'site';
     devtools?: boolean;
     nodeId?: string;

package/dist/types/mcp/canvas-access.d.ts

@@ -1,16 +1,11 @@
 import { type CanvasLayout, type CanvasNodeState, type PmxCanvas } from '../server/index.js';
-import type { PmxAxSource } from '../server/ax-state.js';
 import type { ContextReadInput } from '../server/context-reads.js';
 import { type OperationInvoker } from '../server/operations/index.js';
 type AxStateResult = ReturnType<PmxCanvas['getAxState']>;
 type AxContextResult = ReturnType<PmxCanvas['getAxContext']>;
-type SubmitAxInteractionInput = Parameters<PmxCanvas['submitAxInteraction']>[0];
-type SubmitAxInteractionResult = ReturnType<PmxCanvas['submitAxInteraction']>;
 type GetPendingSteeringResult = ReturnType<PmxCanvas['getPendingSteering']>;
 type ListElicitationsResult = ReturnType<PmxCanvas['listElicitations']>;
 type ListModeRequestsResult = ReturnType<PmxCanvas['listModeRequests']>;
-type IngestActivityInput = Parameters<PmxCanvas['ingestActivity']>[0];
-type IngestActivityResult = ReturnType<PmxCanvas['ingestActivity']>;
 type GetPolicyResult = ReturnType<PmxCanvas['getPolicy']>;
 type GetAxTimelineQuery = Parameters<PmxCanvas['getAxTimeline']>[0];
 type GetAxTimelineResult = ReturnType<PmxCanvas['getAxTimeline']>;
@@ -38,18 +33,12 @@ export interface CanvasAccess {
     listWorkItems(): Promise<ListWorkItemsResult>;
     listApprovalGates(): Promise<ListApprovalGatesResult>;
     listReviewAnnotations(): Promise<ListReviewAnnotationsResult>;
-    submitAxInteraction(input: SubmitAxInteractionInput, options?: {
-        source?: PmxAxSource;
-    }): Promise<SubmitAxInteractionResult>;
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;
     }): Promise<GetPendingSteeringResult>;
     listElicitations(): Promise<ListElicitationsResult>;
     listModeRequests(): Promise<ListModeRequestsResult>;
-    ingestActivity(input: IngestActivityInput, options?: {
-        source?: PmxAxSource;
-    }): Promise<IngestActivityResult>;
     getPolicy(): Promise<GetPolicyResult>;
     getHistory(): Promise<HistoryResult>;
     getPinnedNodeIds(board?: string): Promise<string[]>;
@@ -62,7 +51,7 @@ export interface CanvasAccess {
     runBatch(operations: RunBatchInput): Promise<RunBatchResult>;
     getCodeGraph(): Promise<CodeGraphResult>;
     getAutomationWebViewStatus(): Promise<AutomationWebViewStatus>;
-    screenshotAutomationWebView(options?: AutomationScreenshotOptions): Promise<Uint8Array>;
+    screenshotAutomationWebView(options?: AutomationScreenshotOptions, signal?: AbortSignal): Promise<Uint8Array>;
 }
 export declare function refreshCanvasAccess(access: CanvasAccess): Promise<CanvasAccess>;
 /**

package/dist/types/mcp/resource-subscriptions.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CanvasAccess } from './canvas-access.js';
+/** One subscription set and event source per MCP connection. Notifications are not reads. */
+export declare function registerResourceSubscriptions(server: McpServer, getCanvas: () => Promise<CanvasAccess>): {
+    attach: (canvas: CanvasAccess) => void;
+    dispose: () => void;
+};

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

@@ -19,4 +19,6 @@
  * }
  * ```
  */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
 export declare function startMcpServer(): Promise<void>;

package/dist/types/server/ax-wait.d.ts

@@ -33,4 +33,5 @@ export declare function waitForAxCondition(opts: {
     ready: () => boolean;
     timeoutMs: number;
     channel?: string;
+    signal?: AbortSignal;
 }): Promise<void>;

package/dist/types/server/canvas-operations.d.ts

@@ -168,6 +168,7 @@ export declare function resolveCanvasNode(nodeRef: CanvasNodeLookupInput): {
 };
 export declare function refreshCanvasWebpageNode(id: string, options?: {
     url?: string;
+    signal?: AbortSignal;
 }): Promise<{
     ok: boolean;
     id: string;

package/dist/types/server/canvas-state.d.ts

@@ -170,6 +170,7 @@ export interface CanvasNodeUpdate {
         height: number;
     };
     collapsed?: boolean;
+    zIndex?: number;
 }
 export type CanvasChangeType = 'pins' | 'nodes' | 'ax' | 'ax-timeline';
 /** Name for a board nobody named yet: when it was made, to the minute. */
@@ -740,4 +741,5 @@ declare class CanvasStateManager {
     releaseGroupChildren(groupId: string): boolean;
     clear(): void;
 }
+export declare const boardCatalogEpoch: `${string}-${string}-${string}-${string}-${string}`;
 export declare const canvasState: CanvasStateManager;

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

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'node:events';
-import type { Camera, Tour, TourStop } from '../shared/tour.js';
-import { type TourStep, type TourStepResult } from './tour-control.js';
-export type { Tour, TourStop } from '../shared/tour.js';
-export type { TourStep, TourStepResult } from './tour-control.js';
+import type { Camera, Tour, TourPresenter, TourStop } from '../shared/tour.js';
+import { type TourState, type TourStep, type TourStepResult, type TourSuperseded } from './tour-control.js';
+export type { Tour, TourPresenter, TourStop } from '../shared/tour.js';
+export type { TourState, TourStep, TourStepResult, TourSuperseded } from './tour-control.js';
 import type { AgentPhase, AgentPresence, AgentPresenceSnapshot } from '../shared/agent-presence.js';
 import { canvasState } from './canvas-state.js';
 import type { CanvasAnnotation, CanvasNodeState, CanvasEdge, CanvasLayout } from './canvas-state.js';
@@ -163,14 +163,19 @@ export declare class PmxCanvas extends EventEmitter {
     ungroupNodes(groupId: string, options?: {
         intentId?: string;
     }): boolean;
-    getTour(): Tour;
+    getTour(): TourState;
     setTour(tour: Tour | null): void;
     /** Present a tour stop (index, `next` or `previous`) in the workbench. Not recorded in undo history. */
     goToTourStop(step: TourStep, options?: {
         present?: boolean;
+        presenter?: undefined;
     }): TourStepResult;
+    goToTourStop(step: TourStep, options: {
+        present?: boolean;
+        presenter?: TourPresenter;
+    }): TourStepResult | TourSuperseded;
     /** Leave presentation in every viewer. */
-    exitTour(): void;
+    exitTour(presenter?: TourPresenter): void;
     /** Ease the camera to a node, world rect or viewport. Not recorded in undo history. */
     moveCamera(stop: TourStop): {
         viewport: Camera;

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

@@ -1,3 +1,13 @@
+import { type OperationProgress } from './types.js';
+/** Opt-in NDJSON; the terminal frame retains the ordinary HTTP status/body. */
+export type OperationStreamFrame = {
+    type: 'progress';
+    progress: OperationProgress;
+} | {
+    type: 'result';
+    status: number;
+    body: unknown;
+};
 export declare function matchOperationPath(template: string, pathname: string): Record<string, string> | null;
 /**
  * Shared body reader: preserves the parsed JSON value as-is (object, array,

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

@@ -3,6 +3,6 @@ export { dispatchOperationRoute } from './http.js';
 export { runCanvasBatchOperation, type BatchEnvelope } from './ops/batch.js';
 export type { OpenMcpAppCoreResult } from './ops/app.js';
 export { LocalOperationInvoker, HttpOperationInvoker, type OperationInvoker } from './invoker.js';
-export { registerOperationTools, registerCompositeTools, type OperationToolHost } from './mcp.js';
+export { registerOperationTools, registerCompositeTools, registerOperationHelpTool, type OperationToolHost, } from './mcp.js';
 export { compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
-export { OperationError, defineOperation, type Operation, type OperationContext, type OperationDefinition, type OperationErrorStatus, } from './types.js';
+export { OperationError, defineOperation, type Operation, type OperationContext, type OperationDefinition, type OperationExecutionOptions, type OperationErrorStatus, type OperationProgress, } from './types.js';

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

@@ -1,5 +1,6 @@
+import { type OperationExecutionOptions } from './types.js';
 export interface OperationInvoker {
-    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, input: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }
 /**
  * The agent-presence label for a transport: `PMX_CANVAS_AGENT_SOURCE` lets a
@@ -14,7 +15,7 @@ export declare class LocalOperationInvoker implements OperationInvoker {
     private readonly proxiedRead;
     /** `source` labels this caller's agent presence ('mcp', 'sdk', …). */
     constructor(source?: string, allowExternalMcp?: boolean);
-    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, input: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }
 /** Builds the HTTP request from the op's route template (`:id` from input, GET flags to query). */
 export declare class HttpOperationInvoker implements OperationInvoker {
@@ -24,5 +25,5 @@ export declare class HttpOperationInvoker implements OperationInvoker {
     private readonly proxiedRead;
     /** `source` labels this caller's agent presence on the server ('cli', 'mcp', …). */
     constructor(baseUrl: string, source?: string, allowExternalMcp?: boolean);
-    invoke(name: string, rawInput: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, rawInput: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }