pmx-canvas 0.1.35 → 0.2.0

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

@@ -10,7 +10,7 @@
  * Legacy `.pmx-canvas/state.json` is auto-migrated on first boot.
  */
 import { type PersistedCanvasState, type CanvasTheme, type AxTimelineQuery } from './canvas-db.js';
-import { type PmxAxElicitation, type PmxAxModeRequest, type PmxAxMode, type PmxAxCommandDescriptor, type PmxAxPolicy, type PmxAxFocusState, type PmxAxSource, type PmxAxState, type PmxAxWorkItem, type PmxAxWorkItemStatus, type PmxAxApprovalGate, type PmxAxReviewAnnotation, type PmxAxReviewKind, type PmxAxReviewSeverity, type PmxAxReviewStatus, type PmxAxReviewAnchorType, type PmxAxReviewRegion, type PmxAxEvent, type PmxAxEventKind, type PmxAxEvidence, type PmxAxEvidenceKind, type PmxAxSteeringMessage, type PmxAxHostCapability, type PmxAxTimelineSummary } from './ax-state.js';
+import { type PmxAxActivityKind, type PmxAxElicitation, type PmxAxModeRequest, type PmxAxMode, type PmxAxCommandDescriptor, type PmxAxPolicy, type PmxAxFocusState, type PmxAxSource, type PmxAxState, type PmxAxWorkItem, type PmxAxWorkItemStatus, type PmxAxApprovalGate, type PmxAxReviewAnnotation, type PmxAxReviewKind, type PmxAxReviewSeverity, type PmxAxReviewStatus, type PmxAxReviewAnchorType, type PmxAxReviewRegion, type PmxAxEvent, type PmxAxEventKind, type PmxAxEvidence, type PmxAxEvidenceKind, type PmxAxSteeringMessage, type PmxAxHostCapability, type PmxAxTimelineSummary } from './ax-state.js';
 export declare const PMX_CANVAS_DIR = ".pmx-canvas";
 export interface PersistedBlobRef {
     __pmxCanvasBlob: 'v1';
@@ -142,12 +142,16 @@ declare class CanvasStateManager {
     private _viewport;
     private _theme;
     private _contextPinnedNodeIds;
-    private _axState;
-    private _axHostCapability;
     private _workspaceRoot;
+    private readonly ax;
     private _changeListeners;
-    /** Register a listener for state changes. Used by MCP server to emit resource notifications. */
-    onChange(cb: (type: CanvasChangeType) => void): void;
+    /**
+     * Register a listener for state changes. Used by MCP server to emit resource
+     * notifications and by the blocking-wait endpoints to await an AX transition.
+     * Returns a disposer that unregisters the listener (callers that don't need it
+     * — e.g. the long-lived MCP subscription — may ignore the return value).
+     */
+    onChange(cb: (type: CanvasChangeType) => void): () => void;
     private notifyChange;
     private _mutationRecorder;
     private _suppressRecordingDepth;
@@ -159,8 +163,6 @@ declare class CanvasStateManager {
     private suppressed;
     private recordMutation;
     private currentNodeIdSet;
-    private normalizeAxForCurrentNodes;
-    private applyAxState;
     private applyResolvedGroupBounds;
     private getGroupSnapshot;
     private normalizeNode;
@@ -346,6 +348,9 @@ declare class CanvasStateManager {
         resolution?: string;
         source?: PmxAxSource;
     }): PmxAxModeRequest | null;
+    getApproval(id: string): PmxAxApprovalGate | null;
+    getElicitation(id: string): PmxAxElicitation | null;
+    getModeRequest(id: string): PmxAxModeRequest | null;
     getCommandRegistry(): PmxAxCommandDescriptor[];
     /** Invoke a registry-gated PMX command intent — records a timeline event (no execution). */
     invokeCommand(name: string, args?: Record<string, unknown> | null, options?: {
@@ -356,10 +361,10 @@ declare class CanvasStateManager {
     setPolicy(patch: {
         tools?: Partial<PmxAxPolicy['tools']>;
         prompt?: Partial<PmxAxPolicy['prompt']>;
-    }, _options?: {
+    }, options?: {
         source?: PmxAxSource;
     }): PmxAxPolicy;
-    setHostCapability(input: unknown, _options?: {
+    setHostCapability(input: unknown, options?: {
         source?: PmxAxSource;
     }): PmxAxHostCapability;
     recordAxEvent(input: {
@@ -385,16 +390,43 @@ declare class CanvasStateManager {
         source?: PmxAxSource;
     }): PmxAxSteeringMessage;
     markSteeringDelivered(id: string): boolean;
+    ingestActivity(input: {
+        kind: PmxAxActivityKind;
+        title: string;
+        summary?: string | null;
+        outcome?: 'success' | 'failure';
+        ref?: string | null;
+        nodeIds?: string[];
+        data?: Record<string, unknown> | null;
+        reactions?: {
+            workItem?: false | {
+                status?: PmxAxWorkItemStatus;
+                detail?: string | null;
+            };
+            evidence?: false | {
+                kind?: PmxAxEvidenceKind;
+                body?: string | null;
+            };
+            review?: false | {
+                severity?: PmxAxReviewSeverity;
+                kind?: PmxAxReviewKind;
+                anchorType?: PmxAxReviewAnchorType;
+                nodeId?: string | null;
+            };
+        };
+    }, options?: {
+        source?: PmxAxSource;
+    }): {
+        event: PmxAxEvent;
+        workItem: PmxAxWorkItem | null;
+        evidence: PmxAxEvidence | null;
+        review: PmxAxReviewAnnotation | null;
+    };
     getAxEvents(q?: AxTimelineQuery): PmxAxEvent[];
     getAxEvidence(q?: AxTimelineQuery): PmxAxEvidence[];
     getAxSteering(q?: AxTimelineQuery & {
         onlyPending?: boolean;
     }): PmxAxSteeringMessage[];
-    /**
-     * Undelivered steering for a consumer (Phase 4 delivery). Excludes messages
-     * whose source equals the consumer to prevent delivery loops (e.g. Copilot
-     * should not be handed back steering it originated).
-     */
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;

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

@@ -27,6 +27,13 @@ export declare function normalizeSurfaceTheme(value: string | null | undefined):
  * injected when the node's AX capabilities are enabled (opt-in for `html`), and
  * the server re-validates every interaction — so this is a convenience surface,
  * not a trust boundary.
+ *
+ * `emit` returns a Promise that resolves with the interaction result once the
+ * parent acks it (report #55 — built-in confirmation so a click no longer looks
+ * like "nothing happened"). Authors can also `window.PMX_AX.on('ack', cb)` or
+ * listen for the `pmx-ax-ack` CustomEvent. Resolves with an `ax-ack-timeout`
+ * result after 10s if no ack arrives (e.g. an older parent), so `await emit()`
+ * never hangs.
  */
 export declare function buildAxBridge(axToken: string, nodeId: string): string;
 /**

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

@@ -2,11 +2,12 @@ import { EventEmitter } from 'node:events';
 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 { 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 { 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 { searchNodes } from './spatial-analysis.js';
 import { diffLayouts } from './mutation-history.js';
 import { fitCanvasView, gcCanvasSnapshots, listCanvasSnapshots } from './canvas-operations.js';
+import { type OpenMcpAppCoreResult } from './operations/index.js';
 import { type SerializedCanvasNode } from './canvas-serialization.js';
 import type { HtmlPrimitiveKind } from './html-primitives.js';
 import { type WebArtifactBuildInput, type WebArtifactCanvasBuildResult } from './web-artifacts.js';
@@ -88,6 +89,7 @@ export declare class PmxCanvas extends EventEmitter {
         error?: string;
     }>;
     updateNode(id: string, patch: Partial<CanvasNodeState> & Record<string, unknown>): void;
+    /** Remove a node. Missing id throws (plan-005 unifies this across surfaces). */
     removeNode(id: string): void;
     addEdge(input: {
         from?: string;
@@ -134,7 +136,9 @@ export declare class PmxCanvas extends EventEmitter {
         panned: boolean;
     } | null;
     getAxState(): PmxAxState;
-    getAxContext(): PmxAxContext;
+    getAxContext(options?: {
+        consumer?: string;
+    }): PmxAxContext;
     setAxFocus(nodeIds: string[], options?: {
         source?: PmxAxSource;
     }): PmxAxFocusState;
@@ -253,6 +257,62 @@ export declare class PmxCanvas extends EventEmitter {
         resolution?: string;
         source?: PmxAxSource;
     }): PmxAxModeRequest | null;
+    ingestActivity(input: {
+        kind: PmxAxActivityKind;
+        title: string;
+        summary?: string | null;
+        outcome?: 'success' | 'failure';
+        ref?: string | null;
+        nodeIds?: string[];
+        data?: Record<string, unknown> | null;
+        reactions?: {
+            workItem?: false | {
+                status?: PmxAxWorkItemStatus;
+                detail?: string | null;
+            };
+            evidence?: false | {
+                kind?: PmxAxEvidenceKind;
+                body?: string | null;
+            };
+            review?: false | {
+                severity?: PmxAxReviewSeverity;
+                kind?: PmxAxReviewKind;
+                anchorType?: PmxAxReviewAnchorType;
+                nodeId?: string | null;
+            };
+        };
+    }, options?: {
+        source?: PmxAxSource;
+    }): {
+        event: PmxAxEvent;
+        workItem: PmxAxWorkItem | null;
+        evidence: PmxAxEvidence | null;
+        review: PmxAxReviewAnnotation | null;
+    };
+    getApproval(id: string): PmxAxApprovalGate | null;
+    getElicitation(id: string): PmxAxElicitation | null;
+    getModeRequest(id: string): PmxAxModeRequest | null;
+    awaitApproval(id: string, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        approvalGate: PmxAxApprovalGate | null;
+        pending: boolean;
+    }>;
+    awaitElicitation(id: string, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        elicitation: PmxAxElicitation | null;
+        pending: boolean;
+    }>;
+    awaitMode(id: string, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        modeRequest: PmxAxModeRequest | null;
+        pending: boolean;
+    }>;
     getCommandRegistry(): PmxAxCommandDescriptor[];
     invokeCommand(name: string, args?: Record<string, unknown> | null, options?: {
         source?: PmxAxSource;
@@ -329,7 +389,6 @@ export declare class PmxCanvas extends EventEmitter {
         summary: import("./code-graph.js").CodeGraphSummary;
     };
     validate(): import("./canvas-validation.js").CanvasValidationResult;
-    private findCanvasExtAppNodeId;
     describeSchema(): {
         ok: true;
         source: "running-server";
@@ -362,15 +421,10 @@ export declare class PmxCanvas extends EventEmitter {
         op: string;
         assign?: string;
         args?: Record<string, unknown>;
-    }>): Promise<{
-        ok: boolean;
-        results: Array<Record<string, unknown>>;
-        refs: Record<string, unknown>;
-        failedIndex?: number;
-        error?: string;
-    }>;
+    }>): Promise<import("./operations/index.js").BatchEnvelope>;
     buildWebArtifact(input: WebArtifactBuildInput & {
         openInCanvas?: boolean;
+        includeLogs?: boolean;
     }): Promise<WebArtifactCanvasBuildResult>;
     openMcpApp(input: {
         transport: ExternalMcpTransportConfig;
@@ -384,22 +438,8 @@ export declare class PmxCanvas extends EventEmitter {
         width?: number;
         height?: number;
         timeoutMs?: number;
-    }): Promise<{
-        ok: true;
-        id?: string;
-        nodeId: string | null;
-        toolCallId: string;
-        sessionId: string;
-        resourceUri: string;
-    }>;
-    addDiagram(input: DiagramPresetOpenInput): Promise<{
-        ok: true;
-        id?: string;
-        nodeId: string | null;
-        toolCallId: string;
-        sessionId: string;
-        resourceUri: string;
-    }>;
+    }): Promise<OpenMcpAppCoreResult>;
+    addDiagram(input: DiagramPresetOpenInput): Promise<OpenMcpAppCoreResult>;
     addJsonRenderNode(input: JsonRenderNodeInput): {
         id: string;
         url: string;

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

@@ -0,0 +1,121 @@
+/**
+ * Composite MCP tools (plan-006: MCP tool consolidation).
+ *
+ * A composite tool folds several single-purpose MCP tools into one tool with an
+ * `action` discriminator. It is a PRESENTATION-LAYER construct only: each action
+ * dispatches to an already-registered operation (`src/server/operations/ops/*`)
+ * via the same invoker, reusing that operation's own `mcp.buildInput` and
+ * `mcp.formatResult`. So `canvas_edge { action: "add", ... }` is byte-identical
+ * to the standalone `canvas_add_edge` — same op, same arg mapping, same result
+ * shape — by construction. No handler logic lives here.
+ *
+ * Migration (docs/api-stability.md + plan-006): composites land ADDITIVELY in
+ * v0.2 alongside the legacy single-purpose tools (the tool surface grows, then
+ * shrinks when the legacy tools are removed in v0.3). Every action here maps to a
+ * registry-backed operation (plan-005 slices 1–7 + plan-008 Wave 1).
+ *
+ * Still deferred (its legacy standalone tool keeps working; see plan-008): the
+ * `canvas_snapshot` composite (the v0.3 name collision). The action enums are
+ * forward-compatible: adding an action later is additive. (`canvas_webview`
+ * shipped in plan-008 Wave 3 via runner injection; `canvas_app` shipped in Wave 4
+ * — open-mcp-app / diagram / build-artifact. Wave 5 folded the last three legacy
+ * tools deprecate-only — NO per-action input-injection mechanism was needed:
+ * `canvas_add_html_node` / `canvas_add_html_primitive` → `canvas_node` action
+ * "add" (type:"html" [+ primitive]); `canvas_refresh_webpage_node` → `canvas_node`
+ * action "update" (refresh:true). `canvas_screenshot` stays standalone — it
+ * returns a binary image payload the composite/registry JSON wire shape does not
+ * model.)
+ *
+ * Not shipped here: the `canvas_snapshot` composite (plan-006 #7). Its target
+ * name is ALREADY a legacy standalone tool (the save-snapshot tool, op
+ * `snapshot.save`), so it cannot be added additively without a name clash, and
+ * repurposing `canvas_snapshot` to be action-discriminated now would break
+ * existing callers. It lands in v0.3, in the same change that removes the legacy
+ * single-purpose snapshot tools and frees the name.
+ *
+ * This module must never import server.ts or index.ts.
+ */
+import { type ZodRawShape } from 'zod';
+/**
+ * One composite MCP tool: a frozen tool name + its action→operation routing.
+ *
+ * Two flavours:
+ *  - Single-discriminator (the wave-1 composites + the 4 single-discriminator AX
+ *    composites): the flat `actions` map routes one `action` value → one op.
+ *  - Two-discriminator (`canvas_ax_gate`, plan-007 Slice C): a `kind` × `action`
+ *    matrix folds 9 ops into one tool. Set `extraDiscriminatorShape` (the `kind`
+ *    enum), `memberOps` (the op names — used to derive the schema union + the
+ *    deprecation notes), `actionEnum` (the action discriminator values), and
+ *    `resolveOp` (maps `{ kind, action }` → op name, or undefined for an invalid
+ *    combo → a loud error at dispatch). The flat `actions` map is left empty for
+ *    these; the matrix path uses `resolveOp` instead.
+ */
+export interface CompositeToolDefinition {
+    /** Frozen public tool name (see tests/unit/mcp-tool-freeze.test.ts). */
+    toolName: string;
+    description: string;
+    /** Human-readable action list for the `action` enum description. */
+    actionSummary: string;
+    /**
+     * Map of `action` value → registry operation name (single-discriminator
+     * composites). Empty for two-discriminator composites. Every referenced op
+     * MUST have an `mcp` block — its `buildInput`/`formatResult` are reused so the
+     * composite action matches the legacy standalone tool exactly.
+     */
+    actions: Record<string, string>;
+    /**
+     * Two-discriminator extension (e.g. `canvas_ax_gate`). The extra discriminator
+     * shape — a single `kind` enum — merged into the advertised schema alongside
+     * `action`.
+     */
+    extraDiscriminatorShape?: ZodRawShape;
+    /**
+     * Two-discriminator extension: the action enum values (used to build the
+     * `action` discriminator when there is no flat `actions` map to derive it from).
+     */
+    actionEnum?: readonly string[];
+    /**
+     * Two-discriminator extension: every member op name. Used to build the schema
+     * union (all member-op fields, optional) and to derive a deprecation note per
+     * member op (each mapped back to its (kind, action) by `describeOp`).
+     */
+    memberOps?: string[];
+    /**
+     * Two-discriminator extension: resolve the op name from the validated
+     * discriminators. Returns `undefined` for an invalid combo so dispatch can
+     * raise a loud error instead of silently no-op'ing.
+     */
+    resolveOp?: (input: {
+        kind: string;
+        action: string;
+    }) => string | undefined;
+    /**
+     * Two-discriminator extension: human-readable `(kind, action)` for a member op
+     * (the inverse of `resolveOp`), used to build that op's deprecation note. The
+     * `kind` field-collision is resolved here (see `gateFieldRemap`).
+     */
+    describeOp?: (opName: string) => {
+        kind: string;
+        action: string;
+    } | undefined;
+    /**
+     * Field-name remap applied to the composite's advertised schema and undone at
+     * dispatch. Resolves a collision between a discriminator name and a member-op
+     * field of the same name (e.g. `ax.approval.request` has its own `action`
+     * field — namespaced to `approvalAction` in the composite so the `action`
+     * discriminator wins, then mapped back before invoking the op). Keys are the
+     * composite (public) field names; values are the op field names.
+     */
+    fieldRemap?: Record<string, string>;
+}
+export declare const compositeToolDefinitions: CompositeToolDefinition[];
+/**
+ * Deprecation notes for the legacy single-purpose tools, DERIVED from the
+ * composites: every operation a composite folds gets a `Deprecated: use
+ * canvas_x with action "y".` prefix on its standalone tool description, steering
+ * agents to the composite during the v0.2 overlap window (the legacy tools and
+ * these notes are removed together in v0.3). Keyed by registry operation name.
+ * Deriving it keeps the deprecation list in lockstep with the composites — a new
+ * folded action automatically deprecates the tool it replaces.
+ */
+export declare function buildCompositeDeprecationNotes(definitions?: CompositeToolDefinition[]): Map<string, string>;

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

@@ -0,0 +1,7 @@
+/**
+ * Shared body reader: preserves the parsed JSON value as-is (object, array,
+ * or primitive) — per-op `readInput` decides what to do with non-object
+ * bodies; the shared reader never coerces.
+ */
+export declare function readJsonValue(req: Request): Promise<unknown>;
+export declare function dispatchOperationRoute(req: Request, url: URL): Promise<Response | null>;

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

@@ -0,0 +1,8 @@
+export { executeOperation, getOperation, listOperations, registerOperation, setOperationEventEmitter, } from './registry.js';
+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 { compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
+export { OperationError, defineOperation, type Operation, type OperationContext, type OperationDefinition, type OperationErrorStatus, } from './types.js';

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

@@ -0,0 +1,13 @@
+export interface OperationInvoker {
+    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+}
+/** Runs operations in-process against the shared canvasState singleton. */
+export declare class LocalOperationInvoker implements OperationInvoker {
+    invoke(name: string, input: Record<string, unknown>): 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 {
+    private readonly baseUrl;
+    constructor(baseUrl: string);
+    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+}

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

@@ -0,0 +1,15 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { OperationInvoker } from './invoker.js';
+import { type OperationMcpToolHost } from './types.js';
+import { type CompositeToolDefinition } from './composites.js';
+export interface OperationToolHost extends OperationMcpToolHost {
+    invoker(): OperationInvoker;
+}
+export declare function registerOperationTools(server: McpServer, getHost: () => Promise<OperationToolHost>): void;
+/**
+ * Register composite (action-discriminated) MCP tools (plan-006). Each action
+ * dispatches to a registered operation, reusing that op's `mcp.buildInput` and
+ * `mcp.formatResult` so the composite action is byte-identical to the standalone
+ * tool it folds. Defaults to `compositeToolDefinitions`.
+ */
+export declare function registerCompositeTools(server: McpServer, getHost: () => Promise<OperationToolHost>, definitions?: CompositeToolDefinition[]): void;

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

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

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

@@ -0,0 +1,33 @@
+import { type ExternalMcpTransportConfig } from '../../mcp-app-runtime.js';
+import { type Operation, type OperationContext } from '../types.js';
+export interface OpenMcpAppCoreInput {
+    transport: ExternalMcpTransportConfig;
+    toolName: string;
+    toolArguments?: Record<string, unknown>;
+    nodeId?: string;
+    serverName?: string;
+    title?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    timeoutMs?: number;
+}
+export interface OpenMcpAppCoreResult {
+    ok: true;
+    id?: string;
+    nodeId: string | null;
+    toolCallId: string;
+    sessionId: string;
+    resourceUri: string;
+}
+/**
+ * Open an external MCP app: connect + call + read resource (openExternalMcpApp),
+ * close any prior session on an in-place node, emit `ext-app-open` +
+ * `ext-app-result`, then resolve the resulting canvas node id. This is the exact
+ * legacy SDK `openMcpApp` body, relocated; both the mcpapp.open op AND the SDK
+ * call it. The diagram.open op delegates here after building the Excalidraw input
+ * (the SSE pair fires ONCE — diagram.open does not re-emit).
+ */
+export declare function openMcpAppCore(input: OpenMcpAppCoreInput, ctx: OperationContext): Promise<OpenMcpAppCoreResult>;
+export declare const appOperations: Operation[];

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

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

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

@@ -0,0 +1,31 @@
+/**
+ * Shared helpers for the AX operation modules (ax-state.ts, ax-work.ts, and the
+ * later timeline/delivery waves). These were replicated per-file during the
+ * plan-007 Slice B migration; centralizing them here keeps one definition site
+ * as more AX op files land.
+ *
+ * `normalizeAxSource` / `normalizeAxNodeIds` are reimplemented from server.ts
+ * because `operations/` must never import server.ts (the SSE emitter is injected;
+ * see plan-005). This module likewise must not import server.ts or index.ts.
+ */
+import { z } from 'zod';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { PmxAxSource } from '../../ax-state.js';
+export declare const AX_SOURCES: readonly ["agent", "api", "browser", "cli", "codex", "copilot", "mcp", "sdk", "system"];
+/** Zod schema for the optional `source` field shared by AX MCP tool shapes. */
+export declare const AX_SOURCE_SHAPE: z.ZodOptional<z.ZodEnum<{
+    agent: "agent";
+    api: "api";
+    browser: "browser";
+    cli: "cli";
+    codex: "codex";
+    copilot: "copilot";
+    mcp: "mcp";
+    sdk: "sdk";
+    system: "system";
+}>>;
+/** An absent or unrecognized source falls back to the per-surface default. */
+export declare function normalizeAxSource(value: unknown, fallback: PmxAxSource): PmxAxSource;
+export declare function normalizeAxNodeIds(value: unknown): string[];
+/** The plain JSON tool result shared by AX ops whose MCP body is the wire body. */
+export declare function axJsonResult(result: unknown): CallToolResult;

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+import { type Operation } from '../types.js';
+export interface BatchEnvelope {
+    ok: boolean;
+    results: Array<Record<string, unknown>>;
+    refs: Record<string, unknown>;
+    failedIndex?: number;
+    error?: string;
+}
+export declare const batchOperations: Operation[];
+/**
+ * Typed SDK entry point: run a batch through the registry's single execution
+ * path (`executeOperation('canvas.batch')`). The op emits the one final
+ * canvas-layout-update itself, so callers must NOT emit again.
+ */
+export declare function runCanvasBatchOperation(operations: Array<{
+    op: string;
+    assign?: string;
+    args?: Record<string, unknown>;
+}>): Promise<BatchEnvelope>;

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

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

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

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

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

@@ -0,0 +1,31 @@
+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;
+export interface StreamJsonRenderInput {
+    nodeId?: string;
+    title?: string;
+    patches?: unknown[];
+    done?: boolean;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    strictSize?: boolean;
+}
+export interface StreamJsonRenderResult {
+    id: string;
+    url: string;
+    ok: true;
+    applied: number;
+    skipped: number;
+    specVersion: number;
+    elementCount: number;
+    streamStatus: 'open' | 'closed';
+}
+/**
+ * Create-or-append core for streaming json-render nodes (the SDK's
+ * streamJsonRenderNode wraps this directly). Throws OperationError(400) when
+ * the append target is missing or not a json-render node.
+ */
+export declare function streamJsonRenderCore(input: StreamJsonRenderInput): StreamJsonRenderResult;
+export declare const jsonRenderOperations: Operation[];

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

@@ -0,0 +1,62 @@
+import { type CanvasLayout, type CanvasNodeState } from '../../canvas-state.js';
+import { type Operation } from '../types.js';
+export declare const NODE_TYPES: readonly ["markdown", "status", "context", "ledger", "trace", "file", "image", "mcp-app", "webpage", "html", "group"];
+/** Per-type default node frame size (formerly copy-pasted ladders). */
+export declare function defaultNodeSize(type: string): {
+    width: number;
+    height: number;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function pickFiniteNumber(record: Record<string, unknown>, key: string): number | undefined;
+export declare function getRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function pickPositiveNumber(record: Record<string, unknown>, key: string): number | undefined;
+export declare function resolveCreateGeometry(body: Record<string, unknown>): {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+};
+export declare function setGroupChildrenFromApi(groupId: string, childIds: string[]): boolean;
+export declare function nodeAppSessionId(node: CanvasNodeState | undefined): string | null;
+export declare function closeNodeAppSession(node: CanvasNodeState | undefined): void;
+export declare function buildNodeResponse(node: CanvasNodeState): Record<string, unknown>;
+export declare function wantsFullPayload(input?: Record<string, unknown>): boolean;
+export declare function compactNodePayload(node: CanvasNodeState | undefined): Record<string, unknown> | null;
+export declare function buildSummaryFromLayout(layout: CanvasLayout, pinnedIds: string[]): Record<string, unknown>;
+export declare function compactLayoutPayload(layout: CanvasLayout, pinnedIds: string[]): Record<string, unknown>;
+export declare function agentSafeFullLayoutPayload(layout: CanvasLayout): Record<string, unknown>;
+/**
+ * Node-create/update MCP payload: exposes both `id` and a `nodeId` alias so
+ * 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>;
+/**
+ * Create a basic (non-webpage / non-group / non-primitive) node. Union of the
+ * legacy handleCanvasAddNode generic branch; the SDK passes fileMode 'path',
+ * the HTTP/MCP operation passes fileMode 'auto'.
+ */
+export declare function createBasicCanvasNode(body: Record<string, unknown>, options: {
+    fileMode: 'auto' | 'path';
+}): {
+    node: CanvasNodeState;
+    needsCodeGraphRecompute: boolean;
+};
+/**
+ * Build a node patch with the full HTTP superset semantics (webpage
+ * titleSource, html top-level fields, axCapabilities merge, group children,
+ * structured spec/graph updates, trace fields). Throws OperationError on
+ * validation failures. The SDK's updateNode delegates here.
+ */
+export declare function buildNodePatch(existing: CanvasNodeState, body: Record<string, unknown>): {
+    patch: Partial<CanvasNodeState>;
+    groupChildIds?: string[];
+};
+/**
+ * Remove a node (closing any mcp-app session). Missing id → OperationError 404
+ * on ALL surfaces (plan-005 deliberately unifies the old silent local success).
+ */
+export declare function removeNodeCore(id: string): {
+    needsCodeGraphRecompute: boolean;
+};
+export declare const nodeOperations: Operation[];

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

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