pmx-canvas 0.6.4 → 0.7.0

package/dist/types/server/document-import.d.ts

@@ -0,0 +1,66 @@
+import type { Database } from 'bun:sqlite';
+export declare const MAX_ATTACHMENT_BYTES: number;
+export declare const MAX_INLINE_ATTACHMENT_BYTES: number;
+export declare const MAX_ATTACHMENT_NAME_LENGTH = 255;
+export declare const MAX_IMPORT_SECTIONS = 32;
+export declare const MAX_IMPORT_WARNINGS = 20;
+export declare const MAX_IMPORT_TEXT = 200000;
+export declare const MAX_IMPORT_TITLE_LENGTH = 500;
+export declare const MAX_IMPORT_REFERENCE_LENGTH = 2000;
+export declare const MAX_IMPORT_WARNING_LENGTH = 2000;
+export declare const MAX_IMPORT_AGENT_DESCRIPTION_LENGTH = 4000;
+export declare const MAX_IMPORT_REASON_LENGTH = 4000;
+export interface Attachment {
+    id: string;
+    boardId: string;
+    sha256: string;
+    name: string;
+    mime: string;
+    size: number;
+    createdAt: string;
+}
+export interface ImportSection {
+    title: string;
+    markdown: string;
+    reference?: string;
+}
+export type DocumentImportStatus = 'attached' | 'requested' | 'drafted' | 'unavailable' | 'cancelled' | 'committed';
+export interface DocumentImport {
+    id: string;
+    boardId: string;
+    attachmentId: string;
+    status: DocumentImportStatus;
+    position: {
+        x: number;
+        y: number;
+    };
+    sections: ImportSection[];
+    warnings: string[];
+    agentDescription: string | null;
+    reason: string | null;
+    committedNodeIds: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function storeAttachment(db: Database, input: {
+    boardId: string;
+    name: string;
+    mime: string;
+    bytes: Uint8Array;
+}): Attachment;
+export declare function getAttachment(db: Database, id: string): Attachment | null;
+export declare function readAttachmentBytes(db: Database, id: string): Uint8Array | null;
+export declare function copyBoardAttachments(db: Database, sourceBoardId: string, targetBoardId: string, referencedIds: Set<string>): Map<string, string>;
+export declare function createImport(db: Database, attachmentId: string, position: {
+    x: number;
+    y: number;
+}): DocumentImport;
+export declare function getImport(db: Database, id: string): DocumentImport | null;
+export declare function listImports(db: Database, boardId?: string): DocumentImport[];
+export declare function updateImport(db: Database, id: string, status: DocumentImportStatus, fields?: {
+    sections?: ImportSection[];
+    warnings?: string[];
+    agentDescription?: string;
+    reason?: string;
+    committedNodeIds?: string[];
+}): DocumentImport;

package/dist/types/server/html-surface.d.ts

@@ -60,7 +60,7 @@ export declare function buildContentHeightReporter(frameToken: string): string;
  * of the main SPA bundle). Escaping is mandatory: the source is arbitrary node
  * data and must not be parsed as markup.
  */
-export declare function buildMermaidSurfaceHtml(source: string, inlineEntry?: string | null): string;
+export declare function buildMermaidSurfaceHtml(source: string, inlineEntry?: string | null, fit?: 'contain' | 'none', frameToken?: string): string;
 export interface HtmlSurfaceOptions {
     theme: SurfaceTheme;
     /**

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

@@ -1,11 +1,16 @@
 import { EventEmitter } from 'node:events';
+import { type Tour } from '../shared/tour.js';
+export type { Tour, TourStop } from '../shared/tour.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';
 import { type AxInteractionInput, type AxInteractionPublicResult } from './ax-interaction.js';
 import type { PmxAxIntent } from '../shared/ax-intent.js';
 import type { PmxAxActivityKind, PmxAxApprovalGate, PmxAxCommandDescriptor, PmxAxContext, PmxAxElicitation, PmxAxEvent, PmxAxEvidence, PmxAxEvidenceKind, PmxAxFocusState, PmxAxHostCapability, PmxAxMode, PmxAxModeRequest, PmxAxPolicy, PmxAxReviewAnchorType, PmxAxReviewAnnotation, PmxAxReviewKind, PmxAxReviewRegion, PmxAxReviewSeverity, PmxAxReviewStatus, PmxAxSource, PmxAxState, PmxAxSteeringMessage, PmxAxWorkItem, PmxAxWorkItemStatus } from './ax-state.js';
-import type { AxTimelineQuery } from './canvas-db.js';
+import type { AxTimelineQuery, CanvasBoard } from './canvas-db.js';
+import type { Attachment, DocumentImport, ImportSection } from './document-import.js';
+import type { BackupFile, BackupStatus } from './backup.js';
+import type { ExportManifest } from './board-export.js';
 import { searchNodes } from './spatial-analysis.js';
 import { diffLayouts } from './mutation-history.js';
 import { fitCanvasView, gcCanvasSnapshots, listCanvasSnapshots } from './canvas-operations.js';
@@ -140,6 +145,8 @@ export declare class PmxCanvas extends EventEmitter {
     ungroupNodes(groupId: string, options?: {
         intentId?: string;
     }): boolean;
+    getTour(): Tour;
+    setTour(tour: Tour | null): void;
     clear(): void;
     arrange(layout?: 'grid' | 'column' | 'flow'): void;
     focusNode(id: string, options?: {
@@ -151,7 +158,9 @@ export declare class PmxCanvas extends EventEmitter {
     getAxState(): PmxAxState;
     getAxContext(options?: {
         consumer?: string;
-    }): PmxAxContext;
+    }): PmxAxContext & {
+        boardId: string | null;
+    };
     setAxFocus(nodeIds: string[], options?: {
         source?: PmxAxSource;
     }): PmxAxFocusState;
@@ -197,6 +206,93 @@ export declare class PmxCanvas extends EventEmitter {
         source?: PmxAxSource;
     }): AxInteractionPublicResult;
     getAxTimeline(query?: AxTimelineQuery): ReturnType<typeof canvasState.getAxTimeline>;
+    listBoards(): {
+        activeBoardId: string | null;
+        boards: CanvasBoard[];
+    };
+    listImports(boardId?: string): DocumentImport[];
+    readImport(id: string): {
+        import: DocumentImport;
+        attachment: Attachment;
+        downloadPath: string;
+        bytes?: Uint8Array;
+    } | null;
+    submitImport(id: string, sections: ImportSection[], agentDescription: string, warnings?: string[]): Promise<DocumentImport>;
+    markImportUnavailable(id: string, reason: string): Promise<DocumentImport>;
+    attachDocument(input: {
+        boardId: string;
+        name: string;
+        mime?: string;
+        bytes: Uint8Array;
+        x?: number;
+        y?: number;
+    }): {
+        attachment: Attachment;
+        import: DocumentImport;
+        nodeId: string;
+    };
+    requestImport(id: string, consent: true, trustedHumanToken: string): Promise<DocumentImport>;
+    cancelImport(id: string, trustedHumanToken: string): Promise<DocumentImport>;
+    commitImport(id: string, trustedHumanToken: string): Promise<{
+        import: DocumentImport;
+        nodeIds: string[];
+    }>;
+    createBoard(name: string, category?: string): Promise<CanvasBoard>;
+    /** Rename a board and/or file it under a category (`category: null` removes it). */
+    updateBoard(id: string, patch: {
+        name?: string;
+        category?: string | null;
+    }): Promise<void>;
+    setBoardReadme(id: string, readmeNodeId: string | null): Promise<void>;
+    createBoardFrom(input: {
+        sourceBoardId: string;
+        name: string;
+        category?: string;
+        nodeIds?: string[];
+        includeReadme?: boolean;
+        includeStructure?: boolean;
+        preview?: boolean;
+    }): Promise<Record<string, unknown>>;
+    searchLibrary(query: string, limit?: number): Promise<Record<string, unknown>>;
+    /** Budgeted cross-board brief. Budget is measured in UTF-16 characters. */
+    getContextBrief(options?: {
+        consumer?: string;
+        since?: number;
+        budget?: number;
+    }): Promise<Record<string, unknown>>;
+    /** Open a board, or Home with null. */
+    openBoard(id: string | null): Promise<void>;
+    deleteBoard(id: string): Promise<void>;
+    /** Write a self-contained HTML file of a board (default: the open board). */
+    exportBoard(options?: {
+        board?: string;
+        includeFiles?: boolean;
+        includeDerivedText?: boolean;
+    }): Promise<{
+        path: string;
+        url: string;
+        bytes: number;
+        manifest: ExportManifest;
+    }>;
+    getBackupStatus(): Promise<BackupStatus>;
+    /** Back up every board now; `to` and `keep` default to the configured folder and count. */
+    backup(options?: {
+        to?: string;
+        keep?: number;
+    }): Promise<{
+        backup: BackupFile;
+        removed: string[];
+    }>;
+    /** Back up on a schedule run by the server; `every: 'off'` stops it. */
+    setBackupSchedule(options: {
+        every: string;
+        to?: string;
+        keep?: number;
+    }): Promise<BackupStatus>;
+    /** Replace every board with a backup file; the current file is kept as `canvas.db.before-restore`. */
+    restoreBackup(file: string): Promise<void>;
+    /** The context read log: which canvas context each agent read and which pinned nodes reached it. */
+    getContextReads(limit?: number): ReturnType<typeof canvasState.getContextReads>;
     listWorkItems(): PmxAxWorkItem[];
     addWorkItem(input: {
         title: string;
@@ -386,8 +482,12 @@ export declare class PmxCanvas extends EventEmitter {
         maxScale?: number;
         nodeIds?: string[];
     }): ReturnType<typeof fitCanvasView>;
-    getLayout(): CanvasLayout;
-    getNode(id: string): SdkCanvasNode | undefined;
+    getLayout(options?: {
+        board?: string;
+    }): CanvasLayout;
+    getNode(id: string, options?: {
+        board?: string;
+    }): SdkCanvasNode | undefined;
     search(query: string): ReturnType<typeof searchNodes>;
     getSpatialContext(): import("./spatial-analysis.js").SpatialContext;
     undo(): Promise<{
@@ -588,6 +688,9 @@ export type { CanvasNodeState, CanvasEdge, CanvasLayout, ViewportState } from '.
 export type { CanvasAutomationWebViewOptions, CanvasAutomationWebViewStatus, PrimaryWorkbenchCanvasPromptRequest, PrimaryWorkbenchIntent, } from './server.js';
 export { emitPrimaryWorkbenchEvent, consumePrimaryWorkbenchIntents, setPrimaryWorkbenchAutoOpenEnabled, setPrimaryWorkbenchCanvasPromptHandler, startCanvasServer, stopCanvasServer, getCanvasServerPort, openUrlInExternalBrowser, getCanvasAutomationWebViewStatus, startCanvasAutomationWebView, stopCanvasAutomationWebView, evaluateCanvasAutomationWebView, resizeCanvasAutomationWebView, screenshotCanvasAutomationWebView, } from './server.js';
 export { canvasState } from './canvas-state.js';
+export type { CanvasBoard } from './canvas-db.js';
+export type { BackupFile, BackupStatus } from './backup.js';
+export type { ExportManifest } from './board-export.js';
 export type { CanvasAnnotation, CanvasSnapshot, CanvasSnapshotGcResult, CanvasSnapshotListOptions, } from './canvas-state.js';
 export { findOpenCanvasPosition } from './placement.js';
 export { searchNodes, buildSpatialContext, detectClusters, findNeighborhoods } from './spatial-analysis.js';

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

@@ -114,5 +114,6 @@ export declare function diffLayouts(snapshotName: string, snapshotLayout: {
  */
 export declare function formatDiff(diff: SnapshotDiffResult): string;
 export declare const mutationHistory: MutationHistory;
+/** Direct callers share the same async-local attribution as node mutations. */
 export declare function setMutationActor(actor: MutationActor | null, writer?: string | null): void;
 export {};

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

@@ -10,6 +10,7 @@ export declare function agentSourceLabel(fallback: string): string;
 /** Runs operations in-process against the shared canvasState singleton. */
 export declare class LocalOperationInvoker implements OperationInvoker {
     private readonly source;
+    private readonly proxiedRead;
     /** `source` labels this caller's agent presence ('mcp', 'sdk', …). */
     constructor(source?: string);
     invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
@@ -18,6 +19,7 @@ export declare class LocalOperationInvoker implements OperationInvoker {
 export declare class HttpOperationInvoker implements OperationInvoker {
     private readonly baseUrl;
     private readonly source;
+    private readonly proxiedRead;
     /** `source` labels this caller's agent presence on the server ('cli', 'mcp', …). */
     constructor(baseUrl: string, source?: string);
     invoke(name: string, rawInput: Record<string, unknown>): Promise<unknown>;

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

@@ -1,9 +1,15 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { OperationInvoker } from './invoker.js';
+import { type OperationInvoker } from './invoker.js';
 import { type OperationMcpToolHost } from './types.js';
+import { type ContextReadInput } from '../context-reads.js';
 import { type CompositeToolDefinition } from './composites.js';
 export interface OperationToolHost extends OperationMcpToolHost {
     invoker(): OperationInvoker;
+    prepareContextRead(board?: string): Promise<{
+        boardId: string | null;
+        pinnedNodeIds: string[];
+    }>;
+    recordContextRead(read: ContextReadInput): Promise<void>;
 }
 export declare function registerOperationTools(server: McpServer, getHost: () => Promise<OperationToolHost>): void;
 /**

package/dist/types/server/operations/ops/app.d.ts

@@ -1,3 +1,4 @@
+import { type CanvasSizeAdjustment } from '../../canvas-operations.js';
 import { type ExternalMcpTransportConfig } from '../../mcp-app-runtime.js';
 import { type Operation, type OperationContext } from '../types.js';
 export interface OpenMcpAppCoreInput {
@@ -20,6 +21,7 @@ export interface OpenMcpAppCoreResult {
     toolCallId: string;
     sessionId: string;
     resourceUri: string;
+    sizeAdjustment?: CanvasSizeAdjustment;
 }
 /**
  * Open an external MCP app: connect + call + read resource (openExternalMcpApp),

package/dist/types/server/operations/ops/ax-shared.d.ts

@@ -16,14 +16,14 @@ export declare const AX_SOURCES: readonly ["agent", "amp", "api", "browser", "cl
 export declare const AX_SOURCE_SHAPE: z.ZodOptional<z.ZodEnum<{
     amp: "amp";
     agent: "agent";
+    system: "system";
+    sdk: "sdk";
     api: "api";
     browser: "browser";
     cli: "cli";
     codex: "codex";
     copilot: "copilot";
     mcp: "mcp";
-    sdk: "sdk";
-    system: "system";
 }>>;
 /** Zod schema for the optional `agentId` field shared by AX MCP tool shapes. */
 export declare const AX_AGENT_ID_SHAPE: z.ZodOptional<z.ZodString>;

package/dist/types/server/operations/ops/backup.d.ts

@@ -0,0 +1,2 @@
+import { type Operation } from '../types.js';
+export declare const backupOperations: Operation[];

package/dist/types/server/operations/ops/boards.d.ts

@@ -0,0 +1,10 @@
+import { type CanvasLayout } from '../../canvas-state.js';
+import { type Operation } from '../types.js';
+export declare function boardsPayload(): Record<string, unknown>;
+/** Read a board without opening it. Omitted board preserves the active-board contract. */
+export declare function readTargetBoard(boardId?: unknown, includeBlobs?: boolean): {
+    boardId: string | null;
+    layout: CanvasLayout;
+    pinnedNodeIds: Set<string>;
+};
+export declare const boardOperations: Operation[];

package/dist/types/server/operations/ops/export.d.ts

@@ -0,0 +1,2 @@
+import { type Operation } from '../types.js';
+export declare const exportOperations: Operation[];

package/dist/types/server/operations/ops/imports.d.ts

@@ -0,0 +1,2 @@
+import { type Operation } from '../types.js';
+export declare const importOperations: Operation[];

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

@@ -1,3 +1,4 @@
+import { type CanvasSizeAdjustment } from '../../canvas-operations.js';
 import { type Operation } from '../types.js';
 /** Legacy server.ts parseGraphPayloadData: a graph dataset must be an array of records. */
 export declare function parseGraphPayloadData(value: unknown): Array<Record<string, unknown>> | null;
@@ -21,6 +22,7 @@ export interface StreamJsonRenderResult {
     specVersion: number;
     elementCount: number;
     streamStatus: 'open' | 'closed';
+    sizeAdjustment?: CanvasSizeAdjustment;
 }
 /**
  * Create-or-append core for streaming json-render nodes (the SDK's

package/dist/types/server/operations/ops/nodes.d.ts

@@ -1,6 +1,7 @@
 import { type CanvasLayout, type CanvasNodeState } from '../../canvas-state.js';
+import { type CanvasSizeAdjustment } from '../../canvas-operations.js';
 import { type Operation } from '../types.js';
-export declare const NODE_TYPES: readonly ["markdown", "status", "context", "ledger", "trace", "file", "diff", "mermaid", "image", "mcp-app", "webpage", "html", "group"];
+export declare const NODE_TYPES: readonly ["markdown", "board", "status", "context", "ledger", "trace", "file", "diff", "mermaid", "image", "mcp-app", "webpage", "html", "group"];
 /** Per-type default node frame size (formerly copy-pasted ladders). */
 export declare function defaultNodeSize(type: string): {
     width: number;
@@ -30,7 +31,7 @@ export declare function agentSafeFullLayoutPayload(layout: CanvasLayout): Record
  * agents using either key (or a cached schema) work — matching the
  * external-app / web-artifact responses that already return both.
  */
-export declare function createdNodePayloadFromNode(node: CanvasNodeState, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function createdNodePayloadFromNode(node: CanvasNodeState, options?: Record<string, unknown>, extras?: Record<string, unknown>): Record<string, unknown>;
 /**
  * Create a basic (non-webpage / non-group / non-primitive) node. Union of the
  * legacy handleCanvasAddNode generic branch; the SDK passes fileMode 'path',
@@ -41,6 +42,7 @@ export declare function createBasicCanvasNode(body: Record<string, unknown>, opt
 }): {
     node: CanvasNodeState;
     needsCodeGraphRecompute: boolean;
+    sizeAdjustment?: CanvasSizeAdjustment;
 };
 /**
  * Build a node patch with the full HTTP superset semantics (webpage

package/dist/types/server/operations/ops/query.d.ts

@@ -1,2 +1,4 @@
 import { type Operation } from '../types.js';
+export declare const DEFAULT_CONTEXT_BRIEF_BUDGET = 16000;
+export declare const MAX_CONTEXT_BRIEF_BUDGET = 100000;
 export declare const queryOperations: Operation[];

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

@@ -9,7 +9,7 @@ export declare function setOperationEventEmitter(emitter: OperationEventEmitter
  * mcpapp.open, whose canvas node is created as a side-effect of `ext-app-open` —
  * use this to reject loudly instead of silently no-op'ing in a suppressed run. */
 export declare function isEmitSuppressed(): boolean;
-/** Run `fn` with all operation SSE emits suppressed; restores depth on finally. */
+/** Suppress this call chain's per-entry frames; the batch emits its final frame afterward. */
 export declare function runWithSuppressedEmits<T>(fn: () => Promise<T>): Promise<T>;
 export interface ExecuteOperationMeta {
     /**
@@ -29,6 +29,14 @@ export interface ExecuteOperationMeta {
      * to agents only, and batch inner writes are always agent-originated.
      */
     fromWorkbench?: boolean;
+    /** Authorship only: true when the per-boot workbench token matched. */
+    humanAuthor?: boolean;
+    /**
+     * An MCP server attached to this daemon, or a host adapter, fetching on an
+     * agent's behalf. It records the read the agent actually made itself
+     * (POST /api/canvas/ax/context-reads), so this fetch is not recorded.
+     */
+    proxiedRead?: boolean;
 }
 export declare function executeOperation(name: string, rawInput: unknown, meta?: ExecuteOperationMeta): Promise<unknown>;
 export {};

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

@@ -45,7 +45,7 @@ export interface OperationHttpRoute {
 }
 /** Host capabilities available to MCP result formatters. */
 export interface OperationMcpToolHost {
-    getPinnedNodeIds(): Promise<string[]>;
+    getPinnedNodeIds(board?: string): Promise<string[]>;
     /**
      * Invoke another registered operation over the host's transport (local or
      * HTTP) — structural subset of OperationInvoker to avoid an import cycle.

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

@@ -23,6 +23,7 @@
  * - POST /api/canvas/graph        -> create a native graph node
  * - GET  /api/canvas/json-render/view?nodeId=... -> local json-render viewer
  * - GET  /api/canvas/file-bytes?nodeId=... -> raw bytes for a file node
+ * - GET  /api/canvas/exports/<file>        -> a written static board export (sandboxed)
  * - POST /api/canvas/web-artifact -> build bundled HTML artifact + optional canvas node
  * - GET  /api/workbench/events   -> SSE event stream
  * - GET  /api/workbench/poll     -> proxy-safe polling transport (same events, JSON)

package/dist/types/server/trace-manager.d.ts

@@ -37,6 +37,13 @@ declare class TraceManager {
         durationMs?: number;
         failed?: boolean;
     }): void;
+    /**
+     * The chain's last node is gone (another board was opened, or it was
+     * deleted): start a new chain instead of wiring edges to a missing node.
+     */
+    private dropStaleChain;
+    /** Forget the trace chain without touching nodes. */
+    resetChain(): void;
     clearTrace(): void;
     getTraceNodeCount(): number;
     private getOrigin;

package/dist/types/server/web-artifacts.d.ts

@@ -1,3 +1,4 @@
+import { type CanvasSizeAdjustment } from './canvas-operations.js';
 export interface WebArtifactBuildInput {
     title: string;
     appTsx: string;
@@ -41,11 +42,13 @@ export interface WebArtifactSourceContext {
 export interface WebArtifactCanvasOpenResult {
     nodeId: string;
     url: string;
+    sizeAdjustment: CanvasSizeAdjustment;
 }
 export interface WebArtifactCanvasBuildResult extends WebArtifactBuildOutput {
     openedInCanvas: boolean;
     nodeId?: string;
     url?: string;
+    sizeAdjustment?: CanvasSizeAdjustment;
     startedAt: string;
     completedAt: string;
     durationMs: number;

package/dist/types/server/webpage-node.d.ts

@@ -17,9 +17,30 @@ export interface WebpageSnapshot {
 }
 export declare function normalizeWebpageUrl(rawUrl: string): string;
 export declare function summarizeWebpageContent(data: Record<string, unknown>, maxLength?: number): string;
-export declare function fetchWebpageSnapshot(inputUrl: string): Promise<WebpageSnapshot>;
+export type AddressScope = 'public' | 'private' | 'link-local';
+/**
+ * Where an IP literal points. `private` covers loopback, RFC 1918, CGNAT and
+ * IPv6 ULA; `link-local` is kept apart because it holds cloud metadata
+ * (169.254.169.254) and is refused on every hop.
+ */
+export declare function classifyAddress(address: string): AddressScope;
+type ResolveHost = (hostname: string) => Promise<Array<{
+    address: string;
+    family: number;
+}>>;
+/**
+ * Refuses link-local on every hop, and a redirect that moves a public fetch
+ * onto a loopback or private address. A URL the caller points at a local dev
+ * server on purpose still loads, and may redirect within the local network.
+ */
+export declare function checkWebpageHop(originScope: AddressScope, hopScope: AddressScope, hopUrl: string): void;
+export declare function fetchWebpageSnapshot(inputUrl: string, options?: {
+    resolveHost?: ResolveHost;
+    timeoutMs?: number;
+}): Promise<WebpageSnapshot>;
 export declare function getWebpageFetchErrorDetails(error: unknown): {
     message: string;
     statusCode: number | null;
     contentType: string | null;
 };
+export {};

package/dist/types/server/workbench-auth.d.ts

@@ -0,0 +1,3 @@
+/** Per-process capability used only to distinguish workbench clicks from HTTP agents. */
+export declare const workbenchToken: string;
+export declare function isWorkbenchToken(value: string | null): boolean;

package/dist/types/shared/boards.d.ts

@@ -0,0 +1,6 @@
+/** The Home category migrated 0.6 snapshots land on, so they do not bury the boards in use. */
+export declare const MIGRATED_SNAPSHOT_CATEGORY = "From old snapshots";
+/** Slash-separated folder paths shared by the UI, HTTP/MCP and SDK. */
+export declare function normalizeBoardCategory(value: string | null): string | null;
+/** Includes implicit parents, so a board in A/B can also be moved into A. */
+export declare function categoryAncestors(path: string): string[];

package/dist/types/shared/tour.d.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export declare const cameraSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    scale: z.ZodNumber;
+}, z.core.$strip>;
+export declare const tourStopSchema: z.ZodObject<{
+    target: z.ZodUnion<readonly [z.ZodObject<{
+        nodeId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        viewport: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            scale: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strict>]>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    easing: z.ZodOptional<z.ZodEnum<{
+        linear: "linear";
+        "ease-in-out": "ease-in-out";
+        "ease-out": "ease-out";
+    }>>;
+    padding: z.ZodOptional<z.ZodNumber>;
+    pullback: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const tourSchema: z.ZodObject<{
+    stops: z.ZodArray<z.ZodObject<{
+        target: z.ZodUnion<readonly [z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            viewport: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                scale: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strict>]>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        easing: z.ZodOptional<z.ZodEnum<{
+            linear: "linear";
+            "ease-in-out": "ease-in-out";
+            "ease-out": "ease-out";
+        }>>;
+        padding: z.ZodOptional<z.ZodNumber>;
+        pullback: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Tour = z.infer<typeof tourSchema>;
+export type TourStop = z.infer<typeof tourStopSchema>;
+export type Camera = z.infer<typeof cameraSchema>;
+export interface TourNode {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+}
+export declare function derivedTour(nodes: TourNode[]): Tour;
+export declare function resolveStop(stop: TourStop, nodes: TourNode[], width: number, height: number): Camera;
+/** Interpolate world-space centres and log zoom; translations remain screen-space. */
+export declare function interpolateCamera(from: Camera, to: Camera, progress: number, width: number, height: number, easing?: TourStop['easing'], pullback?: number): Camera;
+/** Each segment includes its endpoint; zero-duration stops take one frame. */
+export declare function segmentFrameCount(duration: number, fps: number): number;
+export declare function tourFrames(tour: Tour, initial: Camera, nodes: TourNode[], width: number, height: number, fps: number): Generator<{
+    x: number;
+    y: number;
+    scale: number;
+}, void, unknown>;

package/docs/RELEASE.md

@@ -40,6 +40,11 @@ bun run pack:dry-run        # confirms the tarball shape
 do not call `bun x playwright test` directly; it fails before test
 discovery with a `.esm.preflight` loader error (ERR-20260508-001).
 
+The Playwright run includes the `pane-600` project
+(`tests/e2e/reference-pane.pw.ts`): the reference surface, Chromium at
+600 px. Every node type must paint there or the release does not ship.
+Embedded WebKit panes (the Copilot app) stay best-effort.
+
 `bun run test:e2e-cli` starts a local server in a fresh temp workspace
 and exercises the CLI flows from
 [`docs/evals/e2e-cli-coverage.md`](evals/e2e-cli-coverage.md).