pmx-canvas 0.10.0 → 0.12.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/BoardMoveDialog.d.ts

@@ -0,0 +1,2 @@
+export declare function openBoardMove(nodeIds: string[]): void;
+export declare function BoardMoveDialog(): import("preact/jsx-runtime").JSX.Element | null;

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/EdgeEditor.d.ts

@@ -0,0 +1,19 @@
+import type { CanvasEdge } from '../types';
+export declare const edgeEditorAnchor: import("@preact/signals-core").Signal<{
+    id: string;
+    incarnation: number;
+    point: {
+        x: number;
+        y: number;
+    };
+} | null>;
+/** Like EdgeHint, the editor lives in App's screen layer, outside the transformed world. */
+export declare function SelectedEdgeEditor(): import("preact/jsx-runtime").JSX.Element | null;
+/** Screen-sized controls anchored to the selected relation, not scaled with its SVG. */
+export declare function EdgeEditor({ edge, point }: {
+    edge: CanvasEdge;
+    point: {
+        x: number;
+        y: number;
+    };
+}): import("preact/jsx-runtime").JSX.Element;

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/GroupNavigation.d.ts

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

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

@@ -6,6 +6,8 @@
 interface TextPromptRequest {
     title: string;
     placeholder: string;
+    description?: string;
+    maxLength?: number;
     /** Prefilled (and pre-selected) value — edit flows start from the current text. */
     initial: string;
     /** Submitting an empty field resolves '' instead of null — "clear the value" flows. */
@@ -20,6 +22,8 @@ export declare function askText(title: string, placeholder: string, opts?: {
     initial?: string;
     allowEmpty?: boolean;
     confirm?: string;
+    description?: string;
+    maxLength?: number;
 }): Promise<string | null>;
 export declare function TextPrompt(): 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/PromptNode.d.ts

@@ -1,4 +1,5 @@
 import type { CanvasNodeState } from '../types';
+export declare function hasUnsavedPrompt(boardId: string, nodeId: string): boolean;
 export declare function PromptNode({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;

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, jsonRpc?: boolean): 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/WorkCard.d.ts

@@ -0,0 +1,7 @@
+import { type AxWorkItemStatus } from '../../shared/ax-kinds.js';
+import type { CanvasNodeState } from '../types';
+export declare function hasUnsavedWorkCard(boardId: string, nodeId: string): boolean;
+export declare function WorkCard({ node, state }: {
+    node: CanvasNodeState;
+    state: AxWorkItemStatus;
+}): import("preact/jsx-runtime").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-ax-surface-bridge.d.ts

@@ -17,4 +17,5 @@ export declare function useAxSurfaceBridge(options: {
     nodeId: string;
     sourceSurface: AxSurfaceBridgeSurface;
     iframeRef: RefObject<HTMLIFrameElement>;
+    jsonRpc?: boolean;
 }): 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

@@ -77,6 +77,20 @@ export declare function trackDragMembership(nodeId: string): void;
 export declare const hiddenByCollapsedGroup: import("@preact/signals-core").ReadonlySignal<Map<string, string>>;
 /** The node that stands in for `id` on the canvas: itself, or its collapsed group's chip. */
 export declare function visibleNodeFor(id: string): CanvasNodeState | undefined;
+interface GroupVisit {
+    id: string;
+    parent: unknown;
+    viewport: ViewportState;
+    selection: Set<string>;
+    active: string | null;
+}
+/** Human navigation only. The canonical node/edge maps and agent reads remain whole-board. */
+export declare const groupPath: import("@preact/signals-core").Signal<GroupVisit[]>;
+export declare const groupContents: import("@preact/signals-core").ReadonlySignal<Set<string> | null>;
+/** The drawing's outside endpoints are view-only stubs, never inserted into nodes. */
+export declare const groupViewNodes: import("@preact/signals-core").ReadonlySignal<Map<string, CanvasNodeState>>;
+export declare function leaveGroup(depth?: number): void;
+export declare function openGroup(id: string, fit?: boolean): void;
 /** Collapsed groups render as a chip; children keep their positions for restore. */
 export declare function groupsOfSelection(): string[];
 export declare function alignSelection(edge: 'left' | 'top'): void;
@@ -120,7 +134,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 +175,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;
@@ -173,3 +189,4 @@ export declare function expandNode(id: string): void;
 export declare function collapseExpandedNode(): void;
 export declare function autoArrange(): void;
 export declare function forceDirectedArrange(): void;
+export {};

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

@@ -3,6 +3,8 @@ export declare const humanClientId: string;
 export declare const humanName: import("@preact/signals-core").Signal<string>;
 export declare const humans: import("@preact/signals-core").Signal<HumanPresence[]>;
 export declare const otherHumans: import("@preact/signals-core").ReadonlySignal<HumanPresence[]>;
+/** Change the display label, never the per-tab identity or anyone's access. */
+export declare function setHumanName(name: string): void;
 /** Nodes a human took over mid-edit → that human's name, shown as the yield pill for a moment. */
 export declare const yieldedNodes: import("@preact/signals-core").Signal<Map<string, string>>;
 export declare function applyHumanSnapshot(snapshot: Partial<HumanPresenceSnapshot> | null | undefined): 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>;
@@ -92,11 +93,13 @@ export declare function createNodeFromClient(opts: {
     type?: string;
     title?: string;
     content?: string;
+    data?: Record<string, unknown>;
     x?: number;
     y?: number;
     width?: number;
     height?: number;
     boardId?: string;
+    expectedBoardId?: string;
 }): Promise<{
     ok: boolean;
     id?: string;
@@ -236,10 +239,10 @@ export declare function updateEdgeFromClient(edgeId: string, patch: {
     type?: string;
     style?: string;
     animated?: boolean;
-}): Promise<{
+}, expectedBoardId?: string | null): Promise<{
     ok: boolean;
 }>;
 /** Remove a canvas edge via the server. */
-export declare function removeEdgeFromClient(edgeId: string): Promise<{
+export declare function removeEdgeFromClient(edgeId: string, expectedBoardId?: string | null): Promise<{
     ok: boolean;
 }>;

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/client/state/relation-store.d.ts

@@ -1,7 +1,18 @@
+import type { CanvasEdge } from '../types';
 export declare const relationFilter: import("@preact/signals-core").Signal<{
     boardId: string;
     kind: string;
 } | null>;
+export declare function showRelationsOnCanvas(nodeId: string, mode: 'lineage' | 'connections'): void;
+/** Only qualified dependency/lineage sources warn; citations and illustrated loops never do. */
+export declare function relationWarning(edge: CanvasEdge): string[];
+export declare const dependencyAnalysis: import("@preact/signals-core").ReadonlySignal<{
+    cycles: number;
+    cycleEdges: Set<string>;
+    affected: Set<string>;
+    focused: boolean;
+    hasDependencies: boolean;
+}>;
 export declare const relationFocus: import("@preact/signals-core").ReadonlySignal<string | null>;
 /** View-only highlights. They never infer evidence, change a decision or execute a flow. */
 export declare const relationHighlight: import("@preact/signals-core").ReadonlySignal<{

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

@@ -75,7 +75,7 @@ export type AnnotationTool = 'pen' | 'eraser' | 'text' | null;
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export declare const TYPE_LABELS: Record<CanvasNodeState['type'], string>;
 /** Node types that support the full-viewport expand/focus overlay. */
-export declare const EXPANDABLE_TYPES: Set<"board" | "image" | "file" | "markdown" | "mcp-app" | "webpage" | "json-render" | "graph" | "prompt" | "response" | "status" | "context" | "ledger" | "trace" | "diff" | "mermaid" | "html" | "group">;
+export declare const EXPANDABLE_TYPES: Set<"prompt" | "mcp-app" | "markdown" | "webpage" | "json-render" | "graph" | "board" | "response" | "status" | "context" | "ledger" | "trace" | "file" | "diff" | "mermaid" | "image" | "html" | "group">;
 export declare const EXCALIDRAW_SERVER_NAME = "Excalidraw";
 export declare const EXCALIDRAW_CREATE_VIEW_TOOL = "create_view";
 export declare function isExcalidrawNode(node: CanvasNodeState): boolean;

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

@@ -474,10 +474,10 @@ export declare const allComponentDefinitions: {
             text: z.ZodString;
             variant: z.ZodNullable<z.ZodEnum<{
                 error: "error";
-                success: "success";
-                default: "default";
                 info: "info";
                 warning: "warning";
+                success: "success";
+                default: "default";
                 secondary: "secondary";
                 destructive: "destructive";
                 outline: "outline";

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/server/agent-presence.d.ts

@@ -178,6 +178,7 @@ export declare class AgentPresenceRegistry {
     /** A board opened: attached sessions record it as they find it, before any write lands. */
     boardOpened(): void;
     /** Remove a writer (session-end). */
+    private endSession;
     detach(sessionId: string): boolean;
     snapshot(now?: number): AgentPresenceSnapshot;
     /** Latest attached session: a newly attached reviewer must check fast context again. */