@tangle-network/agent-app 0.45.54 → 0.45.55

package/dist/{export-presets-mgVulRaV.d.ts → design-canvas/export-presets.d.ts}

@@ -1,5 +1,3 @@
-import { S as ScenePage, B as Bounds } from './model-DnfO_PdJ.js';
-
 /**
  * Page size presets, channel-size output presets, and export math for the
  * design canvas.
@@ -13,9 +11,9 @@ import { S as ScenePage, B as Bounds } from './model-DnfO_PdJ.js';
  *
  * All dimensions are CSS pixels at 96 DPI unless noted otherwise.
  */
-
+import type { Bounds, ScenePage } from './model';
 /** Define size presets with identifiers, labels, categories, and dimensions for various media types */
-interface SizePreset {
+export interface SizePreset {
     id: string;
     label: string;
     category: 'social' | 'print' | 'presentation' | 'custom';
@@ -23,14 +21,14 @@ interface SizePreset {
     height: number;
 }
 /** Provide predefined size presets for social, presentation, and print categories */
-declare const SIZE_PRESETS: readonly SizePreset[];
+export declare const SIZE_PRESETS: readonly SizePreset[];
 /** Resolve a size preset by its identifier or return null if not found */
-declare function findPreset(id: string): SizePreset | null;
+export declare function findPreset(id: string): SizePreset | null;
 /** Match a (width, height) pair against the preset table. Returns the first
  *  exact match or null — used to drive the dropdown selection indicator. */
-declare function matchPreset(width: number, height: number): SizePreset | null;
+export declare function matchPreset(width: number, height: number): SizePreset | null;
 /** Define supported image export formats as PNG or JPEG */
-type ExportFormat = 'png' | 'jpeg';
+export type ExportFormat = 'png' | 'jpeg';
 /**
  * Export quality preset — pins pixel density, optional output dimensions,
  * bleed inclusion, and raster format so callers pass a preset id rather than
@@ -40,7 +38,7 @@ type ExportFormat = 'png' | 'jpeg';
  * from the crop rect width (see `scaleForPreset`) so the output is exactly
  * this many pixels wide. When null, `pixelRatio` applies directly.
  */
-interface ExportPreset {
+export interface ExportPreset {
     name: string;
     /** Target pixels-per-document-px for stage.toDataURL. */
     pixelRatio: number;
@@ -51,9 +49,9 @@ interface ExportPreset {
     format: ExportFormat;
 }
 /** Provide predefined export configurations for various social media and image formats */
-declare const EXPORT_PRESETS: Record<string, ExportPreset>;
+export declare const EXPORT_PRESETS: Record<string, ExportPreset>;
 /** Define crop rectangle coordinates and dimensions for exporting content within page bounds */
-interface ExportCropRect {
+export interface ExportCropRect {
     /** Page-coordinate origin. Negative when bleed extends outside page bounds. */
     x: number;
     y: number;
@@ -68,7 +66,7 @@ interface ExportCropRect {
  * When `includeBleed` is true but `page.bleed` is null, the page rect is
  * returned unchanged — the caller must not assume symmetric expansion.
  */
-declare function bleedAwareExportBounds(page: ScenePage, includeBleed: boolean): ExportCropRect;
+export declare function bleedAwareExportBounds(page: ScenePage, includeBleed: boolean): ExportCropRect;
 /**
  * Pixel ratio for stage.toDataURL given a crop rect and an export preset.
  *
@@ -78,9 +76,9 @@ declare function bleedAwareExportBounds(page: ScenePage, includeBleed: boolean):
  *
  * The crop rect must already account for bleed inclusion before this call.
  */
-declare function scaleForPreset(preset: ExportPreset, cropRect: ExportCropRect): number;
+export declare function scaleForPreset(preset: ExportPreset, cropRect: ExportCropRect): number;
 /** Define a preset configuration for a channel including its id, label, width, and height */
-interface ChannelPreset {
+export interface ChannelPreset {
     id: string;
     label: string;
     width: number;
@@ -92,14 +90,14 @@ interface ChannelPreset {
  * CSS px — they describe the target delivery format, not the canvas layout.
  * The a4_print_2480x3508 preset corresponds to A4 at 300 dpi.
  */
-declare const CHANNEL_PRESETS: readonly ChannelPreset[];
+export declare const CHANNEL_PRESETS: readonly ChannelPreset[];
 /** Resolve a valid channel preset identifier from the predefined channel presets array */
-type ChannelPresetId = (typeof CHANNEL_PRESETS)[number]['id'];
+export type ChannelPresetId = (typeof CHANNEL_PRESETS)[number]['id'];
 /** Throws when the id is unknown — callers should only pass ids sourced from
  *  `CHANNEL_PRESETS`. */
-declare function requireChannelPreset(id: string): ChannelPreset;
+export declare function requireChannelPreset(id: string): ChannelPreset;
 /** Define the pixel ratio and horizontal offset for scaling a Konva stage to a channel preset size */
-interface ChannelScaleResult {
+export interface ChannelScaleResult {
     /**
      * Konva stage pixelRatio: the stage logical size stays at page dimensions;
      * the backing canvas renders at `pixelRatio × page` px. Setting Konva's
@@ -133,7 +131,7 @@ interface ChannelScaleResult {
  *   pixelRatio = 1.0, rendered page = 1080×1080 px
  *   offsetX = (1920 − 1080) / 2 / 1.0 = 420 page-px, offsetY = 0
  */
-declare function scalePageForChannelPreset(page: Pick<ScenePage, 'width' | 'height'>, channelPreset: ChannelPreset): ChannelScaleResult;
+export declare function scalePageForChannelPreset(page: Pick<ScenePage, 'width' | 'height'>, channelPreset: ChannelPreset): ChannelScaleResult;
 /**
  * Export rectangle in page coordinates that includes bleed margins when
  * present. When `page.bleed` is null, returns the trim rectangle (origin 0,0;
@@ -147,6 +145,4 @@ declare function scalePageForChannelPreset(page: Pick<ScenePage, 'width' | 'heig
  * Named `bleedAwareExportRect` to avoid collision with the two-arg
  * `bleedAwareExportBounds(page, includeBleed)` above.
  */
-declare function bleedAwareExportRect(page: Pick<ScenePage, 'width' | 'height' | 'bleed'>): Bounds;
-
-export { CHANNEL_PRESETS as C, EXPORT_PRESETS as E, SIZE_PRESETS as S, type ChannelPreset as a, type ChannelPresetId as b, type ChannelScaleResult as c, type ExportCropRect as d, type ExportFormat as e, type ExportPreset as f, type SizePreset as g, bleedAwareExportBounds as h, bleedAwareExportRect as i, findPreset as j, scalePageForChannelPreset as k, matchPreset as m, requireChannelPreset as r, scaleForPreset as s };
+export declare function bleedAwareExportRect(page: Pick<ScenePage, 'width' | 'height' | 'bleed'>): Bounds;

package/dist/design-canvas/index.d.ts

@@ -1,269 +1,23 @@
-import { c as SceneDocument, d as SceneElementKind, a as SceneElement, S as ScenePage } from '../model-DnfO_PdJ.js';
-export { B as Bounds, E as EllipseElement, G as GroupElement, I as ImageElement, L as LineElement, N as NewPageOptions, P as PageBleed, b as PageGuides, R as RectElement, e as SCENE_ELEMENT_KINDS, f as SCENE_SCHEMA_VERSION, g as SceneElementBase, h as SceneSettings, T as TextElement, V as VideoElement, i as assertColor, j as assertFinite, k as assertPositiveFinite, l as assertSceneMediaSrc, m as boundsIntersect, n as collectSlots, o as createEmptyDocument, p as createPage, q as elementAabb, r as elementExtent, s as estimateTextHeight, t as findElement, u as requireElement, v as requirePage } from '../model-DnfO_PdJ.js';
-import { S as SceneOperation, a as ScenePlan } from '../operations-ByJ6yXOW.js';
-export { A as AddElementOperation, b as AddPageOperation, c as ApplyDataOperation, B as BindSlotOperation, D as DeleteElementOperation, d as DeletePageOperation, e as DuplicatePageOperation, G as GroupElementsOperation, R as ReorderElementOperation, f as ReorderPageOperation, g as SCENE_OPERATION_TYPES, h as SceneAttrsPatch, i as SceneOperationType, j as SetAttrsOperation, k as SetDocumentTitleOperation, l as SetPageGuidesOperation, m as SetPagePropsOperation, U as UngroupElementOperation } from '../operations-ByJ6yXOW.js';
-import { a as SceneStore, N as NewSceneDecision, b as SceneDocumentRecord } from '../store-CqfDtnPQ.js';
-export { c as SceneDecision, d as SceneExportFormat, e as SceneExportRecord, S as SceneStoreScope } from '../store-CqfDtnPQ.js';
-export { C as CHANNEL_PRESETS, a as ChannelPreset, b as ChannelPresetId, c as ChannelScaleResult, E as EXPORT_PRESETS, d as ExportCropRect, e as ExportFormat, f as ExportPreset, S as SIZE_PRESETS, g as SizePreset, h as bleedAwareExportBounds, i as bleedAwareExportRect, j as findPreset, m as matchPreset, r as requireChannelPreset, s as scaleForPreset, k as scalePageForChannelPreset } from '../export-presets-mgVulRaV.js';
-import { a as McpToolDefinition } from '../mcp-rpc-DYwPlYbZ.js';
-import { S as ScopedMcpServerEntryOptions, A as AppToolMcpServer } from '../mcp-xxoZZfor.js';
-import '@tangle-network/agent-interface';
-import '../types-B25Mib1r.js';
-import '../auth-BYtiazA4.js';
-
 /**
- * Pre-write validation for scene operations. Every rule runs against a
- * `SceneDocument` snapshot BEFORE any mutation, so a rejected batch leaves no
- * partial state. Batch errors carry the shape `operation N (type): reason` —
- * precise enough for an LLM planner to repair the offending operation and
- * resubmit.
- *
- * Validation is static: a batch is checked against the document as given, so
- * an operation may not reference entities created by an earlier operation in
- * the same batch. Dispatchers that chain operations must refresh the document
- * between applications and validate per-operation.
- *
- * Slot typing contract (for apply_data bindings):
- *   text    elements  → value is any string
- *   image   elements  → value must pass assertSceneMediaSrc (src rewrite)
- *   video   elements  → value must pass assertSceneMediaSrc (src rewrite)
- *   rect    elements  → value must pass assertColor (fill recolor)
- *   ellipse elements  → value must pass assertColor (fill recolor)
- *   line    elements  → value must pass assertColor (stroke recolor)
- *   group   elements  → value must pass assertColor (fill/stroke passed down to children)
- */
-
-/** Validate each scene operation against the document and throw detailed errors for invalid operations */
-declare function validateSceneOperations(document: SceneDocument, operations: SceneOperation[]): void;
-/** Validate a scene operation against the document to ensure it meets required constraints */
-declare function validateSceneOperation(document: SceneDocument, operation: SceneOperation): void;
-/**
- * Validates that a slot binding value matches the slot element's kind.
- * text → any string; image/video → media src; rect/ellipse/line/group → color.
- */
-declare function validateSlotValue(slotName: string, elementKind: SceneElementKind, value: string): void;
-
-/**
- * Pure application of validated scene operations to a SceneDocument.
- * `applySceneOperations` deep-clones the document then mutates the clone,
- * returning the new document and per-op results. It never touches the store,
- * a clock, or a PRNG — all id generation goes through the caller-supplied
- * `mintId` option so callers control determinism (counter in tests,
- * crypto.randomUUID in production).
- *
- * Rotation semantics for group/ungroup:
- *   Group: children retain their absolute rotation. The group origin is the
- *   min-x, min-y corner of the AABB union of all member elements. Children
- *   are rebased so their position in group-local space equals
- *   (element.x - group.x, element.y - group.y). A rotated child appears at
- *   the same absolute page position after grouping because the group's additive
- *   translation preserves the child's own-origin transform.
- *   Ungroup: inverse — child.x += group.x, child.y += group.y; rotation stays.
- *   This is consistent with Konva's transform-about-own-origin model without
- *   needing a full matrix concatenation for the common case.
- *
- * `storeApplyScenePlan` layers store I/O on top: getDocument → validate →
- * apply → saveDocument(expectedRev) → recordDecision, retrying once on
- * stale-rev by refetch + revalidate + reapply.
- */
-
-/** Represent the result of applying changes to a scene as an element, page, or entire document */
-type SceneApplyResult = {
-    kind: 'element';
-    pageId: string;
-    element: SceneElement;
-} | {
-    kind: 'page';
-    page: ScenePage;
-} | {
-    kind: 'document';
-};
-/** Resolve element ID conflicts by providing fresh unique identifiers during scene application */
-interface ApplySceneOptions {
-    /**
-     * Provides fresh ids when duplicate_page re-mints element ids. Never called
-     * by any other operation. Counter-based in tests; crypto.randomUUID in
-     * production (wrapped so `mintId()` has no arguments, matching this signature).
-     */
-    mintId: () => string;
-}
-/** Full form: returns the new document AND per-op results. `mintId` must be
- *  provided when any operation in the list may be `duplicate_page` (which
- *  re-mints element ids); for all other operation types it is never called. */
-declare function applySceneOperations(document: SceneDocument, operations: SceneOperation[], options: ApplySceneOptions): {
-    document: SceneDocument;
-    results: SceneApplyResult[];
-};
-/** Convenience 2-arg form: returns the new document directly. Uses a
- *  monotonic counter as the mintId so `duplicate_page` never collides within
- *  a single call (suitable for editor-local optimistic state; server will
- *  re-mint on persist). */
-declare function applySceneOperations(document: SceneDocument, operations: SceneOperation[]): SceneDocument;
-/** Apply a single operation to a document and return the new document.
- *  Equivalent to `applySceneOperations(doc, [op])` but returns `SceneDocument`
- *  directly — the common case in editor commands and tests. */
-declare function applySceneOperation(document: SceneDocument, operation: SceneOperation): SceneDocument;
-/** Resolve and apply a scene plan to the store with specified actor context and generate results */
-declare function storeApplyScenePlan(store: SceneStore, plan: ScenePlan, opts: {
-    actorKind: NewSceneDecision['kind'];
-    mintId: () => string;
-}): Promise<{
-    record: SceneDocumentRecord;
-    results: SceneApplyResult[];
-}>;
-
-/**
- * Template helpers for design-canvas documents. A template is any document
- * whose elements carry `slot` names — those slots define the fillable surface
- * that data sources and agents target. The helpers here are pure (no store,
- * no Konva) so they run server-side, in MCP tools, or in tests without a DOM.
- *
- * Binding semantics (shared with `apply_data` operation):
- *   - text elements: binding value replaces `element.text`
- *   - image/video elements: binding value replaces `element.src`
- *   - rect/ellipse elements with a slot: binding value replaces `element.fill`
- *     (color-slot convention — background swatch templates)
- *   - line/group slots are reserved; binding them throws a loud error
- * Unknown binding keys (no matching slot) throw — callers must preflight with
- * `validateBindings` or accept that the throw is the signal to fix their data.
- */
-
-/** Define allowed string literals representing different slot fill kinds */
-type SlotFillKind = 'text' | 'src' | 'color';
-/** Define a slot template specifying its name, page, element, and fill characteristics */
-interface TemplateSlot {
-    name: string;
-    pageId: string;
-    elementId: string;
-    elementKind: SceneElementKind;
-    fillKind: SlotFillKind;
-}
-/**
- * Wraps `collectSlots` with kind-aware fill typing so callers know WHAT to
- * put in each slot without inspecting the element tree themselves.
- * Throws when duplicate slot names exist (propagated from collectSlots).
- */
-declare function listTemplateSlots(document: SceneDocument): TemplateSlot[];
-/**
- * Preflight check: every key in `bindings` must name a slot in the document.
- * Returns a list of problems; an empty array means the bindings are clean.
- * Does NOT throw — designed to run before `instantiateTemplate` so callers
- * can surface a structured error instead of catching.
- */
-declare function validateBindings(document: SceneDocument, bindings: Record<string, string>): string[];
-/** Define options for instantiating a document with title, optional bindings, and custom id minting */
-interface InstantiateOptions {
-    /** Human-readable title for the new document. */
-    title: string;
-    /** Slot bindings to apply after id re-minting. Partial application allowed. */
-    bindings?: Record<string, string>;
-    /**
-     * Caller-supplied id factory — every page/element id in the source document
-     * is replaced with a fresh value from this callback. The callback receives
-     * the source id so implementations can build stable deterministic ids (e.g.
-     * `crypto.randomUUID()` or `nanoid()` from the host).
-     */
-    mintId(sourceId: string): string;
-}
-/**
- * Produces a new `SceneDocument` from a template:
- * 1. Re-mints every page and element id via `options.mintId` (slot *names* are
- *    preserved so apply_data still targets them by name).
- * 2. Applies `options.bindings` with the same semantics as `apply_data`.
- * 3. Stamps `metadata.templateSourceId` with the source document's title so
- *    the lineage is traceable without storing separate template provenance rows.
- *
- * Throws when bindings reference unknown slots (validated via `validateBindings`
- * before mutation so no partial state is possible).
- */
-declare function instantiateTemplate(document: SceneDocument, options: InstantiateOptions): SceneDocument;
-/**
- * Applies slot bindings to a document in place (mutates a deep copy produced
- * by the caller). Unknown slot names throw — the preflight in `instantiateTemplate`
- * guarantees this is unreachable there; exported so the `apply_data` operation
- * handler can reuse it without duplicating the switch.
- */
-declare function applyBindingsToDocument(document: SceneDocument, bindings: Record<string, string>): SceneDocument;
-
-/**
- * Design-canvas MCP tool registry — what the in-sandbox agent sees over the
- * live agent→canvas channel. Each entry carries an LLM-facing description, a
- * JSON Schema for the arguments, and the typed dispatch that validates the
- * resulting operations, applies them through the store, and records ONE
- * decision row per mutating call.
- *
- * Every mutation: validate → apply via storeApplyScenePlan → recordDecision.
- * Throws anywhere become isError results the model reads to correct its call.
- *
- * Convenience sugar tools (add_text, move_element, etc.) expand to the
- * underlying operation primitives before reaching the kernel — no separate
- * code path to drift.
- */
-
-/** Define the environment for MCP tool with a scene store and ID minting function */
-interface DesignCanvasMcpToolEnv {
-    store: SceneStore;
-    mintId: () => string;
-}
-/** Provide a collection of MCP tool definitions for manipulating and querying the design canvas environment */
-declare const CANVAS_MCP_TOOLS: McpToolDefinition<DesignCanvasMcpToolEnv>[];
-
-/** Find the canvas MCP tool definition matching the given name or return undefined */
-declare function findCanvasMcpTool(name: string): McpToolDefinition<DesignCanvasMcpToolEnv> | undefined;
-/** Extract names of all tools from the CANVAS_MCP_TOOLS array */
-declare const CANVAS_MCP_TOOL_NAMES: string[];
-/** Provide a readonly array of string identifiers representing canvas element kinds */
-declare const CANVAS_ELEMENT_KINDS: readonly string[];
-
-/**
- * Streamable-HTTP MCP server for one design-canvas document — the live
- * agent→canvas channel. JSON-RPC 2.0 over POST, stateless per request
- * (Workers-compatible: no session table, no SSE).
- *
- * Trust boundary: the product authenticates the request (capability token,
- * workspace RBAC) BEFORE constructing the scoped {@link SceneStore} and
- * calling this handler — the handler trusts its store completely. Tool
- * execution failures (argument shape, validation, stale rev) become `isError`
- * tool results carrying the thrown message verbatim so the model can read WHY
- * and retry.
- *
- * The JSON-RPC envelope (initialize/ping/tools/list/tools/call, -32601) lives
- * in {@link createMcpToolHandler}; this module wires the canvas tool list +
- * the caller-supplied id-minting function.
- */
-
-/** Describe design canvas MCP server information including name and version */
-interface DesignCanvasMcpServerInfo {
-    name: string;
-    version: string;
-}
-/** Define options for creating a design canvas MCP handler including store, ID minting, and optional server info */
-interface CreateDesignCanvasMcpHandlerOptions {
-    /** Already scoped + authorized for one (workspace, document, actor). */
-    store: SceneStore;
-    /** Id-minting function threaded into every mutating tool. Must return
-     *  a string unique within the document scope — use crypto.randomUUID()
-     *  in production; a deterministic counter in tests. */
-    mintId: () => string;
-    serverInfo?: DesignCanvasMcpServerInfo;
-}
-/** Create a request handler for the design canvas MCP tool with specified options */
-declare function createDesignCanvasMcpHandler(opts: CreateDesignCanvasMcpHandlerOptions): (request: Request) => Promise<Response>;
-
-/**
- * Profile entry for the design-canvas MCP server — what a product spreads
- * into its sandbox `AgentProfile.mcp` map so the in-sandbox agent gets the
- * live canvas channel. A thin wrapper over the shared `buildScopedMcpServerEntry`
- * mechanism (../tools/mcp): transport 'http', capability token in the
- * Authorization header (server-set, never a tool argument). The only
- * domain-specific values are this channel's default description and name.
- */
-
-/** Describe the live visual asset editor capabilities for the current design document using CSS pixel coordinates */
-declare const DEFAULT_DESIGN_CANVAS_MCP_DESCRIPTION = "Live visual asset editor for the current design document: read scene state, add/move/resize/delete elements, manage pages, bind template slots, apply data, and queue exports. All coordinates are CSS pixels.";
-/** Build scoped MCP server entry options for the design canvas environment */
-type BuildDesignCanvasMcpServerEntryOptions = ScopedMcpServerEntryOptions;
-/** Build the `AgentProfileMcpServer`-shaped entry for the design-canvas channel. */
-declare function buildDesignCanvasMcpServerEntry(opts: BuildDesignCanvasMcpServerEntryOptions): AppToolMcpServer;
-
-export { type ApplySceneOptions, type BuildDesignCanvasMcpServerEntryOptions, CANVAS_ELEMENT_KINDS, CANVAS_MCP_TOOLS, CANVAS_MCP_TOOL_NAMES, type CreateDesignCanvasMcpHandlerOptions, DEFAULT_DESIGN_CANVAS_MCP_DESCRIPTION, type DesignCanvasMcpServerInfo, type DesignCanvasMcpToolEnv, type InstantiateOptions, NewSceneDecision, type SceneApplyResult, SceneDocument, SceneDocumentRecord, SceneElement, SceneElementKind, SceneOperation, ScenePage, ScenePlan, SceneStore, type SlotFillKind, type TemplateSlot, applyBindingsToDocument, applySceneOperation, applySceneOperations, buildDesignCanvasMcpServerEntry, createDesignCanvasMcpHandler, findCanvasMcpTool, instantiateTemplate, listTemplateSlots, storeApplyScenePlan, validateBindings, validateSceneOperation, validateSceneOperations, validateSlotValue };
+ * Design-canvas module: scene document model, the closed operation union,
+ * the store contract, validate/apply kernel, template helpers, export presets,
+ * and the MCP tool surface + handler/entry factories.
+ *
+ * Drizzle-backed persistence (schema factory + store implementation) lives in
+ * './drizzle' (`@tangle-network/agent-app/design-canvas/drizzle`) because it
+ * imports `drizzle-orm` at module top — this barrel stays importable for
+ * consumers without that optional peer installed.
+ *
+ * Konva and React are NOT imported here — all Konva-dependent code lives in
+ * `@tangle-network/agent-app/design-canvas-react`.
+ */
+export * from './model';
+export * from './operations';
+export * from './store';
+export * from './validate';
+export * from './apply';
+export * from './templates';
+export * from './export-presets';
+export * from './mcp-tools';
+export * from './mcp-handler';
+export * from './mcp-entry';

package/dist/design-canvas/mcp-entry.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Profile entry for the design-canvas MCP server — what a product spreads
+ * into its sandbox `AgentProfile.mcp` map so the in-sandbox agent gets the
+ * live canvas channel. A thin wrapper over the shared `buildScopedMcpServerEntry`
+ * mechanism (../tools/mcp): transport 'http', capability token in the
+ * Authorization header (server-set, never a tool argument). The only
+ * domain-specific values are this channel's default description and name.
+ */
+import type { AppToolMcpServer, ScopedMcpServerEntryOptions } from '../tools/mcp';
+/** Describe the live visual asset editor capabilities for the current design document using CSS pixel coordinates */
+export declare const DEFAULT_DESIGN_CANVAS_MCP_DESCRIPTION = "Live visual asset editor for the current design document: read scene state, add/move/resize/delete elements, manage pages, bind template slots, apply data, and queue exports. All coordinates are CSS pixels.";
+/** Build scoped MCP server entry options for the design canvas environment */
+export type BuildDesignCanvasMcpServerEntryOptions = ScopedMcpServerEntryOptions;
+/** Build the `AgentProfileMcpServer`-shaped entry for the design-canvas channel. */
+export declare function buildDesignCanvasMcpServerEntry(opts: BuildDesignCanvasMcpServerEntryOptions): AppToolMcpServer;

package/dist/design-canvas/mcp-handler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Streamable-HTTP MCP server for one design-canvas document — the live
+ * agent→canvas channel. JSON-RPC 2.0 over POST, stateless per request
+ * (Workers-compatible: no session table, no SSE).
+ *
+ * Trust boundary: the product authenticates the request (capability token,
+ * workspace RBAC) BEFORE constructing the scoped {@link SceneStore} and
+ * calling this handler — the handler trusts its store completely. Tool
+ * execution failures (argument shape, validation, stale rev) become `isError`
+ * tool results carrying the thrown message verbatim so the model can read WHY
+ * and retry.
+ *
+ * The JSON-RPC envelope (initialize/ping/tools/list/tools/call, -32601) lives
+ * in {@link createMcpToolHandler}; this module wires the canvas tool list +
+ * the caller-supplied id-minting function.
+ */
+import type { SceneStore } from './store';
+/** Describe design canvas MCP server information including name and version */
+export interface DesignCanvasMcpServerInfo {
+    name: string;
+    version: string;
+}
+/** Define options for creating a design canvas MCP handler including store, ID minting, and optional server info */
+export interface CreateDesignCanvasMcpHandlerOptions {
+    /** Already scoped + authorized for one (workspace, document, actor). */
+    store: SceneStore;
+    /** Id-minting function threaded into every mutating tool. Must return
+     *  a string unique within the document scope — use crypto.randomUUID()
+     *  in production; a deterministic counter in tests. */
+    mintId: () => string;
+    serverInfo?: DesignCanvasMcpServerInfo;
+}
+/** Create a request handler for the design canvas MCP tool with specified options */
+export declare function createDesignCanvasMcpHandler(opts: CreateDesignCanvasMcpHandlerOptions): (request: Request) => Promise<Response>;

package/dist/design-canvas/mcp-tools.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Design-canvas MCP tool registry — what the in-sandbox agent sees over the
+ * live agent→canvas channel. Each entry carries an LLM-facing description, a
+ * JSON Schema for the arguments, and the typed dispatch that validates the
+ * resulting operations, applies them through the store, and records ONE
+ * decision row per mutating call.
+ *
+ * Every mutation: validate → apply via storeApplyScenePlan → recordDecision.
+ * Throws anywhere become isError results the model reads to correct its call.
+ *
+ * Convenience sugar tools (add_text, move_element, etc.) expand to the
+ * underlying operation primitives before reaching the kernel — no separate
+ * code path to drift.
+ */
+import type { SceneStore } from './store';
+import type { McpToolDefinition } from '../tools/mcp-rpc';
+/** Define the environment for MCP tool with a scene store and ID minting function */
+export interface DesignCanvasMcpToolEnv {
+    store: SceneStore;
+    mintId: () => string;
+}
+/** Provide a collection of MCP tool definitions for manipulating and querying the design canvas environment */
+declare const CANVAS_MCP_TOOLS: McpToolDefinition<DesignCanvasMcpToolEnv>[];
+export { CANVAS_MCP_TOOLS };
+/** Find the canvas MCP tool definition matching the given name or return undefined */
+export declare function findCanvasMcpTool(name: string): McpToolDefinition<DesignCanvasMcpToolEnv> | undefined;
+/** Extract names of all tools from the CANVAS_MCP_TOOLS array */
+export declare const CANVAS_MCP_TOOL_NAMES: string[];
+/** Provide a readonly array of string identifiers representing canvas element kinds */
+export declare const CANVAS_ELEMENT_KINDS: readonly string[];