@pixerate/editor 0.140.4 → 0.141.0

package/dist/chunk-DW4CV5H4.js

@@ -0,0 +1,591 @@
+// src/canvas/layout.ts
+import dagre from "@dagrejs/dagre";
+var DEFAULT_NODE_WIDTH = 200;
+var DEFAULT_NODE_HEIGHT = 60;
+var DEFAULT_PLACEMENT_GAP = 48;
+function getCenteredNodePosition(width = 0, height = 0, screenToFlowPosition, screenDimensions) {
+  const rect = screenDimensions ?? (typeof document !== "undefined" ? { width: document.documentElement.clientWidth, height: document.documentElement.clientHeight } : { width: 1920, height: 1080 });
+  const flowPos = screenToFlowPosition({ x: rect.width / 2, y: rect.height / 2 });
+  return {
+    x: flowPos.x - width / 2,
+    y: flowPos.y - height / 2
+  };
+}
+function centerNodes(nodes, screenToFlowPosition, getNodesBounds, screenDimensions) {
+  if (nodes.length === 0) {
+    return [];
+  }
+  const bounds = getNodesBounds(nodes);
+  const boundingBoxOrigin = { x: bounds.x, y: bounds.y };
+  const centeredPosition = getCenteredNodePosition(
+    bounds.width,
+    bounds.height,
+    screenToFlowPosition,
+    screenDimensions
+  );
+  const deltaX = centeredPosition.x - boundingBoxOrigin.x;
+  const deltaY = centeredPosition.y - boundingBoxOrigin.y;
+  return nodes.map((node) => ({
+    ...node,
+    position: {
+      x: node.position.x + deltaX,
+      y: node.position.y + deltaY
+    }
+  }));
+}
+function getLayoutedNodes(nodes, edges, getNodesBounds, options = {}) {
+  if (nodes.length === 0) return [];
+  const {
+    direction = "LR",
+    ranksep = 100,
+    nodesep = 25,
+    defaultNodeWidth = DEFAULT_NODE_WIDTH,
+    defaultNodeHeight = DEFAULT_NODE_HEIGHT
+  } = options;
+  const dagreGraph = new dagre.graphlib.Graph();
+  dagreGraph.setDefaultEdgeLabel(() => ({}));
+  dagreGraph.setGraph({ rankdir: direction, ranksep, nodesep });
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  nodes.forEach((node) => {
+    const nodeWidth = node.measured?.width ?? node.width ?? defaultNodeWidth;
+    const nodeHeight = node.measured?.height ?? node.height ?? defaultNodeHeight;
+    dagreGraph.setNode(node.id, { width: nodeWidth, height: nodeHeight });
+  });
+  edges.forEach((edge) => {
+    if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+      dagreGraph.setEdge(edge.source, edge.target);
+    }
+  });
+  dagre.layout(dagreGraph);
+  return nodes.map((node) => {
+    const nodeWithPosition = dagreGraph.node(node.id);
+    const nodeWidth = node.measured?.width ?? node.width ?? defaultNodeWidth;
+    const nodeHeight = node.measured?.height ?? node.height ?? defaultNodeHeight;
+    return {
+      ...node,
+      position: {
+        x: nodeWithPosition.x - nodeWidth / 2,
+        y: nodeWithPosition.y - nodeHeight / 2
+      }
+    };
+  });
+}
+function estimateNodeSize(node, defaultWidth = DEFAULT_NODE_WIDTH, defaultHeight = DEFAULT_NODE_HEIGHT) {
+  const label = String(node.data?.label ?? node.data?.title ?? node.id ?? "");
+  const lines = label.split(/\n|<br\s*\/?>/);
+  const longest = Math.max(...lines.map((l) => l.replace(/<[^>]+>/g, "").length), 1);
+  const width = Math.min(480, Math.max(defaultWidth, longest * 8 + 48));
+  const height = Math.max(defaultHeight, lines.length * 20 + 24);
+  return { width, height };
+}
+function boundsOf(rects) {
+  if (!rects.length) return null;
+  const minX = Math.min(...rects.map((r) => r.x));
+  const minY = Math.min(...rects.map((r) => r.y));
+  const maxX = Math.max(...rects.map((r) => r.x + r.width));
+  const maxY = Math.max(...rects.map((r) => r.y + r.height));
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function centre(r) {
+  return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
+}
+function overlaps(a, b, pad = 16) {
+  return a.x < b.x + b.width + pad && a.x + a.width + pad > b.x && a.y < b.y + b.height + pad && a.y + a.height + pad > b.y;
+}
+function flowSide(direction = "LR") {
+  switch (direction) {
+    case "LR":
+      return "right";
+    case "RL":
+      return "left";
+    case "BT":
+      return "above";
+    case "TB":
+    default:
+      return "below";
+  }
+}
+function ensureLayout(nodes, edges, options = {}) {
+  if (nodes.length === 0) return [];
+  const stored = options.storedPositions ?? {};
+  const missing = nodes.filter((n) => !stored[n.id]);
+  if (missing.length === 0) {
+    return nodes.map((n) => ({
+      ...n,
+      position: { ...stored[n.id] }
+    }));
+  }
+  const autoLayouted = getLayoutedNodes(nodes, edges, void 0, options);
+  const autoMap = new Map(
+    autoLayouted.map((n) => [n.id, n.position])
+  );
+  const both = nodes.filter((n) => stored[n.id] && autoMap.has(n.id));
+  if (both.length === 0) {
+    return autoLayouted;
+  }
+  let dx = 0;
+  let dy = 0;
+  for (const n of both) {
+    const s = stored[n.id];
+    const a = autoMap.get(n.id);
+    dx += s.x - a.x;
+    dy += s.y - a.y;
+  }
+  dx /= both.length;
+  dy /= both.length;
+  return nodes.map((node) => {
+    if (stored[node.id]) {
+      return {
+        ...node,
+        position: { ...stored[node.id] }
+      };
+    }
+    const autoPos = autoMap.get(node.id) ?? { x: 0, y: 0 };
+    return {
+      ...node,
+      position: {
+        x: Math.round(autoPos.x + dx),
+        y: Math.round(autoPos.y + dy)
+      }
+    };
+  });
+}
+function placeBeside(rects, size, side, nearNodeId, options = {}) {
+  const {
+    gap = DEFAULT_PLACEMENT_GAP,
+    ignore = [],
+    maxAttempts = 32
+  } = options;
+  const skip = new Set([nearNodeId, ...ignore].filter(Boolean));
+  const obstacles = Object.entries(rects).filter(([id]) => !skip.has(id)).map(([, r]) => r);
+  const anchor = nearNodeId && rects[nearNodeId] || boundsOf(Object.values(rects)) || { x: 0, y: 0, width: 0, height: 0 };
+  const anchorCenter = centre(anchor);
+  let baseX;
+  let baseY;
+  switch (side) {
+    case "right":
+      baseX = anchor.x + anchor.width + gap;
+      baseY = anchorCenter.y - size.height / 2;
+      break;
+    case "left":
+      baseX = anchor.x - gap - size.width;
+      baseY = anchorCenter.y - size.height / 2;
+      break;
+    case "above":
+      baseX = anchorCenter.x - size.width / 2;
+      baseY = anchor.y - gap - size.height;
+      break;
+    case "below":
+    default:
+      baseX = anchorCenter.x - size.width / 2;
+      baseY = anchor.y + anchor.height + gap;
+      break;
+  }
+  const isHorizontal = side === "right" || side === "left";
+  const step = (isHorizontal ? size.height : size.width) + 20;
+  for (let i = 0; i < maxAttempts; i++) {
+    const offset = i === 0 ? 0 : Math.ceil(i / 2) * step * (i % 2 === 1 ? 1 : -1);
+    const candidateBox = {
+      x: isHorizontal ? baseX : baseX + offset,
+      y: isHorizontal ? baseY + offset : baseY,
+      width: size.width,
+      height: size.height
+    };
+    if (!obstacles.some((obstacle) => overlaps(candidateBox, obstacle, 8))) {
+      return {
+        x: Math.round(candidateBox.x),
+        y: Math.round(candidateBox.y)
+      };
+    }
+  }
+  return {
+    x: Math.round(baseX),
+    y: Math.round(baseY)
+  };
+}
+
+// src/canvas/arrange.ts
+var LOCKED_DATA_KEY = "locked";
+var LOCKED_PREVIOUS_FLAGS_KEY = "lockedPrevious";
+function parsePx(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const match = /^\s*(-?\d+(?:\.\d+)?)(px)?\s*$/i.exec(value);
+    if (match) return Number(match[1]);
+  }
+  return void 0;
+}
+function readStyleSize(style) {
+  if (!style) return {};
+  if (typeof style === "object") {
+    return { width: parsePx(style.width), height: parsePx(style.height) };
+  }
+  const read = (prop) => {
+    const match = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i").exec(style);
+    return match ? parsePx(match[1]) : void 0;
+  };
+  return { width: read("width"), height: read("height") };
+}
+function withStyleSize(style, size) {
+  if (!style) return style ?? void 0;
+  if (typeof style === "object") {
+    const next2 = { ...style };
+    if (size.width !== void 0 && "width" in next2) next2.width = size.width;
+    if (size.height !== void 0 && "height" in next2) next2.height = size.height;
+    return next2;
+  }
+  let next = style;
+  for (const prop of ["width", "height"]) {
+    const value = size[prop];
+    if (value === void 0) continue;
+    next = next.replace(
+      new RegExp(`((?:^|;)\\s*${prop}\\s*:\\s*)[^;]+`, "i"),
+      `$1${value}px`
+    );
+  }
+  return next;
+}
+function getNodeSize(node, options = {}) {
+  const styleSize = readStyleSize(node.style);
+  let width = node.measured?.width ?? node.width ?? styleSize.width;
+  let height = node.measured?.height ?? node.height ?? styleSize.height;
+  if (width === void 0 || height === void 0) {
+    const fallback = options.estimate === false ? { width: options.defaultWidth ?? 200, height: options.defaultHeight ?? 60 } : estimateNodeSize(node, options.defaultWidth, options.defaultHeight);
+    width ??= fallback.width;
+    height ??= fallback.height;
+  }
+  return { width, height };
+}
+function getAbsolutePosition(node, lookup) {
+  let x = node.position.x;
+  let y = node.position.y;
+  const seen = /* @__PURE__ */ new Set([node.id]);
+  let parentId = node.parentId;
+  while (parentId && !seen.has(parentId)) {
+    const parent = lookup.get(parentId);
+    if (!parent) break;
+    seen.add(parentId);
+    x += parent.position.x;
+    y += parent.position.y;
+    parentId = parent.parentId;
+  }
+  return { x, y };
+}
+function createNodeLookup(nodes) {
+  return new Map(nodes.map((n) => [n.id, n]));
+}
+function getNodeRect(node, lookup, options) {
+  const { x, y } = node.parentId && lookup ? getAbsolutePosition(node, lookup) : node.position;
+  return { x, y, ...getNodeSize(node, options) };
+}
+function isLocked(node) {
+  return node?.data?.[LOCKED_DATA_KEY] === true;
+}
+function lockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  return nodes.map((node) => {
+    if (!idSet.has(node.id) || isLocked(node)) return node;
+    const previous = {};
+    if (node.draggable !== void 0) previous.draggable = node.draggable;
+    if (node.deletable !== void 0) previous.deletable = node.deletable;
+    return {
+      ...node,
+      draggable: false,
+      deletable: false,
+      data: { ...node.data, [LOCKED_DATA_KEY]: true, [LOCKED_PREVIOUS_FLAGS_KEY]: previous }
+    };
+  });
+}
+function unlockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  return nodes.map((node) => {
+    if (!idSet.has(node.id) || !isLocked(node)) return node;
+    const {
+      [LOCKED_DATA_KEY]: _locked,
+      [LOCKED_PREVIOUS_FLAGS_KEY]: previous = {},
+      ...data
+    } = node.data;
+    const next = { ...node, data };
+    delete next.draggable;
+    delete next.deletable;
+    if (previous.draggable !== void 0) next.draggable = previous.draggable;
+    if (previous.deletable !== void 0) next.deletable = previous.deletable;
+    return next;
+  });
+}
+function toggleLockNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  const anyUnlocked = nodes.some((n) => idSet.has(n.id) && !isLocked(n));
+  return anyUnlocked ? lockNodes(nodes, idSet) : unlockNodes(nodes, idSet);
+}
+function collect(nodes, ids, options) {
+  const lookup = createNodeLookup(nodes);
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    const node = lookup.get(id);
+    if (!node || seen.has(id)) continue;
+    seen.add(id);
+    items.push({ node, rect: getNodeRect(node, lookup, options), locked: isLocked(node) });
+  }
+  return { lookup, items };
+}
+function toPositionUpdates(lookup, targets) {
+  const updates = [];
+  for (const [id, abs] of targets) {
+    const node = lookup.get(id);
+    let position = abs;
+    if (node.parentId && lookup.has(node.parentId)) {
+      const parent = lookup.get(node.parentId);
+      const parentAbs = targets.get(parent.id) ?? getAbsolutePosition(parent, lookup);
+      position = { x: abs.x - parentAbs.x, y: abs.y - parentAbs.y };
+    }
+    if (position.x !== node.position.x || position.y !== node.position.y) {
+      updates.push({ id, position });
+    }
+  }
+  return updates;
+}
+function alignNodes(nodes, ids, edge, options = {}) {
+  const { lookup, items } = collect(nodes, ids, options);
+  const fixed = typeof options.to === "object" ? options.to : null;
+  if (items.length === 0 || !fixed && items.length < 2) return [];
+  const bounds = fixed ?? boundsOf(items.map((i) => i.rect));
+  const targets = /* @__PURE__ */ new Map();
+  for (const { node, rect, locked } of items) {
+    if (locked) continue;
+    let { x, y } = rect;
+    switch (edge) {
+      case "left":
+        x = bounds.x;
+        break;
+      case "center":
+        x = bounds.x + bounds.width / 2 - rect.width / 2;
+        break;
+      case "right":
+        x = bounds.x + bounds.width - rect.width;
+        break;
+      case "top":
+        y = bounds.y;
+        break;
+      case "middle":
+        y = bounds.y + bounds.height / 2 - rect.height / 2;
+        break;
+      case "bottom":
+        y = bounds.y + bounds.height - rect.height;
+        break;
+    }
+    targets.set(node.id, { x, y });
+  }
+  return toPositionUpdates(lookup, targets);
+}
+function distributeAxis(items, horizontal, mode, gapOverride, targets) {
+  const start = (r) => horizontal ? r.x : r.y;
+  const size = (r) => horizontal ? r.width : r.height;
+  const sorted = [...items].sort(
+    (a, b) => start(a.rect) + size(a.rect) / 2 - (start(b.rect) + size(b.rect) / 2)
+  );
+  const first = sorted[0].rect;
+  const last = sorted[sorted.length - 1].rect;
+  const n = sorted.length;
+  const set = (item, value) => {
+    if (item.locked) return;
+    const current = targets.get(item.node.id) ?? { x: item.rect.x, y: item.rect.y };
+    targets.set(item.node.id, horizontal ? { ...current, x: value } : { ...current, y: value });
+  };
+  if (mode === "centres") {
+    const c0 = start(first) + size(first) / 2;
+    const c1 = start(last) + size(last) / 2;
+    const step = (c1 - c0) / (n - 1);
+    sorted.forEach((item, i) => set(item, c0 + step * i - size(item.rect) / 2));
+    return;
+  }
+  const span = start(last) + size(last) - start(first);
+  const total = sorted.reduce((sum, item) => sum + size(item.rect), 0);
+  const gap = gapOverride ?? (span - total) / (n - 1);
+  let cursor = start(first);
+  for (const item of sorted) {
+    set(item, cursor);
+    cursor += size(item.rect) + gap;
+  }
+}
+function distributeNodes(nodes, ids, axis, mode = "gaps", options = {}) {
+  const { lookup, items } = collect(nodes, ids, options);
+  const minimum = options.gap !== void 0 && mode === "gaps" ? 2 : 3;
+  if (items.length < minimum) return [];
+  const targets = /* @__PURE__ */ new Map();
+  if (axis !== "vertical") distributeAxis(items, true, mode, options.gap, targets);
+  if (axis !== "horizontal") distributeAxis(items, false, mode, options.gap, targets);
+  return toPositionUpdates(lookup, targets);
+}
+function matchSize(nodes, ids, dimension, options = {}) {
+  const { items } = collect(nodes, ids, options);
+  if (items.length < 2) return [];
+  const reference = options.reference ?? "largest";
+  const pick = (dim) => {
+    if (typeof reference === "object") {
+      const item = items.find((i) => i.node.id === reference.id);
+      if (item) return item.rect[dim];
+    }
+    if (reference === "first") return items[0].rect[dim];
+    const values = items.map((i) => i.rect[dim]);
+    return reference === "smallest" ? Math.min(...values) : Math.max(...values);
+  };
+  const width = dimension !== "height" ? pick("width") : void 0;
+  const height = dimension !== "width" ? pick("height") : void 0;
+  const updates = [];
+  for (const { node, rect, locked } of items) {
+    if (locked) continue;
+    const update = { id: node.id };
+    if (width !== void 0 && width !== rect.width) update.width = width;
+    if (height !== void 0 && height !== rect.height) update.height = height;
+    if (update.width === void 0 && update.height === void 0) continue;
+    if (options.keepCentre) {
+      update.position = {
+        x: node.position.x - ((update.width ?? rect.width) - rect.width) / 2,
+        y: node.position.y - ((update.height ?? rect.height) - rect.height) / 2
+      };
+    }
+    updates.push(update);
+  }
+  return updates;
+}
+function reorderNodes(nodes, ids, operation, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const targetIds = new Set(
+    [...ids].filter((id) => lookup.has(id) && !isLocked(lookup.get(id)))
+  );
+  if (targetIds.size === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const key = node.parentId ?? "";
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(node);
+  }
+  const updates = [];
+  for (const siblings of groups.values()) {
+    if (!siblings.some((n) => targetIds.has(n.id))) continue;
+    const order = siblings.map((node, index) => ({ node, index, z: typeof node.zIndex === "number" ? node.zIndex : 0 })).sort((a, b) => a.z - b.z || a.index - b.index).map((entry) => entry.node);
+    const isTarget = (n) => targetIds.has(n.id);
+    let next;
+    if (operation === "bringToFront") {
+      next = [...order.filter((n) => !isTarget(n)), ...order.filter(isTarget)];
+    } else if (operation === "sendToBack") {
+      next = [...order.filter(isTarget), ...order.filter((n) => !isTarget(n))];
+    } else {
+      next = [...order];
+      const forward = operation === "bringForward";
+      const rects = new Map(next.map((n) => [n.id, getNodeRect(n, lookup, options)]));
+      const intersects = (a, b) => a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+      const indices = next.map((_, i) => i);
+      if (forward) indices.reverse();
+      for (const i of indices) {
+        const node = next[i];
+        if (!isTarget(node)) continue;
+        const step = forward ? 1 : -1;
+        let j = i + step;
+        let swapWith = -1;
+        let firstNonTarget = -1;
+        while (j >= 0 && j < next.length) {
+          if (!isTarget(next[j])) {
+            if (firstNonTarget === -1) firstNonTarget = j;
+            if (intersects(rects.get(node.id), rects.get(next[j].id))) {
+              swapWith = j;
+              break;
+            }
+          }
+          j += step;
+        }
+        if (swapWith === -1) swapWith = firstNonTarget;
+        if (swapWith === -1) continue;
+        next.splice(i, 1);
+        next.splice(swapWith, 0, node);
+      }
+    }
+    if (next.every((node, i) => node === order[i])) continue;
+    next.forEach((node, rank) => {
+      const current = typeof node.zIndex === "number" ? node.zIndex : 0;
+      if (current !== rank) updates.push({ id: node.id, zIndex: rank });
+    });
+  }
+  return updates;
+}
+function applyNodeUpdates(nodes, updates) {
+  if (updates.length === 0) return nodes;
+  const byId = /* @__PURE__ */ new Map();
+  for (const update of updates) {
+    byId.set(update.id, { ...byId.get(update.id), ...update });
+  }
+  return nodes.map((node) => {
+    const update = byId.get(node.id);
+    if (!update) return node;
+    const next = { ...node };
+    if (update.position) next.position = { ...update.position };
+    if (update.zIndex !== void 0) next.zIndex = update.zIndex;
+    if (update.width !== void 0 || update.height !== void 0) {
+      if (update.width !== void 0) next.width = update.width;
+      if (update.height !== void 0) next.height = update.height;
+      if (node.style) next.style = withStyleSize(node.style, update);
+      if (node.measured) {
+        next.measured = {
+          ...node.measured,
+          ...update.width !== void 0 ? { width: update.width } : {},
+          ...update.height !== void 0 ? { height: update.height } : {}
+        };
+      }
+    }
+    return next;
+  });
+}
+function invertNodeUpdates(nodes, updates) {
+  const lookup = createNodeLookup(nodes);
+  const inverse = [];
+  for (const update of updates) {
+    const node = lookup.get(update.id);
+    if (!node) continue;
+    const back = { id: node.id };
+    if (update.position) back.position = { ...node.position };
+    if (update.zIndex !== void 0) back.zIndex = typeof node.zIndex === "number" ? node.zIndex : 0;
+    if (update.width !== void 0 || update.height !== void 0) {
+      const size = getNodeSize(node);
+      if (update.width !== void 0) back.width = size.width;
+      if (update.height !== void 0) back.height = size.height;
+    }
+    inverse.push(back);
+  }
+  return inverse;
+}
+
+export {
+  DEFAULT_NODE_WIDTH,
+  DEFAULT_NODE_HEIGHT,
+  DEFAULT_PLACEMENT_GAP,
+  getCenteredNodePosition,
+  centerNodes,
+  getLayoutedNodes,
+  estimateNodeSize,
+  boundsOf,
+  centre,
+  overlaps,
+  flowSide,
+  ensureLayout,
+  placeBeside,
+  LOCKED_DATA_KEY,
+  LOCKED_PREVIOUS_FLAGS_KEY,
+  readStyleSize,
+  withStyleSize,
+  getNodeSize,
+  getAbsolutePosition,
+  createNodeLookup,
+  getNodeRect,
+  isLocked,
+  lockNodes,
+  unlockNodes,
+  toggleLockNodes,
+  alignNodes,
+  distributeNodes,
+  matchSize,
+  reorderNodes,
+  applyNodeUpdates,
+  invertNodeUpdates
+};

package/dist/{chunk-UMS6YFA6.js → chunk-EAQ4BGNS.js}

@@ -3,7 +3,7 @@ import {
   TOOL_BRIDGE_PROTOCOL,
   ToolRegistry,
   createMcpServer
-} from "./chunk-RB62U6MS.js";
+} from "./chunk-RFBFTLVN.js";
 
 // src/bridge/index.ts
 import { createServer } from "http";

package/dist/{chunk-AGCD3EHB.cjs → chunk-ENIZYNEF.cjs}

@@ -3,7 +3,7 @@
 
 
 
-var _chunkHDK3T2QScjs = require('./chunk-HDK3T2QS.cjs');
+var _chunkY4BWZB6Jcjs = require('./chunk-Y4BWZB6J.cjs');
 
 // src/bridge/index.ts
 var _http = require('http');
@@ -197,7 +197,7 @@ var SKILL_INSTRUCTIONS = "Each editor's tools are documented by an agent skill (
 async function createToolBridge(options) {
   const log = _nullishCoalesce(options.log, () => ( ((message) => process.stderr.write(`[${options.name}] ${message}
 `))));
-  const port = _nullishCoalesce(options.port, () => ( _chunkHDK3T2QScjs.TOOL_BRIDGE_DEFAULT_PORT));
+  const port = _nullishCoalesce(options.port, () => ( _chunkY4BWZB6Jcjs.TOOL_BRIDGE_DEFAULT_PORT));
   const retryMs = _nullishCoalesce(options.retryMs, () => ( 2e3));
   const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 6e4));
   const extraOrigins = new Set(_nullishCoalesce(options.origins, () => ( [])));
@@ -211,7 +211,7 @@ async function createToolBridge(options) {
   let closed = false;
   let retry;
   const send = (editor, message) => editor.socket.send(JSON.stringify(message));
-  const registry = new (0, _chunkHDK3T2QScjs.ToolRegistry)();
+  const registry = new (0, _chunkY4BWZB6Jcjs.ToolRegistry)();
   const listeners = /* @__PURE__ */ new Set();
   const toolsChanged = () => listeners.forEach((l) => l());
   const describeEditors = () => [...editors.values()].map((e) => `${e.id} (${e.name})`).join(", ");
@@ -319,13 +319,13 @@ async function createToolBridge(options) {
         return;
       }
       if (message.t === "hello") {
-        if (message.v !== _chunkHDK3T2QScjs.TOOL_BRIDGE_PROTOCOL) {
+        if (message.v !== _chunkY4BWZB6Jcjs.TOOL_BRIDGE_PROTOCOL) {
           log(`refused an editor speaking protocol v${String(message.v)}`);
-          return ws.close(1008, `This bridge speaks protocol v${_chunkHDK3T2QScjs.TOOL_BRIDGE_PROTOCOL}; update @pixerate/editor.`);
+          return ws.close(1008, `This bridge speaks protocol v${_chunkY4BWZB6Jcjs.TOOL_BRIDGE_PROTOCOL}; update @pixerate/editor.`);
         }
         editor = { id: `e${++editorCounter}`, name: String(message.name || "Editor"), ...message.kind ? { kind: message.kind } : {}, socket: ws, tools: Array.isArray(message.tools) ? message.tools : [], activeAt: Date.now(), activeSeq: ++activity };
         editors.set(editor.id, editor);
-        ws.send(JSON.stringify({ t: "welcome", v: _chunkHDK3T2QScjs.TOOL_BRIDGE_PROTOCOL, id: editor.id }));
+        ws.send(JSON.stringify({ t: "welcome", v: _chunkY4BWZB6Jcjs.TOOL_BRIDGE_PROTOCOL, id: editor.id }));
         log(`editor ${editor.id} connected: ${editor.name} (${editor.tools.length} tools)`);
         toolsChanged();
       } else if (message.t === "tools" && editor) {
@@ -381,7 +381,7 @@ async function createToolBridge(options) {
 `)]);
   const skills = options.skills === false ? {} : _nullishCoalesce(options.skills, () => ( loadSkillFiles()));
   const hasSkills = Object.keys(skills).length > 0;
-  const mcp = _chunkHDK3T2QScjs.createMcpServer.call(void 0, registry, {
+  const mcp = _chunkY4BWZB6Jcjs.createMcpServer.call(void 0, registry, {
     name: options.name,
     version: _nullishCoalesce(options.version, () => ( "0.1.0")),
     instructions: [options.instructions, BRIDGE_INSTRUCTIONS, hasSkills ? SKILL_INSTRUCTIONS : ""].filter(Boolean).join("\n\n"),