@pixerate/editor 0.139.1 → 0.140.1

package/dist/chunk-SPVIXXIB.cjs

@@ -1,466 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
-
-var _chunkWOFXZ3XUcjs = require('./chunk-WOFXZ3XU.cjs');
-
-// src/tools/registry.ts
-var ToolRegistryError = class extends Error {
-  
-  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 = _optionalChain([error, 'access', _ => _.details, 'optionalAccess', _2 => _2.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: _nullishCoalesce(text, () => ( String(value))) }],
-    ...isPlainObject ? { structuredContent: value } : {}
-  };
-}
-var ToolRegistry = (_class = class {
-  /** MCP server capabilities this registry supports. */
-  __init() {this.capabilities = { tools: { listChanged: true } }}
-  __init2() {this.entries = []}
-  __init3() {this.listeners = /* @__PURE__ */ new Set()}
-  
-  __init4() {this.timer = null}
-  
-  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
-    this.options = {
-      onCollision: _nullishCoalesce(options.onCollision, () => ( "namespace")),
-      listChangedDelayMs: _nullishCoalesce(options.listChangedDelayMs, () => ( 0)),
-      validateArguments: _nullishCoalesce(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);
-    _optionalChain([entry, 'access', _3 => _3.unsubscribe, 'optionalCall', _4 => _4()]);
-    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, (_nullishCoalesce(counts.get(tool.name), () => ( 0))) + 1);
-      }
-    }
-    for (const item of all) {
-      const prefix = _nullishCoalesce(item.provider.namespace, () => ( ((_nullishCoalesce(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 = _nullishCoalesce(args, () => ( {}));
-    if (this.options.validateArguments) {
-      const details = _chunkWOFXZ3XUcjs.validateJsonSchema.call(void 0, 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 (e2) {
-      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)) _optionalChain([entry, 'access', _5 => _5.unsubscribe, 'optionalCall', _6 => _6()]);
-    this.listeners.clear();
-  }
-}, _class);
-function createToolRegistry(options) {
-  return new ToolRegistry(options);
-}
-
-// 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 = _nullishCoalesce(request.id, () => ( null));
-    const isNotification = request.id === void 0 || request.id === null;
-    const params = _nullishCoalesce(request.params, () => ( {}));
-    switch (request.method) {
-      case "initialize": {
-        const requested = String(_nullishCoalesce(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) _optionalChain([running, 'access', _7 => _7.get, 'call', _8 => _8(requestId), 'optionalAccess', _9 => _9.abort, 'call', _10 => _10(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, _nullishCoalesce(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 (e3) {
-          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) ? _nullishCoalesce(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() {
-      _optionalChain([unsubscribe, 'optionalCall', _11 => _11()]);
-      unsubscribe = null;
-      for (const controller of running.values()) controller.abort("Server closed.");
-      running.clear();
-    }
-  };
-}
-
-// src/tools/bridge-client.ts
-var TOOL_BRIDGE_PROTOCOL = 1;
-var TOOL_BRIDGE_DEFAULT_PORT = 4477;
-function connectToolBridge(registry, options) {
-  const Ctor = _nullishCoalesce(options.WebSocket, () => ( globalThis.WebSocket));
-  if (!Ctor) throw new Error("No WebSocket implementation: pass options.WebSocket.");
-  const base = _nullishCoalesce(options.url, () => ( `ws://127.0.0.1:${TOOL_BRIDGE_DEFAULT_PORT}`));
-  const url = options.token ? `${base}${base.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.token)}` : base;
-  let status = "connecting";
-  let editorId = null;
-  let socket = null;
-  let closed = false;
-  let delay = 500;
-  let retry = null;
-  const running = /* @__PURE__ */ new Map();
-  const setStatus = (next, detail) => {
-    if (next === status && !detail) return;
-    status = next;
-    _optionalChain([options, 'access', _12 => _12.onStatus, 'optionalCall', _13 => _13(next, detail)]);
-  };
-  const send = (message) => {
-    if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
-  };
-  const unsubscribe = registry.onListChanged((tools) => send({ t: "tools", tools }));
-  const open = () => {
-    if (closed) return;
-    setStatus("connecting");
-    const ws = new Ctor(url);
-    socket = ws;
-    ws.addEventListener("open", () => {
-      delay = 500;
-      send({ t: "hello", v: TOOL_BRIDGE_PROTOCOL, name: options.name, ...options.kind ? { kind: options.kind } : {}, tools: registry.listTools().tools });
-    });
-    ws.addEventListener("message", (event) => {
-      let message;
-      try {
-        message = JSON.parse(String(event.data));
-      } catch (e4) {
-        return;
-      }
-      if (message.t === "welcome") {
-        editorId = message.id;
-        setStatus("connected");
-      } else if (message.t === "call") {
-        const controller = new AbortController();
-        running.set(message.id, controller);
-        void registry.callTool(message.name, _nullishCoalesce(message.arguments, () => ( {})), { signal: controller.signal }).then((result) => {
-          running.delete(message.id);
-          if (!controller.signal.aborted) send({ t: "result", id: message.id, result });
-        });
-      } else if (message.t === "cancel") {
-        _optionalChain([running, 'access', _14 => _14.get, 'call', _15 => _15(message.id), 'optionalAccess', _16 => _16.abort, 'call', _17 => _17(_nullishCoalesce(message.reason, () => ( "Cancelled by the agent.")))]);
-        running.delete(message.id);
-      }
-    });
-    ws.addEventListener("close", (event) => {
-      if (socket !== ws) return;
-      socket = null;
-      editorId = null;
-      for (const controller of running.values()) controller.abort("The bridge disconnected.");
-      running.clear();
-      if (closed) return setStatus("closed");
-      setStatus("disconnected", event.reason || void 0);
-      if (options.reconnect === false) return;
-      retry = setTimeout(open, delay);
-      delay = Math.min(1e4, delay * 2);
-    });
-    ws.addEventListener("error", () => {
-    });
-  };
-  open();
-  return {
-    get status() {
-      return status;
-    },
-    get editorId() {
-      return editorId;
-    },
-    close() {
-      if (closed) return;
-      closed = true;
-      if (retry) clearTimeout(retry);
-      unsubscribe();
-      for (const controller of running.values()) controller.abort("The editor disconnected.");
-      running.clear();
-      const ws = socket;
-      socket = null;
-      _optionalChain([ws, 'optionalAccess', _18 => _18.close, 'call', _19 => _19(1e3, "Editor closed.")]);
-      setStatus("closed");
-    }
-  };
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.ToolRegistryError = ToolRegistryError; exports.TOOL_NAMESPACE_SEPARATOR = TOOL_NAMESPACE_SEPARATOR; exports.toToolResult = toToolResult; exports.ToolRegistry = ToolRegistry; exports.createToolRegistry = createToolRegistry; exports.MCP_PROTOCOL_VERSIONS = MCP_PROTOCOL_VERSIONS; exports.JSON_RPC_ERRORS = JSON_RPC_ERRORS; exports.createMcpServer = createMcpServer; exports.TOOL_BRIDGE_PROTOCOL = TOOL_BRIDGE_PROTOCOL; exports.TOOL_BRIDGE_DEFAULT_PORT = TOOL_BRIDGE_DEFAULT_PORT; exports.connectToolBridge = connectToolBridge;