@pixerate/editor 0.9.0 → 0.11.0

package/dist/index.js

@@ -27,10 +27,10 @@ function tokenizePrompt(text) {
   while ((match = varRegex.exec(text)) !== null) {
     const start = match.index;
     const end = start + match[0].length;
-    const overlaps = rawMatches.some(
+    const overlaps2 = rawMatches.some(
       (m) => !(end <= m.start || start >= m.end)
     );
-    if (!overlaps) {
+    if (!overlaps2) {
       rawMatches.push({
         type: "variable",
         raw: match[0],
@@ -47,10 +47,10 @@ function tokenizePrompt(text) {
   while ((match = instRegex.exec(text)) !== null) {
     const start = match.index;
     const end = start + match[0].length;
-    const overlaps = rawMatches.some(
+    const overlaps2 = rawMatches.some(
       (m) => !(end <= m.start || start >= m.end)
     );
-    if (!overlaps) {
+    if (!overlaps2) {
       rawMatches.push({
         type: "instruction",
         raw: match[0],
@@ -4246,11 +4246,1218 @@ var HistoryManager = class {
 function createHistoryManager(options = {}) {
   return new HistoryManager(options);
 }
+
+// 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/clock.ts
+var pageHidden = () => typeof document !== "undefined" && document.hidden;
+var realClock = {
+  live: true,
+  now: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+  frame: () => new Promise((resolve) => {
+    if (typeof requestAnimationFrame === "function" && !pageHidden()) {
+      requestAnimationFrame(() => resolve());
+    } else {
+      setTimeout(resolve, 16);
+    }
+  }),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)))
+};
+var settle = () => new Promise((resolve) => setTimeout(resolve, 0));
+var ManualClock = class {
+  live = false;
+  time;
+  frames = [];
+  sleepers = [];
+  seq = 0;
+  constructor(start = 0) {
+    this.time = start;
+  }
+  now() {
+    return this.time;
+  }
+  frame() {
+    return new Promise((resolve) => this.frames.push(resolve));
+  }
+  sleep(ms) {
+    return new Promise(
+      (resolve) => this.sleepers.push({
+        at: this.time + Math.max(0, ms),
+        seq: this.seq++,
+        resolve
+      })
+    );
+  }
+  /** Whether any frames or sleep timers are currently pending. */
+  get pending() {
+    return this.frames.length > 0 || this.sleepers.length > 0;
+  }
+  /** Advances time by `ms`, resolving due sleep timers in order, followed by queued frames. */
+  async advance(ms) {
+    const end = this.time + Math.max(0, ms);
+    await settle();
+    while (true) {
+      let next;
+      for (const s of this.sleepers) {
+        if (s.at <= end && (!next || s.at < next.at || s.at === next.at && s.seq < next.seq)) {
+          next = s;
+        }
+      }
+      if (!next) break;
+      this.sleepers.splice(this.sleepers.indexOf(next), 1);
+      this.time = Math.max(this.time, next.at);
+      next.resolve();
+      await settle();
+    }
+    this.time = end;
+    const dueFrames = this.frames.splice(0, this.frames.length);
+    for (const resolveFrame of dueFrames) {
+      resolveFrame();
+    }
+    await settle();
+  }
+  /** Convenience method to advance by 1 frame at a given fps (default: 60fps = 16.67ms). */
+  async tick(fps = 60) {
+    await this.advance(Math.round(1e3 / fps));
+  }
+};
+
+// src/canvas/trajectory.ts
+var defaultEasing = (t) => --t * t * t + 1;
+var linearTrajectory = (origin, target, progress) => {
+  return {
+    position: {
+      x: origin.x + (target.x - origin.x) * progress,
+      y: origin.y + (target.y - origin.y) * progress
+    },
+    scale: progress,
+    opacity: Math.min(1, progress * 1.5)
+  };
+};
+var linearPositionTrajectory = (origin, target, progress) => {
+  return {
+    position: {
+      x: origin.x + (target.x - origin.x) * progress,
+      y: origin.y + (target.y - origin.y) * progress
+    }
+  };
+};
+function createFanOutTrajectory(options = {}) {
+  const {
+    curvature = 0.4,
+    startScale = 0,
+    endScale = 1,
+    startOpacity = 0,
+    endOpacity = 1
+  } = options;
+  return (origin, target, progress, index, total) => {
+    const dx = target.x - origin.x;
+    const dy = target.y - origin.y;
+    const normIndex = total > 1 ? (index - (total - 1) / 2) / ((total - 1) / 2) : 0;
+    const midX = origin.x + dx * 0.4;
+    const midY = origin.y + dy * 0.1 - normIndex * Math.abs(dx) * 0.15 * curvature;
+    const t = progress;
+    const oneMinusT = 1 - t;
+    const x = oneMinusT * oneMinusT * origin.x + 2 * oneMinusT * t * midX + t * t * target.x;
+    const y = oneMinusT * oneMinusT * origin.y + 2 * oneMinusT * t * midY + t * t * target.y;
+    const scale = startScale + (endScale - startScale) * progress;
+    const opacity = startOpacity + (endOpacity - startOpacity) * progress;
+    return {
+      position: { x, y },
+      scale,
+      opacity
+    };
+  };
+}
+function createBezierTrajectory(getControlPoint) {
+  return (origin, target, progress) => {
+    const cp = getControlPoint(origin, target);
+    const t = progress;
+    const oneMinusT = 1 - t;
+    const x = oneMinusT * oneMinusT * origin.x + 2 * oneMinusT * t * cp.x + t * t * target.x;
+    const y = oneMinusT * oneMinusT * origin.y + 2 * oneMinusT * t * cp.y + t * t * target.y;
+    return {
+      position: { x, y },
+      scale: progress,
+      opacity: progress
+    };
+  };
+}
+function runMultiNodeTransition(transitions, options = {}) {
+  if (transitions.length === 0) {
+    options.onComplete?.();
+    return () => {
+    };
+  }
+  const {
+    defaultDuration = 400,
+    defaultEasing: easingFunc = defaultEasing,
+    clock = realClock,
+    onUpdate,
+    onComplete
+  } = options;
+  let isCancelled = false;
+  const startTime = clock.now();
+  const items = transitions.map((tr, i) => ({
+    ...tr,
+    index: tr.index ?? i,
+    total: tr.total ?? transitions.length,
+    duration: tr.duration ?? defaultDuration,
+    easing: tr.easing ?? easingFunc,
+    delay: tr.delay ?? 0,
+    trajectory: tr.trajectory ?? linearTrajectory
+  }));
+  function frame() {
+    if (isCancelled) return;
+    const now = clock.now();
+    let allCompleted = true;
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const elapsed = now - (startTime + item.delay);
+      if (elapsed < 0) {
+        allCompleted = false;
+        continue;
+      }
+      const rawProgress = item.duration <= 0 ? 1 : Math.min(elapsed / item.duration, 1);
+      const progress = item.duration <= 0 ? 1 : item.easing(rawProgress);
+      const point = item.trajectory(item.from, item.to, progress, item.index, item.total);
+      item.node.position = { ...point.position };
+      if (point.scale !== void 0 || point.opacity !== void 0) {
+        if (!item.node.data) {
+          item.node.data = {};
+        }
+        if (point.scale !== void 0) {
+          item.node.data.scale = point.scale;
+        }
+        if (point.opacity !== void 0) {
+          item.node.data.opacity = point.opacity;
+          const currentStyle = (item.node.style || "").replace(/opacity:\s*[^;]+;?/g, "").trim();
+          item.node.style = `${currentStyle ? currentStyle + "; " : ""}opacity: ${point.opacity};`;
+        }
+      }
+      if (rawProgress < 1) {
+        allCompleted = false;
+      }
+    }
+    onUpdate?.();
+    if (!allCompleted) {
+      clock.frame().then(frame);
+    } else {
+      onComplete?.();
+    }
+  }
+  frame();
+  return () => {
+    isCancelled = true;
+  };
+}
+
+// src/canvas/displacement.ts
+import dagre2 from "@dagrejs/dagre";
+function computeNodesBoundingBox(nodes, defaultWidth = 200, defaultHeight = 60) {
+  if (nodes.length === 0) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const node of nodes) {
+    const width = node.measured?.width ?? node.width ?? defaultWidth;
+    const height = node.measured?.height ?? node.height ?? defaultHeight;
+    minX = Math.min(minX, node.position.x);
+    minY = Math.min(minY, node.position.y);
+    maxX = Math.max(maxX, node.position.x + width);
+    maxY = Math.max(maxY, node.position.y + height);
+  }
+  return {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+}
+function calculateDirectionalDisplacement(params) {
+  const {
+    existingNodes,
+    originNode,
+    childNodes: childNodes2,
+    getNodesBounds,
+    options = {}
+  } = params;
+  const {
+    direction = "right",
+    gap = 40,
+    spreadSiblingLanes = false,
+    siblingTolerance = 50,
+    minY
+  } = options;
+  const displacedMap = /* @__PURE__ */ new Map();
+  if (childNodes2.length === 0 || existingNodes.length === 0) {
+    return displacedMap;
+  }
+  const childBounds = getNodesBounds ? getNodesBounds(childNodes2) : computeNodesBoundingBox(childNodes2);
+  const originWidth = originNode.measured?.width ?? originNode.width ?? 200;
+  const originHeight = originNode.measured?.height ?? originNode.height ?? 60;
+  const deltaPrimary = direction === "right" || direction === "left" ? childBounds.width + gap : childBounds.height + gap;
+  const deltaUp = Math.max(0, originNode.position.y - childBounds.y + gap);
+  const deltaDown = Math.max(
+    0,
+    childBounds.y + childBounds.height - (originNode.position.y + originHeight) + gap
+  );
+  const equalDelta = Math.max(deltaUp, deltaDown);
+  for (const node of existingNodes) {
+    if (node.id === originNode.id) continue;
+    const isSiblingRow = Math.abs(node.position.y - originNode.position.y) < siblingTolerance;
+    switch (direction) {
+      case "right": {
+        if (node.position.x > originNode.position.x) {
+          displacedMap.set(node.id, {
+            x: node.position.x + deltaPrimary,
+            y: node.position.y
+          });
+        }
+        break;
+      }
+      case "left": {
+        if (node.position.x < originNode.position.x) {
+          displacedMap.set(node.id, {
+            x: node.position.x - deltaPrimary,
+            y: node.position.y
+          });
+        }
+        break;
+      }
+      case "down": {
+        if (node.position.y > originNode.position.y) {
+          displacedMap.set(node.id, {
+            x: node.position.x,
+            y: node.position.y + deltaPrimary
+          });
+        }
+        break;
+      }
+      case "up": {
+        if (node.position.y < originNode.position.y) {
+          displacedMap.set(node.id, {
+            x: node.position.x,
+            y: node.position.y - deltaPrimary
+          });
+        }
+        break;
+      }
+      case "vertical": {
+        if (isSiblingRow) break;
+        if (node.position.y < originNode.position.y) {
+          displacedMap.set(node.id, {
+            x: node.position.x,
+            y: node.position.y - equalDelta
+          });
+        } else if (node.position.y > originNode.position.y) {
+          displacedMap.set(node.id, {
+            x: node.position.x,
+            y: node.position.y + equalDelta
+          });
+        }
+        break;
+      }
+    }
+  }
+  if (spreadSiblingLanes && (direction === "right" || direction === "left")) {
+    for (const [nodeId, pos] of displacedMap.entries()) {
+      const node = existingNodes.find((n) => n.id === nodeId);
+      if (node && Math.abs(node.position.y - originNode.position.y) < siblingTolerance) {
+        const isAbove = node.position.y < originNode.position.y;
+        displacedMap.set(nodeId, {
+          x: pos.x,
+          y: pos.y + (isAbove ? -deltaUp : deltaDown)
+        });
+      }
+    }
+  }
+  if (minY !== void 0) {
+    for (const [nodeId, pos] of displacedMap.entries()) {
+      if (pos.y < minY) {
+        displacedMap.set(nodeId, { x: pos.x, y: minY });
+      }
+    }
+  }
+  return displacedMap;
+}
+function calculateDagreReflowDisplacement(params) {
+  const {
+    currentNodes,
+    futureNodes,
+    futureEdges,
+    options
+  } = params;
+  const {
+    anchorNodeId,
+    direction = "LR",
+    ranksep = 100,
+    nodesep = 25,
+    defaultNodeWidth = 200,
+    defaultNodeHeight = 60
+  } = options;
+  const anchorNode = currentNodes.find((n) => n.id === anchorNodeId);
+  if (!anchorNode) return /* @__PURE__ */ new Map();
+  const g = new dagre2.graphlib.Graph();
+  g.setDefaultEdgeLabel(() => ({}));
+  g.setGraph({ rankdir: direction, ranksep, nodesep });
+  const nodeIds = new Set(futureNodes.map((n) => n.id));
+  futureNodes.forEach((node) => {
+    const nodeWidth = node.measured?.width ?? node.width ?? defaultNodeWidth;
+    const nodeHeight = node.measured?.height ?? node.height ?? defaultNodeHeight;
+    g.setNode(node.id, { width: nodeWidth, height: nodeHeight });
+  });
+  futureEdges.forEach((edge) => {
+    if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+      g.setEdge(edge.source, edge.target);
+    }
+  });
+  dagre2.layout(g);
+  const anchorLayoutPos = g.node(anchorNodeId);
+  if (!anchorLayoutPos) return /* @__PURE__ */ new Map();
+  const anchorWidth = anchorNode.measured?.width ?? anchorNode.width ?? defaultNodeWidth;
+  const anchorHeight = anchorNode.measured?.height ?? anchorNode.height ?? defaultNodeHeight;
+  const anchorLayoutUpperLeft = {
+    x: anchorLayoutPos.x - anchorWidth / 2,
+    y: anchorLayoutPos.y - anchorHeight / 2
+  };
+  const deltaX = anchorNode.position.x - anchorLayoutUpperLeft.x;
+  const deltaY = anchorNode.position.y - anchorLayoutUpperLeft.y;
+  const displacementMap = /* @__PURE__ */ new Map();
+  currentNodes.forEach((node) => {
+    if (node.id === anchorNodeId) return;
+    const layoutNode = g.node(node.id);
+    if (!layoutNode) return;
+    const nodeWidth = node.measured?.width ?? node.width ?? defaultNodeWidth;
+    const nodeHeight = node.measured?.height ?? node.height ?? defaultNodeHeight;
+    const upperLeftX = layoutNode.x - nodeWidth / 2 + deltaX;
+    const upperLeftY = layoutNode.y - nodeHeight / 2 + deltaY;
+    if (Math.abs(upperLeftX - node.position.x) > 1 || Math.abs(upperLeftY - node.position.y) > 1) {
+      displacementMap.set(node.id, { x: upperLeftX, y: upperLeftY });
+    }
+  });
+  return displacementMap;
+}
+
+// src/canvas/clipboard.ts
+function isEventFromTextInput(event) {
+  const target = event.target;
+  if (!target) return false;
+  if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT" || target.isContentEditable || target.closest?.('[contenteditable="true"]') || target.closest?.(".ProseMirror")) {
+    return true;
+  }
+  return false;
+}
+function isValidCanvasNode(obj) {
+  return typeof obj === "object" && obj !== null && "id" in obj && typeof obj.id === "string" && "position" in obj && typeof obj.position === "object" && obj.position !== null && "x" in obj.position && "y" in obj.position;
+}
+function isValidUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function serializeCanvasNodes(nodes, edges) {
+  const payload = {
+    version: 1,
+    nodes,
+    edges
+  };
+  return JSON.stringify(payload);
+}
+function parseCanvasClipboardData(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.nodes) && parsed.nodes.length > 0 && parsed.nodes.every(isValidCanvasNode)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function remapPastedNodes(nodes, edges = [], offset = { x: 30, y: 30 }, idGenerator = () => `node-${Math.random().toString(36).substring(2, 9)}`) {
+  const idMap = /* @__PURE__ */ new Map();
+  const newNodes = nodes.map((node) => {
+    const newId = idGenerator();
+    idMap.set(node.id, newId);
+    return {
+      ...node,
+      id: newId,
+      position: {
+        x: node.position.x + offset.x,
+        y: node.position.y + offset.y
+      },
+      selected: true
+    };
+  });
+  const newEdges = edges.filter((e) => idMap.has(e.source) && idMap.has(e.target)).map((edge) => ({
+    ...edge,
+    id: `edge-${Math.random().toString(36).substring(2, 9)}`,
+    source: idMap.get(edge.source),
+    target: idMap.get(edge.target),
+    selected: false
+  }));
+  return { nodes: newNodes, edges: newEdges };
+}
+function repositionNodesTo(nodes, targetOrigin) {
+  if (nodes.length === 0) return [];
+  const minX = Math.min(...nodes.map((n) => n.position.x));
+  const minY = Math.min(...nodes.map((n) => n.position.y));
+  const deltaX = targetOrigin.x - minX;
+  const deltaY = targetOrigin.y - minY;
+  return nodes.map((n) => ({
+    ...n,
+    position: {
+      x: n.position.x + deltaX,
+      y: n.position.y + deltaY
+    }
+  }));
+}
+
+// src/canvas/view.ts
+function clampHeight(contentHeight, options = {}) {
+  const { min = 320, max = 560, padding = 48 } = options;
+  return Math.round(Math.min(max, Math.max(min, contentHeight + padding)));
+}
+function layoutBounds(nodes) {
+  if (nodes.length === 0) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const node of nodes) {
+    const x = node.position.x;
+    const y = node.position.y;
+    const width = node.width ?? 180;
+    const height = node.height ?? 80;
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x + width);
+    maxY = Math.max(maxY, y + height);
+  }
+  if (minX === Infinity) return null;
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function canvasHeight(nodes, options) {
+  return clampHeight(layoutBounds(nodes)?.height ?? 0, options);
+}
+var DEFAULT_RANK_HEIGHT = 80 + 72;
+var NODES_PER_RANK = 2;
+function estimateCanvasHeight(nodes, edges, options) {
+  const ranks = Math.max(1, Math.ceil(nodes.length / NODES_PER_RANK));
+  return clampHeight(ranks * DEFAULT_RANK_HEIGHT, options);
+}
+function mix(a, b, t) {
+  return a + (b - a) * t;
+}
+function blendLayout(from, to, t) {
+  if (t >= 1) return to;
+  const fromMap = new Map(from.map((n) => [n.id, n]));
+  return to.map((target) => {
+    const origin = fromMap.get(target.id);
+    if (!origin) return target;
+    return {
+      ...target,
+      position: {
+        x: mix(origin.position.x, target.position.x, t),
+        y: mix(origin.position.y, target.position.y, t)
+      },
+      width: origin.width !== void 0 && target.width !== void 0 ? mix(origin.width, target.width, t) : target.width,
+      height: origin.height !== void 0 && target.height !== void 0 ? mix(origin.height, target.height, t) : target.height
+    };
+  });
+}
+function connectedOnly(nodes, edges) {
+  if (edges.length === 0) return nodes;
+  const linkedNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    linkedNodeIds.add(edge.source);
+    linkedNodeIds.add(edge.target);
+  }
+  const filtered = nodes.filter((node) => linkedNodeIds.has(node.id));
+  return filtered.length > 0 ? filtered : nodes;
+}
+
+// src/canvas/streaming.ts
+var StreamingLayoutManager = class {
+  throttleMs;
+  glideDurationMs;
+  connectedOnly;
+  clock;
+  layoutOptions;
+  onLayoutUpdated;
+  pendingTimer = null;
+  activeTransitionCancel = null;
+  targetPositions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.throttleMs = options.throttleMs ?? 200;
+    this.glideDurationMs = options.glideDurationMs ?? 300;
+    this.connectedOnly = options.connectedOnly ?? false;
+    this.clock = options.clock ?? realClock;
+    this.layoutOptions = options.layoutOptions ?? { direction: "LR" };
+    this.onLayoutUpdated = options.onLayoutUpdated;
+  }
+  /**
+   * Feed incoming nodes and edges into the streaming manager.
+   * Coalesces rapid streaming bursts and triggers smooth layout gliding.
+   */
+  pushStreamUpdate(nodes, edges, currentPositions) {
+    if (this.pendingTimer) {
+      clearTimeout(this.pendingTimer);
+    }
+    this.pendingTimer = setTimeout(() => {
+      this.pendingTimer = null;
+      this.recalculateAndGlide(nodes, edges, currentPositions);
+    }, this.throttleMs);
+  }
+  /**
+   * Forces immediate calculation and cancels pending throttled timers.
+   */
+  flush(nodes, edges, currentPositions) {
+    if (this.pendingTimer) {
+      clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+    this.recalculateAndGlide(nodes, edges, currentPositions);
+  }
+  recalculateAndGlide(nodes, edges, currentPositions) {
+    const targetNodes = this.connectedOnly ? connectedOnly(nodes, edges) : nodes;
+    if (targetNodes.length === 0) return;
+    if (this.activeTransitionCancel) {
+      this.activeTransitionCancel();
+      this.activeTransitionCancel = null;
+    }
+    const stored = {};
+    for (const [id, pos] of currentPositions.entries()) {
+      stored[id] = pos;
+    }
+    const layouted = ensureLayout(targetNodes, edges, {
+      ...this.layoutOptions,
+      storedPositions: stored
+    });
+    const nextPositions = /* @__PURE__ */ new Map();
+    const transitions = [];
+    for (const node of layouted) {
+      const target = node.position;
+      nextPositions.set(node.id, target);
+      const current = currentPositions.get(node.id) ?? target;
+      const distance = Math.hypot(target.x - current.x, target.y - current.y);
+      if (distance > 2) {
+        transitions.push({
+          node,
+          from: current,
+          to: target,
+          trajectory: linearPositionTrajectory,
+          duration: this.glideDurationMs
+        });
+      }
+    }
+    this.targetPositions = nextPositions;
+    if (transitions.length > 0) {
+      this.activeTransitionCancel = runMultiNodeTransition(transitions, {
+        clock: this.clock,
+        onUpdate: () => {
+          const liveMap = new Map(currentPositions);
+          for (const trans of transitions) {
+            liveMap.set(trans.node.id, { ...trans.node.position });
+          }
+          this.onLayoutUpdated?.(liveMap);
+        },
+        onComplete: () => {
+          this.activeTransitionCancel = null;
+          this.onLayoutUpdated?.(nextPositions);
+        }
+      });
+    } else {
+      this.onLayoutUpdated?.(nextPositions);
+    }
+  }
+  destroy() {
+    if (this.pendingTimer) {
+      clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+    if (this.activeTransitionCancel) {
+      this.activeTransitionCancel();
+      this.activeTransitionCancel = null;
+    }
+  }
+};
+
+// src/agent/planner.ts
+function planAgentCommand(command, snapshot, options = {}) {
+  const defaultNodeSize = options.defaultNodeSize ?? { width: 200, height: 60 };
+  const idGen = options.idGenerator ?? (() => `node-${Math.random().toString(36).substring(2, 9)}`);
+  const edgeIdGen = () => `edge-${Math.random().toString(36).substring(2, 9)}`;
+  const nodes = snapshot.canvas?.nodes ?? [];
+  const edges = snapshot.canvas?.edges ?? [];
+  switch (command.type) {
+    case "canvas:add_node": {
+      let pos = command.node.position;
+      if (!pos) {
+        if (command.nearNodeId) {
+          const rects = {};
+          for (const n of nodes) {
+            rects[n.id] = {
+              x: n.position.x,
+              y: n.position.y,
+              width: n.measured?.width ?? n.width ?? defaultNodeSize.width,
+              height: n.measured?.height ?? n.height ?? defaultNodeSize.height
+            };
+          }
+          pos = placeBeside(
+            rects,
+            defaultNodeSize,
+            command.side ?? "right",
+            command.nearNodeId
+          );
+        } else if (nodes.length > 0) {
+          const lastNode = nodes[nodes.length - 1];
+          const rects = {};
+          for (const n of nodes) {
+            rects[n.id] = {
+              x: n.position.x,
+              y: n.position.y,
+              width: n.measured?.width ?? n.width ?? defaultNodeSize.width,
+              height: n.measured?.height ?? n.height ?? defaultNodeSize.height
+            };
+          }
+          pos = placeBeside(rects, defaultNodeSize, "right", lastNode.id);
+        } else {
+          pos = { x: 100, y: 100 };
+        }
+      }
+      const fullNode = {
+        ...command.node,
+        id: command.node.id || idGen(),
+        position: pos
+      };
+      const steps = [
+        {
+          type: "step:canvas_add_node",
+          node: fullNode
+        }
+      ];
+      if (command.nearNodeId) {
+        steps.push({
+          type: "step:canvas_add_edge",
+          edge: {
+            id: edgeIdGen(),
+            source: command.nearNodeId,
+            target: fullNode.id
+          }
+        });
+      }
+      return steps;
+    }
+    case "canvas:remove_nodes": {
+      return [
+        {
+          type: "step:canvas_remove_nodes",
+          nodeIds: command.nodeIds
+        }
+      ];
+    }
+    case "canvas:connect": {
+      return [
+        {
+          type: "step:canvas_add_edge",
+          edge: {
+            id: edgeIdGen(),
+            source: command.source,
+            target: command.target,
+            label: command.label
+          }
+        }
+      ];
+    }
+    case "canvas:update_node": {
+      return [
+        {
+          type: "step:canvas_update_node",
+          id: command.id,
+          data: command.data
+        }
+      ];
+    }
+    case "canvas:layout": {
+      const dir = command.direction ?? "LR";
+      let layouted;
+      if (command.incremental) {
+        const stored = {};
+        for (const n of nodes) {
+          if (n.position && (n.position.x !== 0 || n.position.y !== 0)) {
+            stored[n.id] = { ...n.position };
+          }
+        }
+        layouted = ensureLayout(nodes, edges, {
+          direction: dir,
+          storedPositions: stored
+        });
+      } else {
+        layouted = getLayoutedNodes(nodes, edges, void 0, { direction: dir });
+      }
+      const positions = {};
+      for (const node of layouted) {
+        positions[node.id] = { ...node.position };
+      }
+      return [
+        {
+          type: "step:canvas_move_nodes",
+          positions
+        }
+      ];
+    }
+    case "canvas:select": {
+      return [
+        {
+          type: "step:canvas_select",
+          nodeIds: command.nodeIds
+        }
+      ];
+    }
+    case "canvas:highlight": {
+      return [
+        {
+          type: "step:canvas_highlight",
+          nodeIds: command.nodeIds,
+          color: command.color ?? "#3b82f6",
+          durationMs: command.durationMs ?? 2e3
+        }
+      ];
+    }
+    case "prompt:insert_text": {
+      return [
+        {
+          type: "step:prompt_insert",
+          text: command.text,
+          at: command.at
+        }
+      ];
+    }
+    case "prompt:replace_range": {
+      return [
+        {
+          type: "step:prompt_replace",
+          from: command.from,
+          to: command.to,
+          text: command.text
+        }
+      ];
+    }
+    case "prompt:set_variable": {
+      return [
+        {
+          type: "step:prompt_set_variable",
+          name: command.name,
+          value: command.value
+        }
+      ];
+    }
+    case "prompt:select": {
+      return [
+        {
+          type: "step:prompt_select",
+          from: command.from,
+          to: command.to
+        }
+      ];
+    }
+    case "choreography:say": {
+      return [
+        {
+          type: "step:say",
+          text: command.text,
+          atNodeId: command.atNodeId,
+          position: command.position
+        }
+      ];
+    }
+    case "choreography:wait": {
+      return [
+        {
+          type: "step:wait",
+          ms: command.ms
+        }
+      ];
+    }
+    default: {
+      return [];
+    }
+  }
+}
+
+// src/agent/tools.ts
+var MCP_TOOL_GET_EDITOR_STATE = {
+  name: "get_editor_state",
+  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",
+  description: "Applies high-level structural operations to the visual canvas (adding nodes, connecting edges, organizing layout, or moving elements).",
+  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."
+      },
+      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",
+  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: "number",
+        description: "Position to insert text at."
+      },
+      from: {
+        type: "number",
+        description: "Start offset for replace_range or select."
+      },
+      to: {
+        type: "number",
+        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",
+  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 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
+];
 export {
   ColorHighlighter,
+  DEFAULT_NODE_HEIGHT,
+  DEFAULT_NODE_WIDTH,
+  DEFAULT_PLACEMENT_GAP,
   DataSourceBinder,
   DependencyGraph,
   DirtyTracker,
+  EDITOR_MCP_TOOLS,
+  EXPORT_EXCLUDED_SELECTORS,
   EditorController,
   FontSize,
   FormulaEvaluator,
@@ -4261,23 +5468,44 @@ export {
   Image2 as Image,
   LoadingNode,
   MARKDOWN_MENTION_SPLIT_REGEX,
+  MCP_TOOL_EDIT_CANVAS,
+  MCP_TOOL_EDIT_PROMPT,
+  MCP_TOOL_GET_EDITOR_STATE,
+  MCP_TOOL_VIEW_EDITOR,
   MENTION_REGEX,
+  ManualClock,
   Markdown2 as Markdown,
   Mention,
   SlashCommands,
   SmilieReplacer,
   SpreadsheetController,
+  StreamingLayoutManager,
   TEMPLATE_REGEX,
   TemplateSuggestions,
   VARIABLE_REGEX,
+  blendLayout,
+  boundsOf,
+  calculateDagreReflowDisplacement,
+  calculateDirectionalDisplacement,
+  canvasHeight,
+  centerNodes,
+  centre,
   colNameToIndex,
+  computeNodesBoundingBox,
+  connectedOnly,
+  createBezierTrajectory,
   createDirtyTracker,
   createEditor,
+  createFanOutTrajectory,
   createHistoryManager,
   createMentionExtension,
   createRichTextPreset,
+  defaultEasing,
   defaultIsEqual,
+  ensureLayout,
   escapeHtml,
+  estimateCanvasHeight,
+  estimateNodeSize,
   extractCellDependencies,
   extractInstructionNames,
   extractMentions,
@@ -4285,29 +5513,48 @@ export {
   extractTemplateNames,
   extractVariableNames,
   findHexColors,
+  flowSide,
+  getCenteredNodePosition,
   getEditorMarkdown,
   getEditorText,
   getLatestVersion,
+  getLayoutedNodes,
   handleImageInsertion,
   htmlToPlainText,
   imagePastePluginKey,
   indexToColName,
   insertImageNode,
   instructionRegex,
+  isEventFromTextInput,
+  isValidCanvasNode,
+  isValidUrl,
+  layoutBounds,
+  linearPositionTrajectory,
+  linearTrajectory,
   mapRawOffsetToResolved,
   mapResolvedOffsetToRaw,
   markdownToTipTapHtml,
+  overlaps,
+  pageHidden,
+  parseCanvasClipboardData,
   parseCellReference,
   parseFormula,
   parseMentionSegments,
   parseRange,
+  placeBeside,
   plainTextToTipTapHtml,
+  planAgentCommand,
   preprocessMarkdownFileLinks,
   preprocessMarkdownMentions,
+  realClock,
+  remapPastedNodes,
   removeImageNode,
+  repositionNodesTo,
   resolveTemplates,
   resolveTemplatesWithMapping,
   resolveVariables,
+  runMultiNodeTransition,
+  serializeCanvasNodes,
   stripMarkdownCode,
   templateRegex,
   tokenizeFormula,