pmx-canvas 0.8.2 → 0.9.0

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

@@ -1,9 +1,13 @@
-import type { ComponentChildren } from 'preact';
+import { type ComponentChildren, type VNode } from 'preact';
+/** Escape a bar's filter/clip without installing React-compat event hooks. */
+export declare function BarPortal({ children }: {
+    children: VNode;
+}): null;
 /**
  * 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, children, }: {
+export declare function BarHint({ label, shortcut, body, align, side, tapToOpen, fitWithin, children, }: {
     label: string;
     shortcut?: string;
     /** One or two plain sentences under the label — the explanation a native `title` used to hide. */
@@ -18,5 +22,11 @@ export declare function BarHint({ label, shortcut, body, align, side, tapToOpen,
      * after the click, not linger on focus.
      */
     tapToOpen?: boolean;
+    /**
+     * The clipping box to stay inside (a CSS selector for an ancestor). As the
+     * tooltip opens it takes whichever of end/start alignment fits — a node
+     * header chip sits anywhere along a card that clips its contents.
+     */
+    fitWithin?: string;
     children: ComponentChildren;
 }): import("preact").JSX.Element;

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

@@ -1,3 +1,5 @@
-export declare function BoardLinkDialog({ onClose }: {
+export declare function BoardLinkDialog({ onClose, sourceNodeId, wikiRef, }: {
     onClose: () => void;
+    sourceNodeId?: string;
+    wikiRef?: string;
 }): import("preact/src").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { type BoardSummary } from '../state/boards-store';
+/**
+ * Board pins (docs/design/BoardPins.dc.html): the same pin as a card's, in the
+ * same place, at board level. Pinned, the board's README and pinned cards reach
+ * the agent's brief whichever board is open.
+ */
+export declare function BoardPinButton({ board, inNodeHeader }: {
+    board: BoardSummary;
+    inNodeHeader?: boolean;
+}): import("preact/src").JSX.Element;

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

@@ -5,4 +5,4 @@
  */
 export declare function BoardSwitcher({ fallbackName }: {
     fallbackName: string;
-}): import("preact").JSX.Element;
+}): import("preact/src").JSX.Element;

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

@@ -7,5 +7,5 @@ interface CanvasViewportProps {
     annotationTool?: AnnotationTool;
 }
 export declare function getRenderableWorldNodes(allNodes: Iterable<CanvasNodeState>, focusedNodeId: string | null, hiddenIds?: ReadonlySet<string>): CanvasNodeState[];
-export declare function CanvasViewport({ onNodeContextMenu, onEdgeContextMenu, onCanvasContextMenu, annotationMode, annotationTool, }: CanvasViewportProps): import("preact/src").JSX.Element;
+export declare function CanvasViewport({ onNodeContextMenu, onEdgeContextMenu, onCanvasContextMenu, annotationMode, annotationTool, }: CanvasViewportProps): import("preact").JSX.Element;
 export {};

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

@@ -1,10 +1,9 @@
 /**
  * Command bar (rail-chrome-v2 phase 5): the human's steering surface while a
  * session is attached — the design's floating composer, centered at the
- * bottom of the canvas region. Above it, the pinned context as gold ✦ chips
+ * bottom of the canvas region. Above it, the pinned context as blue chips
  * (× unpins — the same pin the node's own control toggles); the composer row
- * posts an AX steering message to the session. The context-budget meter lives
- * in the top bar (`ContextBudget`), where the mockup puts it. Replaces the
- * quiet board's pin bar only while attached.
+ * posts an AX steering message to the session. What is in the agent's
+ * context is summarised in the top bar's context chip (`ContextChip`).
  */
 export declare function CommandBar(): import("preact/src").JSX.Element;

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

@@ -2,7 +2,8 @@
  * Degraded connection states (rail-chrome-v2 phase 7, design item 14), mapped
  * onto the transport the bridge already runs:
  * - reconnecting: the stream (SSE or the polling fallback) is down and the
- *   bridge is backing off. Edits still go over HTTP; the board may be stale.
+ *   bridge is backing off. HTTP saves may need renewed capability after a
+ *   daemon restart; the board may be stale.
  * - resyncing: a transport came back after a drop and the full `connected`
  *   snapshot is being applied — the seq cursor was dropped, the board reloads
  *   from the server's snapshot without touching local edits.

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

@@ -0,0 +1,3 @@
+/** The quiet footer when Agent sessions is off; pins still curate agent context. */
+export declare function ContextPinBar(): import("preact/src").JSX.Element | null;
+export declare function ContextChip(): import("preact/src").JSX.Element | null;

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

@@ -0,0 +1,5 @@
+import type { CanvasNodeState } from '../types';
+/** The same bounded, navigable reference list on a card and in focus mode. */
+export declare function CrossBoardReferences({ node }: {
+    node: CanvasNodeState;
+}): import("preact/src").JSX.Element | null;

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

@@ -1,5 +1,9 @@
-import type { Signal } from '@preact/signals';
+import { type Signal } from '@preact/signals';
 import type { CanvasEdge, CanvasNodeState } from '../types';
+/** Filter only the kinds on this board; shared presets are managed in Home. */
+export declare function RelationLegend(): import("preact/src").JSX.Element | null;
+/** The link pill's hint, outside the zoomed canvas so it keeps screen size and is never clipped. */
+export declare function EdgeHint(): import("preact/src").JSX.Element | null;
 /**
  * Edges are drawn in world space, so a 1.5px stroke renders as 0.4 screen px at
  * 26% zoom. Full inverse compensation keeps edge chrome at a constant SCREEN
@@ -8,10 +12,17 @@ import type { CanvasEdge, CanvasNodeState } from '../types';
  * at overview zoom.
  */
 export declare function edgeChromeScale(scale: number): number;
+/**
+ * Lines draw below group frames, so a link never covers a group's header; pills
+ * draw in their own layer above the frames, so a link inside a group keeps a
+ * label (LinkAuthorship.dc.html). Transparent pill hits stay below ports without
+ * moving the painted label below the frame's wash.
+ */
+export type EdgeLayerPart = 'lines' | 'pills' | 'pill-hits';
 interface EdgeLayerProps {
     nodes: Signal<Map<string, CanvasNodeState>>;
     edges: Signal<Map<string, CanvasEdge>>;
-    onEdgeContextMenu?: (e: MouseEvent, edgeId: string) => void;
+    part: EdgeLayerPart;
 }
-export declare function EdgeLayer({ nodes, edges, onEdgeContextMenu }: EdgeLayerProps): import("preact/src").JSX.Element | null;
+export declare function EdgeLayer({ nodes, edges, part }: EdgeLayerProps): import("preact/src").JSX.Element | null;
 export {};

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

@@ -1,10 +1,10 @@
 /**
  * Empty board (rail-chrome-v2 phase 7, design item 11): centered onboarding
- * with the ghost mark, a 2×2 grid of starter actions, and the shortcut hint.
- * Every action is real: New note creates the same blank note as M, Drop files
+ * with direct starter actions and a separate way to start with your agent.
+ * Every action is real: Start a note creates the same blank note as M, Drop files
  * opens a picker onto the viewport's import path, Paste a link asks for a URL,
- * Start agent session attaches a browser-keyed session. Tokens only, so it
- * reads the same in dark and light.
+ * and the optional Start agent session attaches a browser-keyed session.
+ * Agent guidance stays visible independently of the session beta.
  */
 export declare function EmptyState({ onOpenPalette }: {
     onOpenPalette: () => void;

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

@@ -0,0 +1,2 @@
+/** One explorer. Ownership defines scope; authored relationships define geometry. */
+export declare function HomeGraphView(): import("preact/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function HomeMapView(): import("preact/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,6 @@
+/** Queue metadata and qualification are one authoritative workspace observation. */
+export declare function HomeReviewView({ folder, folders, onScopeChange, }: {
+    folder: string;
+    folders: string[];
+    onScopeChange: (folder: string) => void;
+}): import("preact/src").JSX.Element | null;

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

@@ -1,9 +1,11 @@
-export declare function promptNewBoard(): Promise<void>;
+export declare function promptNewBoard(folder?: string | null): Promise<void>;
 /**
- * Home (plan 012): the view when no board is open — every board, filed under
- * its category (most recently opened first within each). Categories keep the
- * library findable as it grows into the working memory of many sessions.
- * Deleting asks in place, naming the board and what it holds; browser confirm
- * dialogs are no-ops in agent panes.
+ * Home (docs/design/Home.dc.html, plan 016): the library when no board is
+ * open. A folder tree with pinned boards on the left, the selected folder's
+ * subfolders and board cards in the middle, the selected board's details on
+ * the right. At ≤ 760 px (Pane600.dc.html) the tree becomes a folder picker,
+ * the boards a list and the details a bottom sheet. Folders are board
+ * folder paths; folders carry no colour (decided 2026-10-07). Browser
+ * confirm dialogs are no-ops in agent panes, so Delete asks in place.
  */
-export declare function HomeView(): import("preact").JSX.Element;
+export declare function HomeView(): import("preact/src").JSX.Element;

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

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

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

@@ -0,0 +1,5 @@
+export declare function KnowledgeSync(): null;
+export declare function LifecycleFilters(): import("preact/src").JSX.Element | null;
+export declare function LifecycleFooter({ nodeId }: {
+    nodeId: string;
+}): import("preact/src").JSX.Element | null;

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

@@ -0,0 +1,7 @@
+import type { Lifecycle } from '../../server/knowledge-lifecycle.js';
+export declare const DEFAULT_LIFECYCLE: Lifecycle;
+export declare function LifecycleFields({ value, onChange }: {
+    value: Lifecycle;
+    onChange: (value: Lifecycle) => void;
+}): import("preact/jsx-runtime").JSX.Element;
+export declare const cleanLifecycle: (value: Lifecycle) => Lifecycle;

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

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

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

@@ -0,0 +1,7 @@
+import type { ComponentChildren } from 'preact';
+/** Shared docking only. Map and Graph own their selection and actions. */
+export declare function MemoryInspector({ children, initiallyCollapsed, reveal, }: {
+    children: ComponentChildren;
+    initiallyCollapsed?: boolean;
+    reveal?: number;
+}): import("preact").JSX.Element;

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

@@ -0,0 +1,14 @@
+/**
+ * Which pin? (docs/design/NearPin.dc.html §2): for a hovered, selected or
+ * dragged pin — or the pins a near chip asked to show — dotted tethers to its
+ * neighbours, numbered nearest first, and an unlabeled boundary only when
+ * another node is within range. Drawn in screen
+ * space (architecture rule 9) so they stay legible at fit zoom; while an
+ * unpinned node is dragged only the nearest pin's boundary shows (§3).
+ */
+export declare function NearPinLayer(): import("preact/jsx-runtime").JSX.Element | null;
+/**
+ * Hover a near chip (docs/design/NearPin.dc.html §2): which pins, how far, and
+ * the two ways on — pin it to put it first, or show the pins' tethers.
+ */
+export declare function NearPinCard(): import("preact/jsx-runtime").JSX.Element | null;

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

@@ -1,4 +1,5 @@
-import type { CanvasNodeState } from '../types';
+import type { ComponentChildren } from 'preact';
+import { type CanvasNodeState } from '../types';
 export declare const GLYPHS: {
     readonly eye: "M2 12s3.5-6 10-6 10 6 10 6-3.5 6-10 6S2 12 2 12zM12 9.5a2.5 2.5 0 1 0 0 5a2.5 2.5 0 1 0 0-5";
     readonly eyeOff: "M3 3l18 18M10.6 6.1A10 10 0 0 1 12 6c6.5 0 10 6 10 6a17 17 0 0 1-3 3.6M6.6 6.6C3.8 8.3 2 12 2 12s3.5 6 10 6a9.6 9.6 0 0 0 4.4-1";
@@ -6,19 +7,51 @@ export declare const GLYPHS: {
     readonly pen: "M4 20l4.2-1L19 8.2 15.8 5 5 15.8z";
     readonly warn: "M12 4l9 16H3zM12 10v4M12 17v.5";
 };
-/** The header chip saying what agents did with this node (one per node; glyph + word). */
-export declare function NodeContextMark({ node, pinned }: {
+/**
+ * Authorship lives only in the type icon's hint, not a star or state chip.
+ * A person's edit ends the agent byline.
+ */
+export declare function bylineFor(node: CanvasNodeState): string | null;
+/** How a header chip shows: its word, only its glyph, or folded into the type icon's hint. */
+export type ChipFold = 'word' | 'glyph' | 'hidden';
+/**
+ * The one state chip a header carries — near a pin (unpinned) or the read
+ * state (pinned) — with what it says when folded into the icon's hint. Never
+ * other cards' titles: at rest a node must not contain them.
+ */
+export declare function headerChip(node: CanvasNodeState, pinned: boolean): {
+    amber: boolean;
+    folded: string;
+} | null;
+/** A pinned node's read-state chip: glyph + word, or only the glyph when the title needs the room. */
+export declare function NodeContextMark({ node, pinned, fold, }: {
+    node: CanvasNodeState;
+    pinned: boolean;
+    fold?: ChipFold;
+}): import("preact").JSX.Element | null;
+/**
+ * The type icon's hint holds the full title, the byline and any folded chip.
+ */
+export declare function NodeTypeIcon({ node, pinned, title, fold, children, }: {
     node: CanvasNodeState;
     pinned: boolean;
-}): import("preact/src").JSX.Element | null;
+    title: string;
+    fold: ChipFold;
+    children: ComponentChildren;
+}): import("preact").JSX.Element;
 /** Pinned by an agent: the violet dot on the pin badge. */
 export declare function isAgentPin(nodeId: string): boolean;
 /**
  * Near a pin (docs/design/NearPin.dc.html): a dotted pin-blue chip on an
  * unpinned node the brief carries as title + short summary. Weaker than "in
- * context" on purpose: the agent never gets this node's full content.
+ * context" on purpose: the agent sees it only because a pin is nearby. Hover,
+ * focus or tap opens its card (`NearPinCard`, §2); it previews while dragged,
+ * pulses once on a drop inside and fades on a drop outside (§3).
  */
-export declare function NearPinMark({ node, pinned }: {
+export declare function NearPinMark({ node, pinned, fold, }: {
     node: CanvasNodeState;
     pinned: boolean;
-}): import("preact/src").JSX.Element | null;
+    fold?: ChipFold;
+}): import("preact").JSX.Element | null;
+/** The viewport as a key: the card closes when it changes. */
+export declare function viewKey(): string;

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

@@ -0,0 +1,4 @@
+/** Shared templates live in Home; applying one never rewrites connection kinds. */
+export declare function RelationPresetsDialog({ onClose }: {
+    onClose: () => void;
+}): import("preact/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+/** The expanded card's evidence and uses, from the same graph agents navigate. */
+export declare function RelationsPanel({ nodeId }: {
+    nodeId: string;
+}): import("preact/jsx-runtime").JSX.Element;

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

@@ -1 +1,3 @@
+/** Approvals and write scope are safety controls, not an optional beta. */
+export declare function AgentControls(): import("preact/src").JSX.Element | null;
 export declare function SessionPanel(): import("preact/src").JSX.Element;

package/dist/types/client/canvas/canvas-area.d.ts

@@ -31,7 +31,7 @@ export interface CanvasFitInsets {
 }
 /**
  * Screen-space insets Fit must reserve for the floating chrome that overlays
- * the canvas region: the bottom command bar (whose pinned-chip row grows it)
+ * the canvas region: the bottom command bar or standalone context pill,
  * and the bottom-right minimap. Measured from the live elements — fit's old
  * world-space padding shrank with the fit zoom and parked nodes underneath
  * both (0.5.0 Amp report, finding A; architecture rule 9's trap).

package/dist/types/client/canvas/graph-geometry.d.ts

@@ -0,0 +1,27 @@
+import type { Point } from './memory-layout';
+/** Painted bounds, collision clearance, ports and Fit share this footprint. */
+export declare const GRAPH_NODE: {
+    width: number;
+    height: number;
+    gap: number;
+};
+interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface GraphRoute {
+    path: string;
+    points: Point[];
+    label?: Point & Rect;
+}
+interface Link {
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+}
+/** Obstacle visibility is shared across routes and independent of zoom/hover. */
+export declare function graphRoutes(positions: Map<string, Point>, links: Link[]): Map<string, GraphRoute>;
+export {};

package/dist/types/client/canvas/graph-model.d.ts

@@ -0,0 +1,37 @@
+import type { MemoryGraphEdge, MemoryGraphNode } from '../../shared/memory-graph.js';
+import type { Point } from './memory-layout';
+export type GraphScene = {
+    kind: 'overview';
+} | {
+    kind: 'board';
+    boardId: string;
+} | {
+    kind: 'card';
+    boardId: string;
+    cardId: string;
+};
+export declare const graphSceneKey: (scene: GraphScene) => string;
+export declare const pairKey: (a: string, b: string) => string;
+/** Partition original facts once; grouping never changes authored endpoints. */
+export declare function graphEvidence(edges: MemoryGraphEdge[]): {
+    evidence: MemoryGraphEdge[];
+    pairs: Map<string, {
+        boardId: string;
+        peerId: string;
+        edges: MemoryGraphEdge[];
+    }>;
+    internal: Map<string, number>;
+    missing: MemoryGraphEdge[];
+};
+/** One animation step. The pointer/drop anchor stays fixed while its visible neighbors respond. */
+export declare function relaxGraphPositions(positions: Map<string, Point>, edges: ReadonlyArray<{
+    from: string;
+    to: string;
+    weight?: number;
+}>, held: string, cooling: number): number;
+/** Deterministic initial placement; live additions preserve retained coordinates. */
+export declare function graphPositions(nodes: MemoryGraphNode[], edges: ReadonlyArray<{
+    from: string;
+    to: string;
+    weight?: number;
+}>, retained: Map<string, Point>): Map<string, Point>;

package/dist/types/client/canvas/memory-layout.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryGraphNode } from '../../shared/memory-graph.js';
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const MAP_CARD: {
+    width: number;
+    height: number;
+};
+export interface MemoryRegion extends Point {
+    path: string;
+    width: number;
+    height: number;
+    count: number;
+    depth: number;
+    collapsed: boolean;
+}
+/** Folder membership determines regions; authored Map positions never change membership. */
+export declare function mapLayout(nodes: MemoryGraphNode[], collapsed: Set<string>): {
+    positions: Map<string, Point>;
+    regions: MemoryRegion[];
+    hidden: Set<string>;
+};

package/dist/types/client/canvas/use-chrome-height.d.ts

@@ -0,0 +1,2 @@
+/** Keep floating canvas controls clear when their content wraps or is hidden. */
+export declare function useChromeHeight(property: string): import("preact/src").RefObject<HTMLDivElement>;

package/dist/types/client/canvas/use-focus-trap.d.ts

@@ -11,4 +11,5 @@ export declare function useFocusTrap(ref: {
         current: HTMLElement | null;
     };
     restoreTo?: () => HTMLElement | null;
+    onEscape?: () => void;
 }): void;

package/dist/types/client/canvas/use-memory-graph.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryGraph } from '../../shared/memory-graph.js';
+/** Coalesce live discovery and reject responses from an older library revision. */
+export declare function useMemoryGraph(projection: 'full' | 'boards'): {
+    graph: MemoryGraph | null;
+    loading: boolean;
+    error: boolean;
+    retry: () => void;
+};

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

@@ -4,6 +4,8 @@ interface PanZoomOptions {
     viewport: Signal<ViewportState>;
     onViewportChange: (v: ViewportState) => void;
     onViewportCommit: (v: ViewportState) => void;
+    onBackgroundContextMenu?: (e: MouseEvent, worldX: number, worldY: number) => void;
+    onEdgeContextMenu?: (e: MouseEvent, edgeId: string) => void;
     disabled?: boolean;
 }
 /**
@@ -11,8 +13,9 @@ interface PanZoomOptions {
  * - Wheel + Ctrl/Cmd: zoom centered on pointer
  * - Wheel without modifier: pan
  * - Right or middle pointer drag: pan from anywhere
+ * - Right-click on background: creation menu on release, unless dragged
  * - Pointer drag on background in pan mode: pan
  * - Pinch (touch): zoom
  */
-export declare function usePanZoom({ viewport, onViewportChange, onViewportCommit, disabled }: PanZoomOptions): import("preact/src").RefObject<HTMLDivElement>;
+export declare function usePanZoom({ viewport, onViewportChange, onViewportCommit, onBackgroundContextMenu, onEdgeContextMenu, disabled, }: PanZoomOptions): import("preact/src").RefObject<HTMLDivElement>;
 export {};

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

@@ -27,8 +27,6 @@ export declare function IconZoomOut(p: IconProps): JSX.Element;
 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;
 /** Pen stroke — canvas annotation mode */
@@ -37,16 +35,8 @@ export declare function IconPen(p: IconProps): JSX.Element;
 export declare function IconEraser(p: IconProps): JSX.Element;
 /** Text cursor — canvas text annotation mode */
 export declare function IconTextAnnotation(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;
 /** Speech bubble — steer the agent (command bar composer). */
 export declare function IconSteer(p: IconProps): JSX.Element;
 /** Push pin — context pinning (docs/design/Chrome.dc.html). */

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

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

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

@@ -2,11 +2,11 @@
  *
  *  Two persistence signals:
  *  - `onChange(md)` — fires on every input. Caller typically debounces.
- *  - `onSave(md)`  — fires on ⌘S and blur. Caller should persist immediately
+ *  - `onSave(md)`  — fires on ⌘S and blur. Caller should persist dirty drafts 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, }: {
+ *    latest content: the exact caller draft until input, serialized DOM after it. */
+export declare function InlineMarkdownEditor({ markdown, initialHtml, className, onChange, onSave, }: {
+    markdown: string;
     initialHtml: string;
     className?: string;
     onChange: (markdown: string) => void;

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

@@ -1,7 +1,11 @@
 import type { JSX } from 'preact';
 import type { CanvasNodeState } from '../types';
-/** Flip the index-th GFM task marker in the source (document order matches the rendered boxes). */
+/** Flip exactly one parsed GFM task without reformatting any other source bytes. */
 export declare function toggleTaskMarker(markdown: string, index: number): string;
+/** Review must refer to persisted content, not an edited or saving preview. */
+export declare function hasUnsavedMarkdown(boardId: string, nodeId: string): boolean;
+/** After blur, navigate only when this board/card's save has actually succeeded. */
+export declare function waitForMarkdownSave(boardId: string | null, nodeId: string): Promise<boolean>;
 export declare function MarkdownNode({ node, expanded }: {
     node: CanvasNodeState;
     expanded?: boolean;

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

@@ -8,15 +8,15 @@ type ViewerFrameSource = {
 /**
  * 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 in a hidden sibling avoids exposing Chromium's
- * white navigation paint. Two animation frames after load gives the new document
- * a composited paint before the old one is removed.
+ * 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) => void;
+    onDocumentLoad?: (frame: HTMLIFrameElement, signal: AbortSignal) => void | Promise<boolean | 'cancelled' | void>;
     title: string;
     className?: string;
     sandbox?: string;

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

@@ -1 +1 @@
-export declare function restoreViewerRuntimeState(nodeId: string, token: string, source: Window): void;
+export declare function restoreViewerRuntimeState(nodeId: string, token: string, source: Window, signal?: AbortSignal): Promise<boolean | 'cancelled'>;