@pixerate/editor 0.44.0 → 0.46.0

package/dist/chunk-HHQ4XJWT.js

@@ -0,0 +1,826 @@
+import {
+  validateJsonSchema
+} from "./chunk-PQM5W7ZN.js";
+
+// src/tools/registry.ts
+var ToolRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ToolRegistryError";
+    this.code = code;
+  }
+};
+var TOOL_NAMESPACE_SEPARATOR = "__";
+var TOOL_NAME_REGEX = /^[A-Za-z0-9_.-]{1,128}$/;
+var sanitizeNamespace = (id) => id.replace(/[^A-Za-z0-9_-]/g, "_");
+function readTools(provider) {
+  return typeof provider.tools === "function" ? provider.tools() : provider.tools;
+}
+function toDefinition(name, tool) {
+  const { handler: _handler, name: _name, ...rest } = tool;
+  return { name, ...rest };
+}
+function errorResult(error) {
+  const details = error.details?.length ? "\n" + error.details.map((d) => `- ${d.path}: ${d.message}`).join("\n") : "";
+  return {
+    isError: true,
+    content: [{ type: "text", text: `${error.message}${details}` }],
+    structuredContent: { error }
+  };
+}
+function toToolResult(value) {
+  if (value && typeof value === "object" && Array.isArray(value.content)) {
+    return value;
+  }
+  if (value === void 0) return { content: [] };
+  if (typeof value === "string") return { content: [{ type: "text", text: value }] };
+  const text = JSON.stringify(value);
+  const isPlainObject = typeof value === "object" && value !== null && !Array.isArray(value);
+  return {
+    content: [{ type: "text", text: text ?? String(value) }],
+    ...isPlainObject ? { structuredContent: value } : {}
+  };
+}
+var ToolRegistry = class {
+  /** MCP server capabilities this registry supports. */
+  capabilities = { tools: { listChanged: true } };
+  entries = [];
+  listeners = /* @__PURE__ */ new Set();
+  options;
+  timer = null;
+  lastSignature;
+  constructor(options = {}) {
+    this.options = {
+      onCollision: options.onCollision ?? "namespace",
+      listChangedDelayMs: options.listChangedDelayMs ?? 0,
+      validateArguments: options.validateArguments ?? true
+    };
+    this.lastSignature = this.signature();
+  }
+  /**
+   * Registers a provider and returns a function that unregisters it.
+   * Throws a {@link ToolRegistryError} for a duplicate provider id, an invalid
+   * tool name, or (with `onCollision: 'error'`) a tool name collision.
+   */
+  register(provider) {
+    if (this.entries.some((e) => e.provider.id === provider.id)) {
+      throw new ToolRegistryError("duplicate_provider", `Tool provider "${provider.id}" is already registered.`);
+    }
+    for (const tool of readTools(provider)) {
+      if (!TOOL_NAME_REGEX.test(tool.name)) {
+        throw new ToolRegistryError("invalid_tool", `Invalid tool name "${tool.name}" from provider "${provider.id}".`);
+      }
+    }
+    const entry = { provider };
+    this.entries.push(entry);
+    try {
+      const names = this.resolve(this.options.onCollision === "error").map((t) => t.name);
+      const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+      if (duplicate) {
+        throw new ToolRegistryError("name_collision", `Tool name "${duplicate}" is exposed more than once.`);
+      }
+    } catch (error) {
+      this.entries.pop();
+      throw error;
+    }
+    if (provider.subscribe) {
+      entry.unsubscribe = provider.subscribe(() => this.notifyListChanged());
+    }
+    this.notifyListChanged();
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      this.unregister(provider);
+    };
+  }
+  /** Removes a provider by id or instance. Returns whether it was registered. */
+  unregister(providerOrId) {
+    const index = this.entries.findIndex(
+      (e) => typeof providerOrId === "string" ? e.provider.id === providerOrId : e.provider === providerOrId
+    );
+    if (index === -1) return false;
+    const [entry] = this.entries.splice(index, 1);
+    entry.unsubscribe?.();
+    this.notifyListChanged();
+    return true;
+  }
+  /** Registered provider ids in registration order. */
+  providerIds() {
+    return this.entries.map((e) => e.provider.id);
+  }
+  /**
+   * Resolves exposed names. Tools are ordered by provider registration, then
+   * by their order within the provider.
+   */
+  resolve(throwOnCollision = false) {
+    const all = [];
+    const counts = /* @__PURE__ */ new Map();
+    for (const { provider } of this.entries) {
+      for (const tool of readTools(provider)) {
+        all.push({ name: tool.name, tool, provider });
+        if (!provider.namespace) counts.set(tool.name, (counts.get(tool.name) ?? 0) + 1);
+      }
+    }
+    for (const item of all) {
+      const prefix = item.provider.namespace ?? ((counts.get(item.name) ?? 0) > 1 ? item.provider.id : void 0);
+      if (prefix !== void 0) {
+        if (throwOnCollision && !item.provider.namespace) {
+          throw new ToolRegistryError(
+            "name_collision",
+            `Tool "${item.name}" from provider "${item.provider.id}" collides with another provider's tool.`
+          );
+        }
+        item.name = `${sanitizeNamespace(prefix)}${TOOL_NAMESPACE_SEPARATOR}${item.name}`;
+      }
+    }
+    return all;
+  }
+  /** MCP `tools/list` result for the current providers. */
+  listTools() {
+    return { tools: this.resolve().map(({ name, tool }) => toDefinition(name, tool)) };
+  }
+  /** Whether a tool with this exposed name exists. */
+  hasTool(name) {
+    return this.resolve().some((t) => t.name === name);
+  }
+  /** Looks up a tool definition by exposed name. */
+  getTool(name) {
+    const found = this.resolve().find((t) => t.name === name);
+    return found ? toDefinition(found.name, found.tool) : void 0;
+  }
+  /**
+   * Calls a tool by exposed name and returns an MCP `tools/call` result.
+   * Never rejects: unknown tools, invalid arguments and handler errors come
+   * back as `isError: true` results with a {@link ToolCallError} in
+   * `structuredContent.error` (MCP transports may map `unknown_tool` to a
+   * JSON-RPC `-32602` error instead).
+   */
+  async callTool(name, args = {}, options = {}) {
+    const found = this.resolve().find((t) => t.name === name);
+    if (!found) {
+      return errorResult({ code: "unknown_tool", message: `Unknown tool "${name}".`, tool: name });
+    }
+    const input = args ?? {};
+    if (this.options.validateArguments) {
+      const details = validateJsonSchema(input, found.tool.inputSchema);
+      if (details.length > 0) {
+        return errorResult({
+          code: "invalid_arguments",
+          message: `Invalid arguments for tool "${name}".`,
+          tool: name,
+          details
+        });
+      }
+    }
+    try {
+      const value = await found.tool.handler(input, {
+        name,
+        providerId: found.provider.id,
+        signal: options.signal
+      });
+      return toToolResult(value);
+    } catch (error) {
+      return errorResult({
+        code: "tool_failed",
+        message: error instanceof Error ? error.message : String(error),
+        tool: name
+      });
+    }
+  }
+  /**
+   * Subscribes to tool-list changes. Notifications are coalesced: many
+   * registrations or provider signals within the delay window produce one
+   * call, and none if the exposed list ends up unchanged (e.g. a provider
+   * unmounted and remounted). Returns an unsubscribe function.
+   */
+  onListChanged(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Schedules a coalesced `listChanged` check; providers may call it directly. */
+  notifyListChanged() {
+    if (this.timer !== null) return;
+    this.timer = setTimeout(() => this.flush(), this.options.listChangedDelayMs);
+  }
+  /** Runs a pending `listChanged` check immediately. */
+  flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const signature = this.signature();
+    if (signature === this.lastSignature) return;
+    this.lastSignature = signature;
+    const { tools } = this.listTools();
+    for (const listener of Array.from(this.listeners)) listener(tools);
+  }
+  signature() {
+    try {
+      return JSON.stringify(this.listTools().tools);
+    } catch {
+      return String(Math.random());
+    }
+  }
+  /** Unregisters every provider and listener and cancels pending notifications. */
+  dispose() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    for (const entry of this.entries.splice(0)) entry.unsubscribe?.();
+    this.listeners.clear();
+  }
+};
+function createToolRegistry(options) {
+  return new ToolRegistry(options);
+}
+
+// src/tools/definitions.ts
+var MCP_TOOL_GET_EDITOR_STATE = {
+  name: "get_editor_state",
+  title: "Get editor state",
+  annotations: {
+    title: "Get editor state",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  description: "Retrieves the current state of the document, variables, selection, and canvas graph (nodes and edges).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      includeDocument: {
+        type: "boolean",
+        description: "Whether to include the prompt document text and variables (default: true)."
+      },
+      includeCanvas: {
+        type: "boolean",
+        description: "Whether to include the canvas nodes and edges (default: true)."
+      }
+    }
+  }
+};
+var MCP_TOOL_EDIT_CANVAS = {
+  name: "edit_canvas",
+  title: "Edit the canvas",
+  annotations: {
+    title: "Edit the canvas",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  description: "Applies high-level structural operations to the visual canvas (adding nodes, connecting edges, organizing layout, or moving elements). Prefer the per-operation canvas_* tools when the host exposes them. Returns the ids of created nodes and edges.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: [
+          "add_node",
+          "remove_nodes",
+          "connect",
+          "update_node",
+          "layout",
+          "select",
+          "highlight"
+        ],
+        description: "The canvas operation to execute."
+      },
+      node: {
+        type: "object",
+        description: "Node definition when operation is add_node. Can omit position to auto-place."
+      },
+      nearNodeId: {
+        type: "string",
+        description: "Anchor node ID to position beside using collision-aware placement."
+      },
+      side: {
+        type: "string",
+        enum: ["top", "right", "bottom", "left"],
+        description: "Side of the anchor node to place the new node beside."
+      },
+      nodeIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of node IDs for remove_nodes, select, or highlight."
+      },
+      id: {
+        type: "string",
+        description: "Node ID for update_node (or pass `node: { id, data }`)."
+      },
+      data: {
+        type: "object",
+        description: "Data fields to merge into the node for update_node."
+      },
+      color: {
+        type: "string",
+        description: "CSS color for highlight (default #3b82f6)."
+      },
+      durationMs: {
+        type: "integer",
+        minimum: 0,
+        description: "How long the highlight lasts in ms (default 2000)."
+      },
+      source: {
+        type: "string",
+        description: "Source node ID for connect operation."
+      },
+      target: {
+        type: "string",
+        description: "Target node ID for connect operation."
+      },
+      label: {
+        type: "string",
+        description: "Optional edge label for connect operation."
+      },
+      direction: {
+        type: "string",
+        enum: ["LR", "TB", "RL", "BT"],
+        description: "Layout direction (default LR)."
+      },
+      incremental: {
+        type: "boolean",
+        description: "Preserve existing node coordinates and blend layout (default true)."
+      }
+    },
+    required: ["operation"]
+  }
+};
+var MCP_TOOL_EDIT_PROMPT = {
+  name: "edit_prompt",
+  title: "Edit the prompt",
+  annotations: {
+    title: "Edit the prompt",
+    readOnlyHint: false,
+    destructiveHint: true,
+    idempotentHint: false,
+    openWorldHint: false
+  },
+  description: "Applies edits to the prompt template document, including inserting text, replacing ranges, and setting variables.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["insert_text", "replace_range", "set_variable", "select"],
+        description: "The prompt operation to execute."
+      },
+      text: {
+        type: "string",
+        description: "Text to insert or replace."
+      },
+      at: {
+        type: "integer",
+        minimum: 0,
+        description: "Position to insert text at."
+      },
+      from: {
+        type: "integer",
+        minimum: 0,
+        description: "Start offset for replace_range or select."
+      },
+      to: {
+        type: "integer",
+        minimum: 0,
+        description: "End offset for replace_range or select."
+      },
+      name: {
+        type: "string",
+        description: "Variable name for set_variable."
+      },
+      value: {
+        description: "Variable value for set_variable."
+      }
+    },
+    required: ["operation"]
+  }
+};
+var MCP_TOOL_VIEW_EDITOR = {
+  name: "view_editor",
+  title: "View the editor",
+  annotations: {
+    title: "View the editor",
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  description: "Captures a visual image snapshot (JPEG or PNG) of the editor canvas or viewport for multimodal evaluation. Active agent cursor indicators are automatically excluded from the snapshot.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      scope: {
+        type: "string",
+        enum: ["viewport", "canvas"],
+        description: "Whether to capture only the visible viewport or the full canvas bounding box (default: viewport)."
+      },
+      format: {
+        type: "string",
+        enum: ["jpeg", "png"],
+        description: "Image format of the base64 snapshot (default: jpeg)."
+      },
+      maxEdge: {
+        type: "integer",
+        description: "Maximum width or height dimension in pixels (default: 1024)."
+      }
+    }
+  }
+};
+var WRITE_ANNOTATIONS = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var DESTRUCTIVE_ANNOTATIONS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var IDEMPOTENT_ANNOTATIONS = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var NODE_IDS = {
+  type: "array",
+  items: { type: "string", minLength: 1 },
+  minItems: 1,
+  uniqueItems: true,
+  description: "Node ids (from get_editor_state)."
+};
+var POSITION = {
+  type: "object",
+  properties: { x: { type: "number" }, y: { type: "number" } },
+  required: ["x", "y"],
+  additionalProperties: false
+};
+var DOC_POSITION = { type: "integer", minimum: 0 };
+var MCP_TOOL_CANVAS_ADD_NODE = {
+  name: "canvas_add_node",
+  title: "Add a canvas node",
+  annotations: { title: "Add a canvas node", ...WRITE_ANNOTATIONS },
+  description: "Adds a node to the canvas. Without `position` it is placed without overlaps beside `nearNodeId` (and connected from it) or beside the last node. Returns the new node id (generated unless you pass `node.id`) and the id of the connecting edge.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node: {
+        type: "object",
+        description: "The node. Extra host-specific fields are kept.",
+        properties: {
+          id: { type: "string", minLength: 1, description: "Node id (default: generated). Must be unused." },
+          type: { type: "string", description: "Node type registered by the host." },
+          data: { type: "object", description: 'Node data (e.g. { "label": "..." }).' },
+          position: { ...POSITION, description: "Canvas coordinates (default: auto-placed)." },
+          width: { type: "number", exclusiveMinimum: 0 },
+          height: { type: "number", exclusiveMinimum: 0 },
+          parentId: { type: "string", description: "Parent (group/frame) node id." }
+        }
+      },
+      nearNodeId: { type: "string", description: "Existing node to place the new node beside and connect from." },
+      side: {
+        type: "string",
+        enum: ["top", "right", "bottom", "left"],
+        description: "Side of `nearNodeId` to place the node on (default right)."
+      }
+    },
+    required: ["node"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_REMOVE_NODES = {
+  name: "canvas_remove_nodes",
+  title: "Remove canvas nodes",
+  annotations: { title: "Remove canvas nodes", ...DESTRUCTIVE_ANNOTATIONS },
+  description: "Removes nodes (and their edges) from the canvas. Every id must exist.",
+  inputSchema: {
+    type: "object",
+    properties: { nodeIds: NODE_IDS },
+    required: ["nodeIds"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_CONNECT = {
+  name: "canvas_connect",
+  title: "Connect canvas nodes",
+  annotations: { title: "Connect canvas nodes", ...WRITE_ANNOTATIONS },
+  description: "Adds an edge from one existing node to another. Returns the new edge id.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      source: { type: "string", minLength: 1, description: "Source node id." },
+      target: { type: "string", minLength: 1, description: "Target node id." },
+      label: { type: "string", description: "Edge label." }
+    },
+    required: ["source", "target"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_UPDATE_NODE = {
+  name: "canvas_update_node",
+  title: "Update a canvas node",
+  annotations: { title: "Update a canvas node", ...DESTRUCTIVE_ANNOTATIONS, idempotentHint: true },
+  description: "Merges fields into an existing node's data.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      id: { type: "string", minLength: 1, description: "Node id." },
+      data: { type: "object", description: 'Data fields to merge (e.g. { "label": "New" }).' }
+    },
+    required: ["id", "data"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_LAYOUT = {
+  name: "canvas_layout",
+  title: "Lay out the canvas",
+  annotations: { title: "Lay out the canvas", ...IDEMPOTENT_ANNOTATIONS },
+  description: "Arranges the canvas graph automatically.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      direction: { type: "string", enum: ["LR", "TB", "RL", "BT"], description: "Layout direction (default LR)." },
+      incremental: {
+        type: "boolean",
+        description: "Keep nodes that already have a position where they are (default true)."
+      }
+    },
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_SELECT = {
+  name: "canvas_select",
+  title: "Select canvas nodes",
+  annotations: { title: "Select canvas nodes", ...IDEMPOTENT_ANNOTATIONS },
+  description: "Replaces the canvas selection with these nodes (an empty list clears it).",
+  inputSchema: {
+    type: "object",
+    properties: { nodeIds: { ...NODE_IDS, minItems: 0 } },
+    required: ["nodeIds"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_CANVAS_HIGHLIGHT = {
+  name: "canvas_highlight",
+  title: "Highlight canvas nodes",
+  annotations: { title: "Highlight canvas nodes", ...IDEMPOTENT_ANNOTATIONS },
+  description: "Briefly highlights nodes to draw the user's attention to them.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      nodeIds: NODE_IDS,
+      color: { type: "string", description: "CSS color (default #3b82f6)." },
+      durationMs: { type: "integer", minimum: 0, maximum: 6e4, description: "Duration in ms (default 2000)." }
+    },
+    required: ["nodeIds"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_PROMPT_INSERT_TEXT = {
+  name: "prompt_insert_text",
+  title: "Insert prompt text",
+  annotations: { title: "Insert prompt text", ...WRITE_ANNOTATIONS },
+  description: "Inserts text into the prompt at a position, or at the cursor when `at` is omitted.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: { type: "string", description: "Text to insert." },
+      at: { ...DOC_POSITION, description: "Position (as in get_editor_state `document.selection`)." }
+    },
+    required: ["text"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_PROMPT_REPLACE_RANGE = {
+  name: "prompt_replace_range",
+  title: "Replace prompt text",
+  annotations: { title: "Replace prompt text", ...DESTRUCTIVE_ANNOTATIONS },
+  description: "Replaces the prompt text between two positions (an empty text deletes it).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      from: { ...DOC_POSITION, description: "Start position." },
+      to: { ...DOC_POSITION, description: "End position (>= from)." },
+      text: { type: "string", description: "Replacement text." }
+    },
+    required: ["from", "to", "text"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_PROMPT_SET_VARIABLE = {
+  name: "prompt_set_variable",
+  title: "Set a prompt variable",
+  annotations: { title: "Set a prompt variable", ...DESTRUCTIVE_ANNOTATIONS, idempotentHint: true },
+  description: "Sets the value of a template variable used by the prompt.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", minLength: 1, description: "Variable name." },
+      value: { description: "Variable value (any JSON value)." }
+    },
+    required: ["name", "value"],
+    additionalProperties: false
+  }
+};
+var MCP_TOOL_PROMPT_SELECT = {
+  name: "prompt_select",
+  title: "Select prompt text",
+  annotations: { title: "Select prompt text", ...IDEMPOTENT_ANNOTATIONS },
+  description: "Selects the prompt text between two positions (from === to places the cursor).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      from: { ...DOC_POSITION, description: "Start position." },
+      to: { ...DOC_POSITION, description: "End position (>= from)." }
+    },
+    required: ["from", "to"],
+    additionalProperties: false
+  }
+};
+var EDITOR_CANVAS_TOOLS = [
+  MCP_TOOL_CANVAS_ADD_NODE,
+  MCP_TOOL_CANVAS_REMOVE_NODES,
+  MCP_TOOL_CANVAS_CONNECT,
+  MCP_TOOL_CANVAS_UPDATE_NODE,
+  MCP_TOOL_CANVAS_LAYOUT,
+  MCP_TOOL_CANVAS_SELECT,
+  MCP_TOOL_CANVAS_HIGHLIGHT
+];
+var EDITOR_PROMPT_TOOLS = [
+  MCP_TOOL_PROMPT_INSERT_TEXT,
+  MCP_TOOL_PROMPT_REPLACE_RANGE,
+  MCP_TOOL_PROMPT_SET_VARIABLE,
+  MCP_TOOL_PROMPT_SELECT
+];
+var EDIT_OPERATION_REQUIRED_ARGUMENTS = {
+  edit_canvas: {
+    add_node: ["node"],
+    remove_nodes: ["nodeIds"],
+    connect: ["source", "target"],
+    update_node: ["id"],
+    layout: [],
+    select: ["nodeIds"],
+    highlight: ["nodeIds"]
+  },
+  edit_prompt: {
+    insert_text: ["text"],
+    replace_range: ["from", "to", "text"],
+    set_variable: ["name"],
+    select: ["from", "to"]
+  }
+};
+var EXPORT_EXCLUDED_SELECTORS = [
+  ".pixerate-presence",
+  ".agent-presence",
+  ".ursula-presence"
+];
+var EDITOR_MCP_TOOLS = [
+  MCP_TOOL_GET_EDITOR_STATE,
+  MCP_TOOL_EDIT_CANVAS,
+  MCP_TOOL_EDIT_PROMPT,
+  MCP_TOOL_VIEW_EDITOR
+];
+
+// src/tools/mcp-server.ts
+var MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+var JSON_RPC_ERRORS = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603
+};
+var errorResponse = (id, code, message, data) => ({
+  jsonrpc: "2.0",
+  id,
+  error: { code, message, ...data !== void 0 ? { data } : {} }
+});
+function createMcpServer(registry, options) {
+  let initialized = false;
+  let unsubscribe = null;
+  const running = /* @__PURE__ */ new Map();
+  const startNotifications = () => {
+    if (unsubscribe || !options.send) return;
+    const send = options.send;
+    unsubscribe = registry.onListChanged(() => send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }));
+  };
+  async function dispatch(request) {
+    const id = request.id ?? null;
+    const isNotification = request.id === void 0 || request.id === null;
+    const params = request.params ?? {};
+    switch (request.method) {
+      case "initialize": {
+        const requested = String(params.protocolVersion ?? "");
+        const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_PROTOCOL_VERSIONS[0];
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion,
+            capabilities: registry.capabilities,
+            serverInfo: { name: options.name, version: options.version, ...options.title ? { title: options.title } : {} },
+            ...options.instructions ? { instructions: options.instructions } : {}
+          }
+        };
+      }
+      case "notifications/initialized":
+        initialized = true;
+        startNotifications();
+        return null;
+      case "notifications/cancelled": {
+        const requestId = params.requestId;
+        if (requestId !== void 0) running.get(requestId)?.abort(params.reason);
+        return null;
+      }
+      case "ping":
+        return { jsonrpc: "2.0", id, result: {} };
+      case "tools/list":
+        return { jsonrpc: "2.0", id, result: registry.listTools() };
+      case "tools/call": {
+        const name = params.name;
+        if (typeof name !== "string") {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, 'tools/call needs a string "name".');
+        }
+        if (!registry.hasTool(name)) {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown tool: ${name}`);
+        }
+        const args = params.arguments;
+        if (args !== void 0 && (typeof args !== "object" || args === null || Array.isArray(args))) {
+          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, '"arguments" must be an object.');
+        }
+        const controller = new AbortController();
+        if (!isNotification) running.set(id, controller);
+        try {
+          const result = await registry.callTool(name, args ?? {}, { signal: controller.signal });
+          if (controller.signal.aborted) return null;
+          return { jsonrpc: "2.0", id, result };
+        } finally {
+          if (!isNotification) running.delete(id);
+        }
+      }
+      default:
+        if (isNotification) return null;
+        return errorResponse(id, JSON_RPC_ERRORS.methodNotFound, `Method not found: ${request.method}`);
+    }
+  }
+  return {
+    get initialized() {
+      return initialized;
+    },
+    async handle(message) {
+      let request;
+      if (typeof message === "string") {
+        try {
+          request = JSON.parse(message);
+        } catch {
+          return errorResponse(null, JSON_RPC_ERRORS.parseError, "Parse error.");
+        }
+      } else {
+        request = message;
+      }
+      if (!request || typeof request !== "object" || Array.isArray(request) || request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+        const id = request && typeof request === "object" && !Array.isArray(request) ? request.id ?? null : null;
+        return errorResponse(id, JSON_RPC_ERRORS.invalidRequest, "Invalid JSON-RPC 2.0 request.");
+      }
+      try {
+        return await dispatch(request);
+      } catch (error) {
+        if (request.id === void 0 || request.id === null) return null;
+        return errorResponse(
+          request.id,
+          JSON_RPC_ERRORS.internalError,
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    },
+    close() {
+      unsubscribe?.();
+      unsubscribe = null;
+      for (const controller of running.values()) controller.abort("Server closed.");
+      running.clear();
+    }
+  };
+}
+
+export {
+  ToolRegistryError,
+  TOOL_NAMESPACE_SEPARATOR,
+  toToolResult,
+  ToolRegistry,
+  createToolRegistry,
+  MCP_TOOL_GET_EDITOR_STATE,
+  MCP_TOOL_EDIT_CANVAS,
+  MCP_TOOL_EDIT_PROMPT,
+  MCP_TOOL_VIEW_EDITOR,
+  MCP_TOOL_CANVAS_ADD_NODE,
+  MCP_TOOL_CANVAS_REMOVE_NODES,
+  MCP_TOOL_CANVAS_CONNECT,
+  MCP_TOOL_CANVAS_UPDATE_NODE,
+  MCP_TOOL_CANVAS_LAYOUT,
+  MCP_TOOL_CANVAS_SELECT,
+  MCP_TOOL_CANVAS_HIGHLIGHT,
+  MCP_TOOL_PROMPT_INSERT_TEXT,
+  MCP_TOOL_PROMPT_REPLACE_RANGE,
+  MCP_TOOL_PROMPT_SET_VARIABLE,
+  MCP_TOOL_PROMPT_SELECT,
+  EDITOR_CANVAS_TOOLS,
+  EDITOR_PROMPT_TOOLS,
+  EDIT_OPERATION_REQUIRED_ARGUMENTS,
+  EXPORT_EXCLUDED_SELECTORS,
+  EDITOR_MCP_TOOLS,
+  MCP_PROTOCOL_VERSIONS,
+  JSON_RPC_ERRORS,
+  createMcpServer
+};
+//# sourceMappingURL=chunk-HHQ4XJWT.js.map