@pixerate/editor 0.260.0 → 0.262.0

package/dist/{chunk-5DLCOQOQ.cjs → chunk-YBC3RKT2.cjs}

@@ -1,6 +1,6 @@
-"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; }
+"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 _chunkRTPBM46Fcjs = require('./chunk-RTPBM46F.cjs');
+var _chunk7TD63DZPcjs = require('./chunk-7TD63DZP.cjs');
 
 
 var _chunk3SLBXKAWcjs = require('./chunk-3SLBXKAW.cjs');
@@ -39,7 +39,7 @@ function imageEvalFixturePixels(f) {
 }
 async function callEvalTool(callTool, { tool, args = {} }) {
   const res = await callTool(tool, await resolve(callTool, args));
-  if (res.isError) throw new Error(`${tool}: ${_nullishCoalesce(_optionalChain([res, 'access', _ => _.content, 'optionalAccess', _2 => _2[0], 'optionalAccess', _3 => _3.text]), () => ( "tool error"))}`);
+  if (res.isError) throw new Error(`${tool}: ${_nullishCoalesce(_optionalChain([res, 'access', _2 => _2.content, 'optionalAccess', _3 => _3[0], 'optionalAccess', _4 => _4.text]), () => ( "tool error"))}`);
   return res.structuredContent;
 }
 async function resolve(callTool, v) {
@@ -127,7 +127,7 @@ async function failedEvalChecks(callTool, checks) {
 function toolResultValue(result) {
   if (result.structuredContent) return result.structuredContent;
   const text = result.content.find((b) => b.type === "text");
-  if (!_optionalChain([text, 'optionalAccess', _4 => _4.text])) return void 0;
+  if (!_optionalChain([text, 'optionalAccess', _5 => _5.text])) return void 0;
   try {
     return JSON.parse(text.text);
   } catch (e3) {
@@ -136,7 +136,7 @@ function toolResultValue(result) {
 }
 function toolResultError(result) {
   const text = result.content.find((b) => b.type === "text");
-  return _nullishCoalesce(_optionalChain([text, 'optionalAccess', _5 => _5.text]), () => ( "The tool failed."));
+  return _nullishCoalesce(_optionalChain([text, 'optionalAccess', _6 => _6.text]), () => ( "The tool failed."));
 }
 var realWait = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 async function runToolScript(source, script, options = {}) {
@@ -147,7 +147,7 @@ async function runToolScript(source, script, options = {}) {
   })));
   const ctx = { results: {}, last: void 0 };
   const finish = (ok) => {
-    if (control.stopped) _optionalChain([options, 'access', _6 => _6.playback, 'optionalAccess', _7 => _7.stop, 'call', _8 => _8()]);
+    if (control.stopped) _optionalChain([options, 'access', _7 => _7.playback, 'optionalAccess', _8 => _8.stop, 'call', _9 => _9()]);
     emit({ type: "done", ok, stopped: control.stopped });
     return { ok, ctx };
   };
@@ -156,7 +156,7 @@ async function runToolScript(source, script, options = {}) {
     const step = script.steps[i];
     if (step.say) {
       emit({ type: "say", step: i, text: step.say });
-      _optionalChain([options, 'access', _9 => _9.playback, 'optionalAccess', _10 => _10.say, 'call', _11 => _11(step.say, options.actor ? { actor: options.actor } : {})]);
+      _optionalChain([options, 'access', _10 => _10.playback, 'optionalAccess', _11 => _11.say, 'call', _12 => _12(step.say, options.actor ? { actor: options.actor } : {})]);
       await pause(_chunk3SLBXKAWcjs.readingTime.call(void 0, step.say));
     }
     if (!step.tool) continue;
@@ -187,7 +187,7 @@ var STYLE_SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
 var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function parseStyleDomains(markdown) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
-  const line = _optionalChain([match, 'optionalAccess', _12 => _12[1], 'access', _13 => _13.split, 'call', _14 => _14(/\r?\n/), 'access', _15 => _15.find, 'call', _16 => _16((l) => /^domains:/.test(l))]);
+  const line = _optionalChain([match, 'optionalAccess', _13 => _13[1], 'access', _14 => _14.split, 'call', _15 => _15(/\r?\n/), 'access', _16 => _16.find, 'call', _17 => _17((l) => /^domains:/.test(l))]);
   if (!line) return void 0;
   const raw = line.slice("domains:".length).trim().replace(/^\[|\]$/g, "");
   return raw.split(",").map((d) => d.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean);
@@ -205,8 +205,8 @@ function memoryStyleStore(initial = {}, state = {}) {
   }
   return {
     list: () => [.../* @__PURE__ */ new Set([...files.keys(), ...states.keys()])].sort().map((name) => ({ name, ...states.get(name) })),
-    read: (name, file) => _optionalChain([files, 'access', _17 => _17.get, 'call', _18 => _18(name), 'optionalAccess', _19 => _19.get, 'call', _20 => _20(file)]),
-    files: (name) => [..._nullishCoalesce(_optionalChain([files, 'access', _21 => _21.get, 'call', _22 => _22(name), 'optionalAccess', _23 => _23.keys, 'call', _24 => _24()]), () => ( []))].sort(),
+    read: (name, file) => _optionalChain([files, 'access', _18 => _18.get, 'call', _19 => _19(name), 'optionalAccess', _20 => _20.get, 'call', _21 => _21(file)]),
+    files: (name) => [..._nullishCoalesce(_optionalChain([files, 'access', _22 => _22.get, 'call', _23 => _23(name), 'optionalAccess', _24 => _24.keys, 'call', _25 => _25()]), () => ( []))].sort(),
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -344,7 +344,7 @@ function createStyleResolver(options) {
         }
         enabled = entry.enabled;
       }
-      const { description = "", body } = _chunkRTPBM46Fcjs.parseSkillFrontmatter.call(void 0, winner.text);
+      const { description = "", body } = _chunk7TD63DZPcjs.parseSkillFrontmatter.call(void 0, winner.text);
       const named = parseStyleDomains(winner.text);
       const applies = /* @__PURE__ */ new Set();
       for (const d of _nullishCoalesce(named, () => ( domainIds))) {
@@ -449,8 +449,8 @@ function createStyleResolver(options) {
       return { ...runStyleChecks(domain, state, style), style };
     },
     subscribe(listener) {
-      const offs = [...layers.map((l) => _optionalChain([l, 'access', _25 => _25.store, 'access', _26 => _26.subscribe, 'optionalCall', _27 => _27(listener)])), _optionalChain([options, 'access', _28 => _28.tokens, 'optionalAccess', _29 => _29.subscribe, 'optionalCall', _30 => _30(listener)])];
-      return () => offs.forEach((off) => _optionalChain([off, 'optionalCall', _31 => _31()]));
+      const offs = [...layers.map((l) => _optionalChain([l, 'access', _26 => _26.store, 'access', _27 => _27.subscribe, 'optionalCall', _28 => _28(listener)])), _optionalChain([options, 'access', _29 => _29.tokens, 'optionalAccess', _30 => _30.subscribe, 'optionalCall', _31 => _31(listener)])];
+      return () => offs.forEach((off) => _optionalChain([off, 'optionalCall', _32 => _32()]));
     }
   };
 }
@@ -586,16 +586,177 @@ function createStyleToolProvider(styles, options = {}) {
 function createOriginMiddleware(options) {
   const fallback = _nullishCoalesce(options.fallbackOrigin, () => ( "agent:anonymous"));
   return (call, next) => {
-    if (_optionalChain([call, 'access', _32 => _32.tool, 'access', _33 => _33.annotations, 'optionalAccess', _34 => _34.readOnlyHint]) === true) return next();
+    if (_optionalChain([call, 'access', _33 => _33.tool, 'access', _34 => _34.annotations, 'optionalAccess', _35 => _35.readOnlyHint]) === true) return next();
     const found = typeof options.histories === "function" ? options.histories(call) : options.histories;
     const targets = !found ? [] : Array.isArray(found) ? found : [found];
     if (!targets.length) return next();
-    const origin = _optionalChain([call, 'access', _35 => _35.context, 'access', _36 => _36.actor, 'optionalAccess', _37 => _37.id]) ? `agent:${call.context.actor.id}` : fallback;
+    const origin = _optionalChain([call, 'access', _36 => _36.context, 'access', _37 => _37.actor, 'optionalAccess', _38 => _38.id]) ? `agent:${call.context.actor.id}` : fallback;
     const run = targets.reduceRight((inner, target) => () => target.withOrigin(origin, inner), next);
     return run();
   };
 }
 
+// src/tools/conformance.ts
+var ConformanceIds = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  __init() {this.toPlaceholder = /* @__PURE__ */ new Map()}
+  __init2() {this.fromPlaceholder = /* @__PURE__ */ new Map()}
+  /** The placeholder for `id`, assigning the next one when it is new. */
+  add(id) {
+    let placeholder = this.toPlaceholder.get(id);
+    if (!placeholder) {
+      placeholder = `@${this.toPlaceholder.size + 1}`;
+      this.toPlaceholder.set(id, placeholder);
+      this.fromPlaceholder.set(placeholder, id);
+    }
+    return placeholder;
+  }
+  placeholder(id) {
+    return this.toPlaceholder.get(id);
+  }
+  /** `text` with every known id in it replaced by its placeholder (longest ids first). */
+  replaceWithin(text) {
+    const exact = this.toPlaceholder.get(text);
+    if (exact) return exact;
+    let out = text;
+    for (const id of [...this.toPlaceholder.keys()].sort((a, b) => b.length - a.length)) {
+      if (out.includes(id)) out = out.split(id).join(this.toPlaceholder.get(id));
+    }
+    return out;
+  }
+  /** The real id a placeholder stands for. */
+  resolve(placeholder) {
+    return this.fromPlaceholder.get(placeholder);
+  }
+}, _class);
+var PLACEHOLDER = /^@[1-9][0-9]*$/;
+var TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var BASE64 = /^[A-Za-z0-9+/=_-]+$/;
+var CONFORMANCE_BINARY_MIN_LENGTH = 200;
+function isBinary(value) {
+  return value.startsWith("data:") || value.length >= CONFORMANCE_BINARY_MIN_LENGTH && BASE64.test(value);
+}
+function sortedKeys(value) {
+  return Object.keys(value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function collectIds(value, ids, isId) {
+  if (typeof value === "string") {
+    if (isId(value)) ids.add(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectIds(item, ids, isId);
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const k of sortedKeys(value)) {
+      if (isId(k)) ids.add(k);
+      collectIds(value[k], ids, isId);
+    }
+  }
+}
+function replaceIds(value, ids) {
+  if (typeof value === "string") return isBinary(value) ? "<binary>" : TIMESTAMP.test(value) ? "<time>" : ids.replaceWithin(value);
+  if (Array.isArray(value)) return value.map((item) => replaceIds(item, ids));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const k of sortedKeys(value)) out[ids.replaceWithin(k)] = replaceIds(value[k], ids);
+    return out;
+  }
+  return value;
+}
+function normalizeConformanceValue(value, ids, isGeneratedId = () => false) {
+  const json = value === void 0 ? null : JSON.parse(JSON.stringify(value));
+  collectIds(json, ids, (v) => !PLACEHOLDER.test(v) && isGeneratedId(v));
+  return replaceIds(json, ids);
+}
+function omitConformancePaths(value, paths) {
+  let out = value === void 0 ? null : JSON.parse(JSON.stringify(value));
+  for (const path of paths) out = omitPath(out, path.split("/").slice(1));
+  return out;
+}
+function omitPath(value, parts) {
+  if (!value || typeof value !== "object" || parts.length === 0) return value;
+  const [head, ...rest] = parts;
+  if (Array.isArray(value)) {
+    if (head === "*") return value.map((item) => omitPath(item, rest));
+    const i = Number(head);
+    if (!Number.isInteger(i) || i < 0 || i >= value.length) return value;
+    if (rest.length === 0) return value.filter((_, j) => j !== i);
+    return value.map((item, j) => j === i ? omitPath(item, rest) : item);
+  }
+  const object = value;
+  const keys = head === "*" ? Object.keys(object) : head in object ? [head] : [];
+  for (const key of keys) {
+    if (rest.length === 0) delete object[key];
+    else object[key] = omitPath(object[key], rest);
+  }
+  return object;
+}
+function resolveConformanceArguments(value, ids) {
+  if (typeof value === "string" && PLACEHOLDER.test(value)) {
+    const id = ids.resolve(value);
+    if (id === void 0) throw new Error(`Placeholder ${value} is used before any result returned that id.`);
+    return id;
+  }
+  if (Array.isArray(value)) return value.map((item) => resolveConformanceArguments(item, ids));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = resolveConformanceArguments(v, ids);
+    return out;
+  }
+  return value;
+}
+function conformanceResult(result) {
+  if (result.isError) {
+    const error = _nullishCoalesce(_optionalChain([result, 'access', _39 => _39.structuredContent, 'optionalAccess', _40 => _40.error]), () => ( {}));
+    const value = { code: _nullishCoalesce(error.code, () => ( "tool_failed")), message: _nullishCoalesce(_nullishCoalesce(error.message, () => ( resultText(result))), () => ( "")), ...error.details !== void 0 ? { details: error.details } : {} };
+    return { value: { error: value }, isError: true };
+  }
+  if (result.structuredContent !== void 0) return { value: result.structuredContent, isError: false };
+  const text = resultText(result);
+  if (text === void 0) return { value: null, isError: false };
+  try {
+    return { value: JSON.parse(text), isError: false };
+  } catch (e4) {
+    return { value: text, isError: false };
+  }
+}
+function resultText(result) {
+  for (const content of result.content) {
+    if (content.type === "text" && "text" in content && typeof content.text === "string") return content.text;
+  }
+  return void 0;
+}
+async function runConformanceScenario(scenario, host) {
+  const ids = new ConformanceIds();
+  const isId = _optionalChain([host, 'access', _41 => _41.isGeneratedId, 'optionalAccess', _42 => _42.bind, 'call', _43 => _43(host)]);
+  const outputs = [];
+  try {
+    for (const step of scenario.steps) {
+      const args = resolveConformanceArguments(_nullishCoalesce(step.arguments, () => ( {})), ids);
+      const { value, isError } = conformanceResult(await host.callTool(step.tool, args));
+      const result = normalizeConformanceValue(value, ids, isId);
+      const output = { result: step.ignore ? omitConformancePaths(result, step.ignore) : result, isError };
+      if (step.document) output.document = normalizeConformanceValue(host.document(), ids, isId);
+      if (step.pixels) {
+        const image = host.pixels({ paper: typeof step.pixels === "object" ? step.pixels.paper : void 0 });
+        output.pixels = { width: image.width, height: image.height, data: new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength) };
+      }
+      outputs.push(output);
+    }
+  } finally {
+    _optionalChain([host, 'access', _44 => _44.dispose, 'optionalCall', _45 => _45()]);
+  }
+  return outputs;
+}
+
+
+
+
+
+
+
+
 
 
 
@@ -612,4 +773,4 @@ function createOriginMiddleware(options) {
 
 
 
-exports.listSkillEvals = listSkillEvals; exports.imageEvalFixturePixels = imageEvalFixturePixels; exports.callEvalTool = callEvalTool; exports.matchesEvalExpectation = matchesEvalExpectation; exports.failedEvalChecks = failedEvalChecks; exports.toolResultValue = toolResultValue; exports.toolResultError = toolResultError; exports.runToolScript = runToolScript; exports.parseStyleDomains = parseStyleDomains; exports.memoryStyleStore = memoryStyleStore; exports.createStyleResolver = createStyleResolver; exports.runStyleChecks = runStyleChecks; exports.renderStyle = renderStyle; exports.createStyleToolProvider = createStyleToolProvider; exports.createOriginMiddleware = createOriginMiddleware;
+exports.listSkillEvals = listSkillEvals; exports.imageEvalFixturePixels = imageEvalFixturePixels; exports.callEvalTool = callEvalTool; exports.matchesEvalExpectation = matchesEvalExpectation; exports.failedEvalChecks = failedEvalChecks; exports.toolResultValue = toolResultValue; exports.toolResultError = toolResultError; exports.runToolScript = runToolScript; exports.parseStyleDomains = parseStyleDomains; exports.memoryStyleStore = memoryStyleStore; exports.createStyleResolver = createStyleResolver; exports.runStyleChecks = runStyleChecks; exports.renderStyle = renderStyle; exports.createStyleToolProvider = createStyleToolProvider; exports.createOriginMiddleware = createOriginMiddleware; exports.ConformanceIds = ConformanceIds; exports.CONFORMANCE_BINARY_MIN_LENGTH = CONFORMANCE_BINARY_MIN_LENGTH; exports.normalizeConformanceValue = normalizeConformanceValue; exports.omitConformancePaths = omitConformancePaths; exports.resolveConformanceArguments = resolveConformanceArguments; exports.conformanceResult = conformanceResult; exports.runConformanceScenario = runConformanceScenario;

package/dist/chunk-ZEKI6EPI.cjs

@@ -0,0 +1,301 @@
+"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 _chunk7TD63DZPcjs = require('./chunk-7TD63DZP.cjs');
+
+// 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 toolsetInstructions(source) {
+  const sets = source.toolsets();
+  const discovery = source.hasTool("list_toolsets") && source.hasTool("search_tools");
+  const lines = [
+    "Tools are grouped into toolsets, one per open editor or feature, and named `<toolset>__<tool>`." + (discovery ? " Only some are listed at first: call list_toolsets to see them all, search_tools to find a tool for a task, and enable_tools to add what you need." : "")
+  ];
+  if (sets.length > 0) {
+    lines.push("", "Toolsets:");
+    for (const set of sets) {
+      const about = [set.title, _chunk7TD63DZPcjs.summarize.call(void 0, set.description)].filter(Boolean).join(": ");
+      const skill = set.skill ? ` (skill: ${set.skill})` : "";
+      lines.push(`- ${set.name}${about ? ` - ${about}` : ""}${skill}, ${set.tools.length} tools`);
+    }
+  }
+  if (sets.some((s) => s.skill)) {
+    lines.push(
+      "",
+      "Read the skill a toolset names before using it" + (source.hasTool("get_skill") ? " (get_skill)." : " (an MCP resource or prompt when the server offers skills).")
+    );
+  }
+  return lines.join("\n");
+}
+var skillUri = (path) => `skill://${path}`;
+function createMcpServer(registry, options) {
+  const skillFiles = _nullishCoalesce(options.skills, () => ( null));
+  const skills = skillFiles ? _chunk7TD63DZPcjs.listSkills.call(void 0, skillFiles) : [];
+  const capabilities = {
+    ...registry.capabilities,
+    ...skills.length > 0 ? { resources: {}, prompts: {} } : {}
+  };
+  const readSkillPath = (path) => _nullishCoalesce(_optionalChain([skillFiles, 'optionalAccess', _ => _[path]]), () => ( _optionalChain([skillFiles, 'optionalAccess', _2 => _2[`./${path}`]])));
+  let initialized = false;
+  let actor;
+  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 client = params.clientInfo;
+        if (client && typeof client.name === "string" && client.name) {
+          actor = { id: `mcp:${client.name}`, name: typeof client.title === "string" && client.title ? client.title : client.name };
+        }
+        const instructions = typeof options.instructions === "function" ? options.instructions(registry) : options.instructions;
+        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,
+            serverInfo: { name: options.name, version: options.version, ...options.title ? { title: options.title } : {} },
+            ...instructions ? { instructions } : {}
+          }
+        };
+      }
+      case "notifications/initialized":
+        initialized = true;
+        startNotifications();
+        return null;
+      case "notifications/cancelled": {
+        const requestId = params.requestId;
+        if (requestId !== void 0) _optionalChain([running, 'access', _3 => _3.get, 'call', _4 => _4(requestId), 'optionalAccess', _5 => _5.abort, 'call', _6 => _6(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, ...actor ? { actor } : {} });
+          if (controller.signal.aborted) return null;
+          return { jsonrpc: "2.0", id, result };
+        } finally {
+          if (!isNotification) running.delete(id);
+        }
+      }
+      case "resources/list":
+      case "prompts/list":
+      case "resources/read":
+      case "prompts/get": {
+        if (skills.length === 0) break;
+        if (request.method === "resources/list") {
+          const resources = skills.flatMap(
+            (skill2) => ["SKILL.md", ...skill2.references].map((file) => ({
+              uri: skillUri(`${skill2.name}/${file}`),
+              name: file === "SKILL.md" ? skill2.name : `${skill2.name}/${file}`,
+              ...file === "SKILL.md" ? { description: skill2.description } : {},
+              mimeType: "text/markdown"
+            }))
+          );
+          return { jsonrpc: "2.0", id, result: { resources } };
+        }
+        if (request.method === "resources/read") {
+          const uri = String(_nullishCoalesce(params.uri, () => ( "")));
+          const text2 = uri.startsWith("skill://") ? readSkillPath(uri.slice("skill://".length)) : void 0;
+          if (text2 === void 0) return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown resource: ${uri}`, { uri });
+          return { jsonrpc: "2.0", id, result: { contents: [{ uri, mimeType: "text/markdown", text: text2 }] } };
+        }
+        if (request.method === "prompts/list") {
+          return { jsonrpc: "2.0", id, result: { prompts: skills.map((s) => ({ name: s.name, description: s.description })) } };
+        }
+        const skill = skills.find((s) => s.name === params.name);
+        const text = skill ? readSkillPath(`${skill.name}/SKILL.md`) : void 0;
+        if (!skill || text === void 0) return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown prompt: ${String(params.name)}`);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            description: skill.description,
+            messages: [{ role: "user", content: { type: "text", text: _chunk7TD63DZPcjs.parseSkillFrontmatter.call(void 0, text).body.trim() } }]
+          }
+        };
+      }
+    }
+    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 (e) {
+          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', _7 => _7()]);
+      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', _8 => _8.onStatus, 'optionalCall', _9 => _9(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 (e2) {
+        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', _10 => _10.get, 'call', _11 => _11(message.id), 'optionalAccess', _12 => _12.abort, 'call', _13 => _13(_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', _14 => _14.close, 'call', _15 => _15(1e3, "Editor closed.")]);
+      setStatus("closed");
+    }
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.MCP_PROTOCOL_VERSIONS = MCP_PROTOCOL_VERSIONS; exports.JSON_RPC_ERRORS = JSON_RPC_ERRORS; exports.toolsetInstructions = toolsetInstructions; exports.createMcpServer = createMcpServer; exports.TOOL_BRIDGE_PROTOCOL = TOOL_BRIDGE_PROTOCOL; exports.TOOL_BRIDGE_DEFAULT_PORT = TOOL_BRIDGE_DEFAULT_PORT; exports.connectToolBridge = connectToolBridge;