@pixerate/editor 0.53.0 → 0.54.0

package/dist/diagram/index.js

@@ -0,0 +1,1146 @@
+import {
+  HistoryManager
+} from "../chunk-QVZZGT4X.js";
+import {
+  PRESENCE_COLORS,
+  PerformanceQueue,
+  PresenceStore,
+  createInstantPresenceClock,
+  realPresenceClock,
+  tweenPresenceCursor
+} from "../chunk-B6DSIEXA.js";
+import {
+  CLASS_RELATIONS,
+  ER_CARDINALITIES,
+  ER_PATTERNS,
+  FLOWCHART_SHAPES,
+  META_COMMENT_PREFIX,
+  META_FRONTMATTER_KEY,
+  STATE_SHAPES,
+  applyEdit,
+  applyEdits,
+  canonicalShape,
+  classGrammar,
+  createLineAdapter,
+  createPassthroughAdapter,
+  detectFamily,
+  detectFamilyFromHeader,
+  emptyMeta,
+  erGrammar,
+  flowchartAdapter,
+  formatChain,
+  formatLink,
+  formatNode,
+  getDiagramAdapter,
+  isMetaEmpty,
+  mergeMeta,
+  parseAttributes,
+  parseChain,
+  parseFlowchartSource,
+  parseLink,
+  parseMembers,
+  parseMermaid,
+  parseStatement,
+  quoteLabelIfNeeded,
+  registerDiagramAdapter,
+  relationFor,
+  resolveShape,
+  serializeMermaid,
+  serializeMeta,
+  splitSource,
+  splitStatements,
+  stateGrammar,
+  supportTierOf
+} from "../chunk-WWJNC7SX.js";
+
+// src/diagram/types.ts
+var DIRECTIONS = ["TB", "TD", "BT", "LR", "RL"];
+
+// src/diagram/source/find.ts
+var MERMAID_INFO = /^(mermaid|mmd)\b/i;
+function findMermaidSources(text) {
+  const clean = text.replace(/^\uFEFF/, "");
+  const blocks = fencedBlocks(clean);
+  if (blocks.length) {
+    const found = [];
+    for (const block of blocks) {
+      if (block.info && !MERMAID_INFO.test(block.info)) continue;
+      const item = asDiagram(block.body, block.heading, !block.info);
+      if (item) found.push(item);
+    }
+    if (found.length) return found;
+  }
+  const whole = asDiagram(clean.trim(), void 0, true);
+  return whole ? [whole] : [];
+}
+function asDiagram(source, heading, strict = false) {
+  if (!source.trim()) return void 0;
+  const split = splitSource(source);
+  const family = detectFamilyFromHeader(split.header);
+  if (family === "unknown") return void 0;
+  if (strict && !/^\s*([a-z]|C4)/.test(split.header)) return void 0;
+  const fmTitle = split.preamble.frontmatter?.title;
+  const title = typeof fmTitle === "string" && fmTitle.trim() ? fmTitle.trim() : heading;
+  return { source: source.trimEnd() + "\n", family, ...title ? { title } : {} };
+}
+function fencedBlocks(text) {
+  const lines = text.split(/\r\n|\n/);
+  const blocks = [];
+  let heading;
+  for (let i = 0; i < lines.length; i++) {
+    const open = /^ {0,3}(`{3,}(?!`)|~{3,}(?!~))([^`]*)$/.exec(lines[i]);
+    if (!open) {
+      const h = headingText(lines[i]);
+      if (h) heading = h;
+      continue;
+    }
+    const fence = open[1];
+    const close = new RegExp(`^ {0,3}${fence[0] === "`" ? "`" : "~"}{${fence.length},}$`);
+    const body = [];
+    let j = i + 1;
+    while (j < lines.length && !close.test(lines[j].trimEnd())) body.push(lines[j++]);
+    blocks.push({ info: open[2].trim(), body: body.join("\n"), heading });
+    i = j;
+  }
+  return blocks;
+}
+function headingText(line) {
+  const m = /^ {0,3}#{1,6}([ \t].*)$/.exec(line);
+  if (!m) return void 0;
+  let text = m[1].trim();
+  let end = text.length;
+  while (end > 0 && text[end - 1] === "#") end--;
+  if (end === 0 || text[end - 1] === " " || text[end - 1] === "	") text = text.slice(0, end).trim();
+  return text || void 0;
+}
+
+// src/diagram/controller.ts
+var EDITABLE_DIAGRAM_FAMILIES = ["flowchart", "state", "class", "er"];
+function diagramShapes(family) {
+  if (family === "flowchart") return FLOWCHART_SHAPES.map((shape) => shape.name);
+  if (family === "state") return STATE_SHAPES.map((shape) => shape.name);
+  return [];
+}
+function diagramSupportsGroups(family) {
+  return family === "flowchart" || family === "state" || family === "class";
+}
+var quote = (ids) => [...ids].map((id) => `"${id}"`).join(", ");
+function validateDiagramEdit(doc, op) {
+  const { graph, family } = doc;
+  if (op.type === "replaceSource") return null;
+  if (doc.tier !== "editable")
+    return `This ${family} diagram can only be edited as Mermaid text; replace the source instead.`;
+  const nodes = new Set(graph.nodes.map((n) => n.id));
+  const groups = new Set(graph.groups.map((g) => g.id));
+  const edges = new Set(graph.edges.map((e) => e.id));
+  const anyIds = () => nodes.size ? `existing node ids are ${quote([...nodes].slice(0, 20))}` : "the diagram has no nodes yet";
+  const node = (id, allowGroup = false) => nodes.has(id) || allowGroup && groups.has(id) ? null : `There is no node "${id}"; ${anyIds()}.`;
+  const group = (id) => id === void 0 || groups.has(id) ? null : `There is no group "${id}"; ${groups.size ? `existing groups are ${quote(groups)}` : "the diagram has no groups"}.`;
+  const edge = (id) => edges.has(id) ? null : `There is no edge "${id}"; ${edges.size ? `existing edge ids are ${quote([...edges].slice(0, 20))}` : "the diagram has no edges yet"}.`;
+  const shape = (name) => {
+    if (name === void 0) return null;
+    const shapes = diagramShapes(family);
+    if (!shapes.length) return `Nodes of a ${family} diagram have no shapes to choose from.`;
+    return shapes.includes(name) ? null : `Unknown shape "${name}"; use one of ${quote(shapes)}.`;
+  };
+  const free = (id) => !/^[A-Za-z0-9_][\w.-]*$/.test(id) ? `Id "${id}" is not a valid Mermaid id; use letters, digits, "_", "-" or ".".` : nodes.has(id) || groups.has(id) ? `Id "${id}" is already used; choose another.` : null;
+  const first = (...problems) => problems.find((p) => p) ?? null;
+  switch (op.type) {
+    case "addNode":
+      return first(free(op.node.id), shape(op.node.shape), group(op.node.parentId));
+    case "removeNodes":
+      return first(...op.ids.map((id) => node(id, true)));
+    case "renameNode":
+      return node(op.id, true);
+    case "setNodeShape":
+      return first(node(op.id), shape(op.shape));
+    case "setNodeClasses":
+    case "setNodeStyles":
+    case "setNodeLink":
+    case "setNodeData":
+    case "resizeNode":
+      return node(op.id, true);
+    case "moveNodes":
+      return first(...op.moves.map((m) => node(m.id, true)));
+    case "addEdge":
+      return first(node(op.edge.source, true), node(op.edge.target, true));
+    case "removeEdges":
+      return first(...op.ids.map(edge));
+    case "setEdgeLabel":
+    case "setEdgeStyle":
+    case "setEdgeData":
+      return edge(op.id);
+    case "reconnectEdge":
+      return first(edge(op.id), node(op.source, true), node(op.target, true));
+    case "groupNodes":
+      if (!diagramSupportsGroups(family)) return `${family} diagrams have no groups.`;
+      return first(free(op.groupId), ...op.nodeIds.map((id) => node(id, true)), group(op.parentId));
+    case "ungroup":
+      return group(op.groupId);
+    case "renameGroup":
+    case "setGroupDirection":
+      return group(op.id);
+    case "setNodeParent":
+      return first(...op.ids.map((id) => node(id, true)), group(op.parentId));
+    case "setDirection":
+      return DIRECTIONS.includes(op.direction) ? null : `Unknown direction "${op.direction}"; use one of ${quote(DIRECTIONS)}.`;
+    default:
+      return null;
+  }
+}
+var DiagramController = class {
+  history;
+  doc;
+  selection = [];
+  issue = null;
+  readOnly;
+  revision = 0;
+  applying = false;
+  gestureKey = null;
+  gestureCount = 0;
+  onChange;
+  listeners = /* @__PURE__ */ new Set();
+  unsubscribeHistory;
+  state;
+  constructor(options = {}) {
+    this.history = options.history ?? new HistoryManager();
+    this.onChange = options.onChange;
+    this.readOnly = options.readOnly ?? false;
+    this.doc = parseMermaid(options.source ?? "flowchart TD\n");
+    this.state = this.computeState();
+    this.connect();
+  }
+  connect() {
+    this.unsubscribeHistory?.();
+    this.unsubscribeHistory = this.history.subscribe((h) => {
+      const s = this.state;
+      if (this.applying || s.canUndo === h.canUndo && s.canRedo === h.canRedo && s.undoLabel === h.undoName && s.redoLabel === h.redoName) return;
+      this.notify(false);
+    });
+  }
+  /** Stops listening to the history (subscribing again reconnects). */
+  destroy() {
+    this.unsubscribeHistory?.();
+    this.unsubscribeHistory = void 0;
+  }
+  /** The current snapshot (stable until the next change). */
+  getState = () => this.state;
+  /** Calls `listener` after every change. Returns an unsubscribe function. */
+  subscribe = (listener) => {
+    if (!this.unsubscribeHistory) this.connect();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** The current document (immutable; edit through the controller). */
+  getDocument() {
+    return this.doc;
+  }
+  getSource() {
+    return this.doc.source;
+  }
+  computeState() {
+    const h = this.history.getState();
+    return {
+      document: this.doc,
+      source: this.doc.source,
+      family: this.doc.family,
+      editable: this.doc.tier === "editable" && !this.readOnly,
+      readOnly: this.readOnly,
+      selection: this.selection,
+      issue: this.issue,
+      canUndo: h.canUndo,
+      canRedo: h.canRedo,
+      undoLabel: h.undoName,
+      redoLabel: h.redoName,
+      revision: this.revision
+    };
+  }
+  notify(sourceChanged) {
+    this.revision++;
+    this.state = this.computeState();
+    if (sourceChanged) this.onChange?.(this.doc.source, this.doc);
+    const state = this.state;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[DiagramController] Error in state listener:", error);
+      }
+    });
+  }
+  setDocument(doc) {
+    this.applying = true;
+    try {
+      this.doc = doc;
+      const ids = new Set([...doc.graph.nodes, ...doc.graph.groups, ...doc.graph.edges].map((x) => x.id));
+      this.selection = this.selection.filter((id) => ids.has(id));
+    } finally {
+      this.applying = false;
+    }
+    this.notify(true);
+  }
+  commit(label, next) {
+    const before = this.doc;
+    this.issue = null;
+    if (next.source === before.source) {
+      this.notify(false);
+      return;
+    }
+    const command = {
+      name: label,
+      tag: "diagram",
+      execute: () => this.setDocument(next),
+      undo: () => this.setDocument(before),
+      redo: () => this.setDocument(next),
+      byteSize: (before.source.length + next.source.length) * 2
+    };
+    if (this.gestureKey !== null) this.history.executeMerged(command, { key: `diagram.gesture:${this.gestureKey}:${this.gestureCount}` });
+    else this.history.execute(command);
+  }
+  reject(message) {
+    this.issue = message;
+    this.notify(false);
+    return { ok: false, message };
+  }
+  /**
+   * Applies edits as one undo step. All-or-nothing: every edit is checked against the
+   * document as it stands after the edits before it, and nothing changes when one fails.
+   */
+  apply(ops, label = "Edit diagram") {
+    const list = Array.isArray(ops) ? ops : [ops];
+    if (this.readOnly) return this.reject("The diagram is read-only.");
+    let doc = this.doc;
+    for (const op of list) {
+      const problem = validateDiagramEdit(doc, op);
+      if (problem) return this.reject(problem);
+      doc = applyEdits(doc, [op]);
+    }
+    this.commit(label, doc);
+    return { ok: true, document: this.doc };
+  }
+  /**
+   * Replaces the whole source. `clearHistory` drops the undo stack (opening a file);
+   * otherwise the replacement is one undo step.
+   */
+  load(source, options = {}) {
+    const next = parseMermaid(source, { metaCarrier: this.doc.metaCarrier });
+    if (options.clearHistory) {
+      this.history.clear();
+      this.issue = null;
+      this.selection = [];
+      this.setDocument(next);
+      return { ok: true, document: next };
+    }
+    if (this.readOnly) return this.reject("The diagram is read-only.");
+    this.commit("Replace diagram", next);
+    return { ok: true, document: this.doc };
+  }
+  setReadOnly(readOnly) {
+    if (this.readOnly === readOnly) return;
+    this.readOnly = readOnly;
+    this.notify(false);
+  }
+  /** Selects node, group or edge ids (unknown ids are dropped). */
+  select(ids) {
+    const known = new Set([...this.doc.graph.nodes, ...this.doc.graph.groups, ...this.doc.graph.edges].map((x) => x.id));
+    const next = ids.filter((id) => known.has(id));
+    if (next.length === this.selection.length && next.every((id, i) => id === this.selection[i])) return;
+    this.selection = next;
+    this.notify(false);
+  }
+  /** Edits until `endGesture` (e.g. the moves of one drag) fold into one undo step. */
+  beginGesture(key) {
+    this.gestureKey = key;
+    this.gestureCount++;
+  }
+  endGesture() {
+    this.gestureKey = null;
+  }
+  undo() {
+    return this.history.undo();
+  }
+  redo() {
+    return this.history.redo();
+  }
+  /** A node id not used by any node or group: `prefix` followed by the next free number. */
+  nextId(prefix = "N") {
+    const used = new Set([...this.doc.graph.nodes, ...this.doc.graph.groups].map((x) => x.id));
+    let i = 1;
+    while (used.has(`${prefix}${i}`)) i++;
+    return `${prefix}${i}`;
+  }
+};
+
+// src/diagram/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var ID = { type: "string", minLength: 1, description: 'A node id from get_diagram (e.g. "A").' };
+var IDS = (what) => ({ type: "array", items: { type: "string", minLength: 1 }, minItems: 1, description: what });
+var EDGE_ID = { type: "string", minLength: 1, description: 'An edge id from get_diagram (e.g. "L_A_B_0").' };
+var LABEL = (what) => ({ type: "string", description: what });
+var object = (properties, required = []) => ({
+  type: "object",
+  properties,
+  ...required.length ? { required } : {},
+  additionalProperties: false
+});
+function describeDiagram(doc) {
+  const { graph } = doc;
+  return {
+    family: doc.family,
+    editable: doc.tier === "editable",
+    direction: graph.direction,
+    ...graph.title ? { title: graph.title } : {},
+    nodes: graph.nodes.map((n) => ({
+      id: n.id,
+      label: n.label,
+      shape: n.shape,
+      ...n.parentId ? { parentId: n.parentId } : {},
+      ...n.classes.length ? { classes: n.classes } : {},
+      ...n.styles.length ? { styles: n.styles } : {},
+      ...n.data?.synthetic ? { synthetic: true } : {}
+    })),
+    edges: graph.edges.map((e) => ({
+      id: e.id,
+      source: e.source,
+      target: e.target,
+      ...e.label ? { label: e.label } : {},
+      pattern: e.pattern,
+      arrowEnd: e.arrowEnd
+    })),
+    groups: graph.groups.map((g) => ({
+      id: g.id,
+      label: g.label,
+      ...g.parentId ? { parentId: g.parentId } : {},
+      ...g.direction ? { direction: g.direction } : {}
+    })),
+    shapes: diagramShapes(doc.family),
+    positions: Object.fromEntries(Object.entries(doc.meta.layout ?? {}).map(([id, [x, y]]) => [id, { x: Math.round(x), y: Math.round(y) }])),
+    ...doc.diagnostics.length ? { diagnostics: doc.diagnostics.map((d) => ({ severity: d.severity, message: d.message, ...d.line ? { line: d.line } : {} })) } : {}
+  };
+}
+function createDiagramToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "This diagram is read-only.";
+    return controller.getState().readOnly ? "This diagram is read-only." : null;
+  };
+  const doc = () => controller.getDocument();
+  const actor = options.actor ?? { id: "agent", name: "Agent" };
+  const apply = async (ops, label) => {
+    const result = options.director ? await options.director.perform(actor, Array.isArray(ops) ? ops : [ops], label) : controller.apply(ops, label);
+    if (!result.ok) throw new Error(result.message);
+    return result.document;
+  };
+  const edgeIds = () => new Set(doc().graph.edges.map((e) => e.id));
+  const newEdges = (before, after) => after.graph.edges.filter((e) => !before.has(e.id)).map((e) => ({ id: e.id, source: e.source, target: e.target, ...e.label ? { label: e.label } : {} }));
+  const nodeOut = (d, id) => {
+    const n = d.graph.nodes.find((x) => x.id === id) ?? d.graph.groups.find((x) => x.id === id);
+    return n ? { id: n.id, label: n.label, ..."shape" in n ? { shape: n.shape } : {}, ...n.parentId ? { parentId: n.parentId } : {} } : { id };
+  };
+  const pinned = (moves) => {
+    const shown = options.getPositions?.();
+    if (!shown) return moves;
+    const stored = doc().meta.layout ?? {};
+    const taken = new Set(moves.map((m) => m.id));
+    return [...moves, ...Object.entries(shown).filter(([id]) => !taken.has(id) && !stored[id]).map(([id, position]) => ({ id, position }))];
+  };
+  const requireEditable = () => {
+    if (doc().tier !== "editable")
+      throw new Error(`This ${doc().family} diagram can only be changed as Mermaid text; use load_diagram_mermaid.`);
+  };
+  const getDiagram = {
+    name: "get_diagram",
+    title: "Read the diagram",
+    description: "Returns the diagram: its Mermaid family (flowchart, state, class, er; other families are text only), direction, nodes (id, label, shape, parentId), edges (id, source, target, label), groups (subgraphs / composite states), the shapes nodes can take, stored canvas positions, any parse diagnostics and the selection. Use the ids it returns with the write tools.",
+    inputSchema: object({ includeSource: { type: "boolean", description: "Also return the Mermaid text (default false)." } }),
+    annotations: { title: "Read the diagram", ...READ },
+    handler: async ({ includeSource = false }) => {
+      const reason = readOnlyReason();
+      return {
+        ...describeDiagram(doc()),
+        selection: controller.getState().selection,
+        ...includeSource ? { source: doc().source } : {},
+        ...reason ? { readOnly: reason } : {}
+      };
+    }
+  };
+  const exportMermaid = {
+    name: "export_diagram_mermaid",
+    title: "Export the diagram as Mermaid",
+    description: 'Returns the diagram as Mermaid text. Canvas positions are kept in a "%% @pixerate {\u2026}" comment that Mermaid ignores; pass withLayout false to leave it out.',
+    inputSchema: object({ withLayout: { type: "boolean", description: "Keep the %% @pixerate layout comment (default true)." } }),
+    annotations: { title: "Export the diagram as Mermaid", ...READ },
+    handler: async ({ withLayout = true }) => {
+      const source = doc().source;
+      return { family: doc().family, source: withLayout ? source : source.replace(/^[ \t]*%%\s*@(?:pixerate|ursula)\s+\{.*\}[ \t]*(\r?\n|$)/gm, "") };
+    }
+  };
+  const findDiagrams = {
+    name: "find_mermaid_diagrams",
+    title: "Find Mermaid diagrams in text",
+    description: "Finds the Mermaid diagrams in a piece of text (Markdown with ```mermaid blocks, a chat reply, or a bare diagram) without changing anything. Returns each diagram's source, family and title; pass a source to load_diagram_mermaid to open it.",
+    inputSchema: object({ text: { type: "string", description: "The text to search." } }, ["text"]),
+    annotations: { title: "Find Mermaid diagrams in text", ...READ },
+    handler: ({ text }) => ({ diagrams: findMermaidSources(text) })
+  };
+  const loadMermaid = {
+    name: "load_diagram_mermaid",
+    title: "Replace the diagram with Mermaid",
+    description: "Replaces the whole diagram with Mermaid text (one undo step). Flowchart, state, class and ER diagrams become editable on the canvas; other families are kept as text. Returns the family, node and edge counts and any parse diagnostics. Prefer the per-operation tools for small changes: they keep the rest of the text as written.",
+    inputSchema: object({ source: { type: "string", minLength: 1, description: 'Mermaid text, starting with a header such as "flowchart LR".' } }, ["source"]),
+    annotations: { title: "Replace the diagram with Mermaid", ...DESTRUCTIVE },
+    handler: async ({ source }) => {
+      const fenced = /^\s*(`{3,}|~{3,})/m.test(source) ? findMermaidSources(source) : [];
+      if (fenced.length > 1) throw new Error(`The text holds ${fenced.length} diagrams; pass one (find_mermaid_diagrams lists them).`);
+      const text = fenced[0]?.source ?? source;
+      if (detectFamily(text) === "unknown")
+        throw new Error('The text has no Mermaid header (e.g. "flowchart LR", "stateDiagram-v2", "classDiagram", "erDiagram"); nothing was changed.');
+      const result = options.director ? await options.director.playSource(actor, text) : controller.load(text);
+      if (!result.ok) throw new Error(result.message);
+      const d = result.document;
+      return {
+        family: d.family,
+        editable: d.tier === "editable",
+        nodes: d.graph.nodes.length,
+        edges: d.graph.edges.length,
+        groups: d.graph.groups.length,
+        ...d.diagnostics.length ? { diagnostics: d.diagnostics.map((x) => x.message) } : {}
+      };
+    }
+  };
+  const addNode = {
+    name: "add_diagram_node",
+    title: "Add a node",
+    description: "Adds a node to the diagram, optionally inside a group and connected from an existing node. Without a position the canvas places it beside its neighbours. Returns the node and any edge created.",
+    inputSchema: object(
+      {
+        label: LABEL("Text shown in the node."),
+        id: { type: "string", pattern: "^[A-Za-z0-9_][\\w.-]*$", description: 'Mermaid id (default: the next free "N<number>").' },
+        shape: { type: "string", description: 'One of the shapes get_diagram lists (default "rect"). Flowchart and state diagrams only.' },
+        parentId: { type: "string", description: "Group (subgraph) to add the node to." },
+        from: { type: "string", description: "An existing node to connect to the new node." },
+        edgeLabel: LABEL('Label of the edge from "from" (needs "from").'),
+        x: { type: "number", description: "Left edge in canvas px (needs y)." },
+        y: { type: "number", description: "Top edge in canvas px (needs x)." }
+      },
+      ["label"]
+    ),
+    annotations: { title: "Add a node", ...WRITE },
+    handler: async ({ label, id, shape, parentId, from, edgeLabel, x, y }) => {
+      requireEditable();
+      if (x === void 0 !== (y === void 0)) throw new Error("Give both x and y, or neither to place the node automatically.");
+      if (edgeLabel !== void 0 && from === void 0) throw new Error('edgeLabel needs "from", the node the edge starts at.');
+      const nodeId = id ?? controller.nextId();
+      const before = edgeIds();
+      const ops = [
+        { type: "addNode", node: { id: nodeId, label, ...shape ? { shape } : {}, ...parentId ? { parentId } : {} }, ...x !== void 0 ? { position: [x, y] } : {} }
+      ];
+      if (from !== void 0) ops.push({ type: "addEdge", edge: { source: from, target: nodeId, ...edgeLabel ? { label: edgeLabel } : {} } });
+      const d = await apply(ops, "Add node");
+      const edges = newEdges(before, d);
+      return { node: nodeOut(d, nodeId), ...edges.length ? { edge: edges[0] } : {} };
+    }
+  };
+  const removeElements = {
+    name: "remove_diagram_nodes",
+    title: "Remove nodes or groups",
+    description: "Deletes nodes with every edge that touches them. A group id removes the group but keeps its contents. Returns the removed ids and the ids of the edges that went with them.",
+    inputSchema: object({ ids: IDS("Node or group ids from get_diagram.") }, ["ids"]),
+    annotations: { title: "Remove nodes or groups", ...DESTRUCTIVE },
+    handler: async ({ ids }) => {
+      requireEditable();
+      const before = doc().graph.edges.map((e) => e.id);
+      const d = await apply({ type: "removeNodes", ids }, ids.length === 1 ? "Delete node" : "Delete nodes");
+      const after = new Set(d.graph.edges.map((e) => e.id));
+      return { removed: ids, removedEdges: before.filter((id) => !after.has(id)) };
+    }
+  };
+  const renameNode = {
+    name: "rename_diagram_node",
+    title: "Rename a node or group",
+    description: "Changes the label of a node or group. Returns the node with its new label.",
+    inputSchema: object({ id: { ...ID, description: "A node or group id from get_diagram." }, label: LABEL("The new label.") }, ["id", "label"]),
+    annotations: { title: "Rename a node or group", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, label }) => {
+      requireEditable();
+      const isGroup = doc().graph.groups.some((g) => g.id === id);
+      const d = await apply(isGroup ? { type: "renameGroup", id, label } : { type: "renameNode", id, label }, "Rename");
+      return { node: nodeOut(d, id) };
+    }
+  };
+  const setShape = {
+    name: "set_diagram_node_shape",
+    title: "Change a node's shape",
+    description: "Changes a node's shape (flowchart and state diagrams). Use one of the shapes get_diagram lists. Returns the node.",
+    inputSchema: object({ id: ID, shape: { type: "string", minLength: 1, description: 'Shape name, e.g. "rect", "rounded", "diam", "cyl", "circle".' } }, ["id", "shape"]),
+    annotations: { title: "Change a node's shape", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, shape }) => {
+      requireEditable();
+      return { node: nodeOut(await apply({ type: "setNodeShape", id, shape }, "Change shape"), id) };
+    }
+  };
+  const setStyle = {
+    name: "set_diagram_node_style",
+    title: "Style a node",
+    description: 'Replaces a node\'s inline Mermaid styles (written as a `style` statement), e.g. ["fill:#fde68a", "stroke:#b45309", "stroke-width:2px"]. An empty list removes them. Returns the node with its styles.',
+    inputSchema: object(
+      { id: ID, styles: { type: "array", items: { type: "string", pattern: "^[\\w-]+:[^,;]+$" }, description: 'CSS-like "property:value" pairs.' } },
+      ["id", "styles"]
+    ),
+    annotations: { title: "Style a node", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, styles }) => {
+      requireEditable();
+      const d = await apply({ type: "setNodeStyles", id, styles }, "Style node");
+      return { id, styles: d.graph.nodes.find((n) => n.id === id)?.styles ?? [] };
+    }
+  };
+  const connect = {
+    name: "connect_diagram_nodes",
+    title: "Connect two nodes",
+    description: "Draws an edge from one existing node to another, with an optional label. Returns the new edge with its id.",
+    inputSchema: object({ source: { ...ID, description: "Node the edge starts at." }, target: { ...ID, description: "Node the edge ends at." }, label: LABEL("Edge label (optional).") }, ["source", "target"]),
+    annotations: { title: "Connect two nodes", ...WRITE },
+    handler: async ({ source, target, label }) => {
+      requireEditable();
+      const before = edgeIds();
+      const d = await apply({ type: "addEdge", edge: { source, target, ...label ? { label } : {} } }, "Connect");
+      return { edge: newEdges(before, d)[0] ?? null };
+    }
+  };
+  const removeEdges = {
+    name: "remove_diagram_edges",
+    title: "Remove edges",
+    description: "Deletes edges by id; the nodes stay. Returns the removed ids.",
+    inputSchema: object({ ids: IDS("Edge ids from get_diagram.") }, ["ids"]),
+    annotations: { title: "Remove edges", ...DESTRUCTIVE },
+    handler: async ({ ids }) => {
+      requireEditable();
+      await apply({ type: "removeEdges", ids }, ids.length === 1 ? "Delete edge" : "Delete edges");
+      return { removed: ids };
+    }
+  };
+  const labelEdge = {
+    name: "set_diagram_edge_label",
+    title: "Label an edge",
+    description: "Sets an edge's label; an empty string removes it. Returns the edge.",
+    inputSchema: object({ id: EDGE_ID, label: LABEL('The new label ("" removes it).') }, ["id", "label"]),
+    annotations: { title: "Label an edge", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, label }) => {
+      requireEditable();
+      const d = await apply({ type: "setEdgeLabel", id, label }, "Label edge");
+      const e = d.graph.edges.find((x) => x.id === id);
+      return { edge: e ? { id: e.id, source: e.source, target: e.target, label: e.label ?? "" } : { id, label } };
+    }
+  };
+  const reconnect = {
+    name: "reconnect_diagram_edge",
+    title: "Reconnect an edge",
+    description: "Moves an edge to new endpoints, keeping its label and style. Returns the edge (its id may change with its endpoints).",
+    inputSchema: object({ id: EDGE_ID, source: { ...ID, description: "New start node." }, target: { ...ID, description: "New end node." } }, ["id", "source", "target"]),
+    annotations: { title: "Reconnect an edge", ...WRITE },
+    handler: async ({ id, source, target }) => {
+      requireEditable();
+      const index = doc().graph.edges.findIndex((e2) => e2.id === id);
+      const d = await apply({ type: "reconnectEdge", id, source, target }, "Reconnect edge");
+      const e = d.graph.edges.find((x) => x.id === id) ?? d.graph.edges.find((x, i) => i === index && x.source === source && x.target === target) ?? d.graph.edges.find((x) => x.source === source && x.target === target);
+      return { edge: e ? { id: e.id, source: e.source, target: e.target, ...e.label ? { label: e.label } : {} } : null };
+    }
+  };
+  const setDirection = {
+    name: "set_diagram_direction",
+    title: "Set the layout direction",
+    description: "Sets the direction the diagram flows in: TB / TD (top to bottom), BT, LR (left to right) or RL. Returns the direction.",
+    inputSchema: object({ direction: { type: "string", enum: [...DIRECTIONS], description: "TB, TD, BT, LR or RL." } }, ["direction"]),
+    annotations: { title: "Set the layout direction", ...WRITE_IDEMPOTENT },
+    handler: async ({ direction }) => {
+      requireEditable();
+      return { direction: (await apply({ type: "setDirection", direction }, "Change direction")).graph.direction };
+    }
+  };
+  const group = {
+    name: "group_diagram_nodes",
+    title: "Group nodes",
+    description: "Puts nodes into a new group (a flowchart subgraph, composite state or class namespace). Returns the group id.",
+    inputSchema: object(
+      {
+        nodeIds: IDS("Node ids to put in the group."),
+        label: LABEL("Group title."),
+        id: { type: "string", pattern: "^[A-Za-z0-9_][\\w.-]*$", description: 'Group id (default: the next free "G<number>").' }
+      },
+      ["nodeIds", "label"]
+    ),
+    annotations: { title: "Group nodes", ...WRITE },
+    handler: async ({ nodeIds, label, id }) => {
+      requireEditable();
+      if (!diagramSupportsGroups(doc().family)) throw new Error(`${doc().family} diagrams have no groups.`);
+      const groupId = id ?? controller.nextId("G");
+      await apply({ type: "groupNodes", groupId, label, nodeIds }, "Group");
+      return { group: { id: groupId, label, nodeIds } };
+    }
+  };
+  const ungroup = {
+    name: "ungroup_diagram_group",
+    title: "Ungroup",
+    description: "Removes a group and keeps its nodes (they move to the group's parent). Returns the ids that were in it.",
+    inputSchema: object({ id: { type: "string", minLength: 1, description: "A group id from get_diagram." } }, ["id"]),
+    annotations: { title: "Ungroup", ...DESTRUCTIVE },
+    handler: async ({ id }) => {
+      requireEditable();
+      const members = [...doc().graph.nodes, ...doc().graph.groups].filter((x) => x.parentId === id).map((x) => x.id);
+      await apply({ type: "ungroup", groupId: id }, "Ungroup");
+      return { ungrouped: id, members };
+    }
+  };
+  const move = {
+    name: "move_diagram_nodes",
+    title: "Move nodes",
+    description: "Moves nodes or groups on the canvas to absolute positions (top-left, canvas px). Positions are stored in the %% @pixerate comment; the Mermaid statements do not change. Returns the new positions.",
+    inputSchema: object(
+      {
+        moves: {
+          type: "array",
+          minItems: 1,
+          description: "One entry per node.",
+          items: object({ id: { ...ID, description: "Node or group id." }, x: { type: "number", description: "Left edge in px." }, y: { type: "number", description: "Top edge in px." } }, ["id", "x", "y"])
+        }
+      },
+      ["moves"]
+    ),
+    annotations: { title: "Move nodes", ...WRITE_IDEMPOTENT },
+    handler: async ({ moves }) => {
+      const list = moves;
+      requireEditable();
+      await apply({ type: "moveNodes", moves: pinned(list.map((m) => ({ id: m.id, position: [m.x, m.y] }))) }, "Move");
+      return { moved: moves };
+    }
+  };
+  const undo = {
+    name: "undo_diagram",
+    title: "Undo a diagram edit",
+    description: "Undoes the last diagram edit. Returns whether something was undone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Undo a diagram edit", ...WRITE },
+    handler: async () => {
+      const label = controller.getState().undoLabel;
+      const undone = controller.undo();
+      return { undone, ...undone ? { label } : {} };
+    }
+  };
+  const redo = {
+    name: "redo_diagram",
+    title: "Redo a diagram edit",
+    description: "Redoes the last undone diagram edit. Returns whether something was redone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Redo a diagram edit", ...WRITE },
+    handler: async () => {
+      const label = controller.getState().redoLabel;
+      const redone = controller.redo();
+      return { redone, ...redone ? { label } : {} };
+    }
+  };
+  const reads = [getDiagram, exportMermaid, findDiagrams];
+  const writes = [loadMermaid, addNode, removeElements, renameNode, setShape, setStyle, connect, removeEdges, labelEdge, reconnect, setDirection, group, ungroup, move, undo, redo];
+  return {
+    id: options.id ?? "diagram",
+    namespace: options.namespace,
+    tools: () => readOnlyReason() ? reads : [...reads, ...writes],
+    subscribe: (notify) => {
+      let last = readOnlyReason();
+      return controller.subscribe(() => {
+        const now = readOnlyReason();
+        if (now !== last) {
+          last = now;
+          notify();
+        }
+      });
+    }
+  };
+}
+
+// src/diagram/draft.ts
+function signature(graph) {
+  return JSON.stringify([
+    graph.title ?? "",
+    graph.nodes.map((n) => [n.id, n.label, n.parentId ?? "", n.data ?? null]),
+    graph.edges.map((e) => [e.source, e.target, e.label ?? ""]),
+    graph.groups.map((g) => [g.id, g.label, g.parentId ?? ""]),
+    graph.data ?? null
+  ]);
+}
+var isMeta = (line) => /^\s*%%\s*@(?:pixerate|ursula)\b/.test(line);
+function bodyLines(lines, headerIndex) {
+  const body = lines.slice(headerIndex + 1).filter((l) => !isMeta(l));
+  while (body.length && !body[body.length - 1].trim()) body.pop();
+  return body;
+}
+function headerIndexOf(lines, header) {
+  const wanted = header.trim();
+  return wanted ? lines.findIndex((l) => l.trim() === wanted) : -1;
+}
+function draftFrames(current, target, options = {}) {
+  const maxFrames = Math.max(2, options.maxFrames ?? 40);
+  const now = parseMermaid(current);
+  const goal = parseMermaid(target);
+  if (goal.family !== now.family || goal.diagnostics.length) return null;
+  const eol = goal.eol;
+  const lines = target.split(/\r?\n/);
+  const at = headerIndexOf(lines, goal.header);
+  if (at < 0) return null;
+  const currentLines = current.split(/\r?\n/);
+  const currentAt = headerIndexOf(currentLines, now.header);
+  if (currentAt < 0) return null;
+  const have = bodyLines(currentLines, currentAt);
+  const body = lines.map((line, index) => ({ line, index })).slice(at + 1).filter(({ line }) => !isMeta(line));
+  for (let i = 0; i < have.length; i++) {
+    if (body[i]?.line !== have[i]) return null;
+  }
+  const frames = [];
+  let last = signature(now.graph);
+  for (let i = have.length; i < body.length; i++) {
+    const end = body[i].index;
+    const candidate = lines.slice(0, end + 1).join(eol) + eol;
+    const doc = parseMermaid(candidate);
+    if (doc.family !== goal.family || doc.diagnostics.length) continue;
+    const sig = signature(doc.graph);
+    if (sig === last) continue;
+    frames.push(candidate);
+    last = sig;
+  }
+  if (!frames.length) return null;
+  if (last === signature(goal.graph)) frames[frames.length - 1] = target;
+  else frames.push(target);
+  if (frames.length <= maxFrames) return frames;
+  const sampled = [];
+  for (let k = 1; k <= maxFrames; k++) {
+    sampled.push(frames[Math.round(k * frames.length / maxFrames) - 1]);
+  }
+  return sampled;
+}
+function changedItems(before, after) {
+  const old = /* @__PURE__ */ new Map();
+  for (const n of before.nodes) old.set(n.id, JSON.stringify([n.label, n.parentId, n.data]));
+  for (const g of before.groups) old.set(g.id, JSON.stringify([g.label, g.parentId]));
+  const out = [];
+  for (const n of after.nodes)
+    if (old.get(n.id) !== JSON.stringify([n.label, n.parentId, n.data])) out.push(n.id);
+  for (const g of after.groups)
+    if (old.get(g.id) !== JSON.stringify([g.label, g.parentId])) out.push(g.id);
+  return out;
+}
+
+// src/diagram/director.ts
+var center = (place, id) => {
+  const p = place.positions[id];
+  if (!p) return null;
+  const s = place.sizes[id] ?? { width: 160, height: 56 };
+  return { x: p[0] + s.width / 2, y: p[1] + s.height / 2 };
+};
+function freeSpot(place) {
+  let maxX = 0;
+  let maxY = 0;
+  let any = false;
+  for (const [id, [x, y]] of Object.entries(place.positions)) {
+    const s = place.sizes[id] ?? { width: 160, height: 56 };
+    maxX = Math.max(maxX, x + s.width);
+    maxY = Math.max(maxY, y + s.height);
+    any = true;
+  }
+  return any ? { x: maxX + 60, y: maxY / 2 } : { x: 80, y: 40 };
+}
+var NEW_NODE = { width: 160, height: 56 };
+function besideFree(place, from, direction) {
+  const d = direction.toUpperCase();
+  const along = d === "LR" ? { x: 1, y: 0 } : d === "RL" ? { x: -1, y: 0 } : d === "BT" ? { x: 0, y: -1 } : { x: 0, y: 1 };
+  const side = { x: along.y, y: along.x };
+  const rects = Object.entries(place.positions).map(([id, [x, y]]) => ({ x, y, ...place.sizes[id] ?? NEW_NODE }));
+  const free = (c) => !rects.some((r) => c.x - NEW_NODE.width / 2 - 20 < r.x + r.width && c.x + NEW_NODE.width / 2 + 20 > r.x && c.y - NEW_NODE.height / 2 - 20 < r.y + r.height && c.y + NEW_NODE.height / 2 + 20 > r.y);
+  const base = { x: from.x + along.x * 240, y: from.y + along.y * 140 };
+  for (let i = 0; i < 24; i++) {
+    const k = i === 0 ? 0 : (i % 2 ? 1 : -1) * Math.ceil(i / 2);
+    const c = { x: base.x + side.x * k * 200, y: base.y + side.y * k * 90 };
+    if (free(c)) return c;
+  }
+  return base;
+}
+function planDiagramEdit(doc, place, op, speed = 1, next) {
+  const ms = (n) => Math.round(n / Math.max(0.1, speed));
+  const at = (id) => center(place, id);
+  const click = (to) => to ? [{ type: "move", to, ms: ms(380) }, { type: "press" }, { type: "release" }] : [];
+  const edgeMid = (id) => {
+    const e = doc.graph.edges.find((x) => x.id === id);
+    const a = e && at(e.source);
+    const b = e && at(e.target);
+    return a && b ? { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 } : null;
+  };
+  switch (op.type) {
+    case "addNode": {
+      const from = next?.type === "addEdge" && next.edge.target === op.node.id ? at(next.edge.source) : null;
+      const to = op.position ? { x: op.position[0] + 80, y: op.position[1] + 28 } : from ? besideFree(place, from, doc.graph.direction) : freeSpot(place);
+      const label = op.node.label ?? op.node.id;
+      return [...click(to), { type: "type", text: label, ms: ms(Math.min(900, 60 * label.length + 200)) }, { type: "commit" }];
+    }
+    case "addEdge": {
+      const a = at(op.edge.source);
+      const b = at(op.edge.target) ?? (a ? { x: a.x + 260, y: a.y } : null);
+      if (!a || !b) return [{ type: "commit" }];
+      return [
+        { type: "move", to: a, ms: ms(380) },
+        { type: "press" },
+        { type: "move", to: b, ms: ms(520) },
+        { type: "release" },
+        ...op.edge.label ? [{ type: "type", text: op.edge.label, ms: ms(500) }] : [],
+        { type: "commit" }
+      ];
+    }
+    case "moveNodes": {
+      const steps = [];
+      for (const move of op.moves) {
+        const from = at(move.id);
+        const size = place.sizes[move.id] ?? { width: 160, height: 56 };
+        if (!from) continue;
+        steps.push(
+          { type: "move", to: from, ms: ms(380) },
+          { type: "press" },
+          { type: "drag", id: move.id, to: { x: move.position[0] + size.width / 2, y: move.position[1] + size.height / 2 }, position: move.position, ms: ms(520) },
+          { type: "release" }
+        );
+      }
+      return [...steps, { type: "commit" }];
+    }
+    case "renameNode":
+    case "renameGroup":
+      return [...click(at(op.id)), { type: "press" }, { type: "release" }, { type: "type", text: op.label, ms: ms(Math.min(900, 60 * op.label.length + 200)) }, { type: "commit" }];
+    case "removeNodes":
+      return [...click(at(op.ids[0])), { type: "say", text: "Delete", ms: ms(300) }, { type: "commit" }];
+    case "removeEdges":
+      return [...click(edgeMid(op.ids[0])), { type: "say", text: "Delete", ms: ms(300) }, { type: "commit" }];
+    case "setEdgeLabel":
+      return [...click(edgeMid(op.id)), { type: "type", text: op.label, ms: ms(500) }, { type: "commit" }];
+    case "reconnectEdge": {
+      const a = at(op.source);
+      const b = at(op.target);
+      return [...click(edgeMid(op.id)), ...a && b ? [{ type: "move", to: a, ms: ms(300) }, { type: "press" }, { type: "move", to: b, ms: ms(500) }, { type: "release" }] : [], { type: "commit" }];
+    }
+    case "setNodeShape":
+    case "setNodeStyles":
+    case "setNodeClasses":
+    case "setNodeLink":
+    case "setNodeData":
+    case "resizeNode":
+      return [...click(at(op.id)), { type: "commit" }];
+    case "groupNodes": {
+      const points = op.nodeIds.map(at).filter((p) => !!p);
+      if (!points.length) return [{ type: "commit" }];
+      const min = { x: Math.min(...points.map((p) => p.x)) - 90, y: Math.min(...points.map((p) => p.y)) - 40 };
+      const max = { x: Math.max(...points.map((p) => p.x)) + 90, y: Math.max(...points.map((p) => p.y)) + 40 };
+      return [{ type: "move", to: min, ms: ms(380) }, { type: "press" }, { type: "move", to: max, ms: ms(520) }, { type: "release" }, { type: "type", text: op.label, ms: ms(500) }, { type: "commit" }];
+    }
+    default:
+      return [{ type: "commit" }];
+  }
+}
+var DiagramDirector = class {
+  constructor(controller, presence, options) {
+    this.controller = controller;
+    this.options = options;
+    this.presence = presence;
+    this.clock = options.clock ?? realPresenceClock;
+    this.queue = new PerformanceQueue(presence, {
+      clock: this.clock,
+      linger: options.linger,
+      beginGesture: (key) => controller.beginGesture(key),
+      endGesture: () => controller.endGesture()
+    });
+  }
+  controller;
+  options;
+  presence;
+  clock;
+  queue;
+  /** Acts out `ops` in order for `actor` as one undo step. */
+  perform(actor, ops, label = "Edit diagram") {
+    let check = this.controller.getDocument();
+    if (this.controller.getState().readOnly) return Promise.resolve({ ok: false, message: "The diagram is read-only." });
+    for (const op of ops) {
+      const problem = validateDiagramEdit(check, op);
+      if (problem) return Promise.resolve({ ok: false, message: problem });
+      check = applyEdits(check, [op]);
+    }
+    return this.queue.run(actor, async () => {
+      const mark = this.controller.history.mark();
+      const fail = (message) => {
+        this.controller.history.revertTo(mark);
+        return { ok: false, message };
+      };
+      if (ops.some((op) => op.type === "addNode" || op.type === "moveNodes")) {
+        const problem = this.pin(label);
+        if (problem) return fail(problem);
+      }
+      for (let i = 0; i < ops.length; i++) {
+        const op = ops[i];
+        const steps = planDiagramEdit(this.controller.getDocument(), this.options.placement(), op, this.options.speed, ops[i + 1]);
+        for (const step of steps) {
+          const problem = await this.act(actor.id, step, op, label);
+          if (problem) return fail(problem);
+        }
+      }
+      return { ok: true, document: this.controller.getDocument() };
+    });
+  }
+  /**
+   * Replaces the diagram with `source`, drawing it statement by statement when it extends
+   * what is there (Ursula's draft playback): each frame lands, the cursor points at what
+   * appeared, and the whole write is one undo step. Otherwise it lands at once.
+   */
+  playSource(actor, source, label = "Replace diagram") {
+    if (this.controller.getState().readOnly) return Promise.resolve({ ok: false, message: "The diagram is read-only." });
+    return this.queue.run(actor, async () => {
+      const frames = draftFrames(this.controller.getSource(), source, { maxFrames: this.options.maxDraftFrames }) ?? [source];
+      const pause = Math.round(260 / Math.max(0.1, this.options.speed ?? 1));
+      for (const frame of frames) {
+        const before = this.controller.getDocument().graph;
+        const result = this.controller.apply({ type: "replaceSource", source: frame }, label);
+        if (!result.ok) return result;
+        const fresh = changedItems(before, result.document.graph);
+        const target = fresh.length ? center(this.options.placement(), fresh[fresh.length - 1]) : null;
+        const actorNow = this.presence.get(actor.id);
+        if (target && actorNow) await tweenPresenceCursor(this.presence, this.clock, actor.id, actorNow, target, pause);
+        else await this.clock.wait(pause);
+      }
+      return { ok: true, document: this.controller.getDocument() };
+    });
+  }
+  /** Stores the drawn position of every node and group that has none yet. */
+  pin(label) {
+    const doc = this.controller.getDocument();
+    const stored = doc.meta.layout ?? {};
+    const known = new Set([...doc.graph.nodes, ...doc.graph.groups].map((x) => x.id));
+    const moves = Object.entries(this.options.placement().positions).filter(([id]) => known.has(id) && !stored[id]).map(([id, position]) => ({ id, position }));
+    if (!moves.length) return null;
+    const result = this.controller.apply({ type: "moveNodes", moves }, label);
+    return result.ok ? null : result.message;
+  }
+  /** Runs one step; returns a problem sentence when the edit can no longer be applied. */
+  async act(id, step, op, label) {
+    const where = () => {
+      const a = this.presence.get(id);
+      return a ? { x: a.x, y: a.y } : { x: 0, y: 0 };
+    };
+    switch (step.type) {
+      case "say":
+        this.presence.set({ id, message: step.text });
+        await this.clock.wait(step.ms);
+        return null;
+      case "type": {
+        const chars = [...step.text];
+        const each = step.ms / Math.max(1, chars.length);
+        for (let i = 1; i <= chars.length; i++) {
+          this.presence.set({ id, message: chars.slice(0, i).join("") });
+          await this.clock.wait(each);
+        }
+        return null;
+      }
+      case "move":
+        await tweenPresenceCursor(this.presence, this.clock, id, where(), step.to, step.ms);
+        return null;
+      case "press":
+        this.presence.set({ id, pressed: true });
+        return null;
+      case "release":
+        this.presence.set({ id, pressed: false });
+        return null;
+      case "drag": {
+        const start = this.options.placement().positions[step.id];
+        let problem = null;
+        await tweenPresenceCursor(this.presence, this.clock, id, where(), step.to, step.ms, (e) => {
+          if (problem || !start) return;
+          const position = [start[0] + (step.position[0] - start[0]) * e, start[1] + (step.position[1] - start[1]) * e];
+          const result = this.controller.apply({ type: "moveNodes", moves: [{ id: step.id, position }] }, label);
+          if (!result.ok) problem = result.message;
+        });
+        return problem;
+      }
+      case "commit": {
+        const placed = op.type === "addNode" && !op.position ? { ...op, position: [Math.round(where().x - 80), Math.round(where().y - 28)] } : op;
+        const result = this.controller.apply(placed, label);
+        return result.ok ? null : result.message;
+      }
+    }
+  }
+};
+function planDiagramEdits(source, place, ops, speed = 1) {
+  let doc = parseMermaid(source);
+  return ops.map((op, i) => {
+    const steps = planDiagramEdit(doc, place, op, speed, ops[i + 1]);
+    doc = applyEdits(doc, [op]);
+    return steps;
+  });
+}
+export {
+  CLASS_RELATIONS,
+  DIRECTIONS,
+  DiagramController,
+  DiagramDirector,
+  EDITABLE_DIAGRAM_FAMILIES,
+  ER_CARDINALITIES,
+  ER_PATTERNS,
+  FLOWCHART_SHAPES,
+  META_COMMENT_PREFIX,
+  META_FRONTMATTER_KEY,
+  PRESENCE_COLORS,
+  PerformanceQueue,
+  PresenceStore,
+  STATE_SHAPES,
+  applyEdit,
+  applyEdits,
+  canonicalShape,
+  changedItems,
+  classGrammar,
+  createDiagramToolProvider,
+  createInstantPresenceClock,
+  createLineAdapter,
+  createPassthroughAdapter,
+  describeDiagram,
+  detectFamily,
+  detectFamilyFromHeader,
+  diagramShapes,
+  diagramSupportsGroups,
+  draftFrames,
+  emptyMeta,
+  erGrammar,
+  findMermaidSources,
+  flowchartAdapter,
+  formatChain,
+  formatLink,
+  formatNode,
+  getDiagramAdapter,
+  isMetaEmpty,
+  mergeMeta,
+  parseAttributes,
+  parseChain,
+  parseFlowchartSource,
+  parseLink,
+  parseMembers,
+  parseMermaid,
+  parseStatement,
+  planDiagramEdit,
+  planDiagramEdits,
+  quoteLabelIfNeeded,
+  realPresenceClock,
+  registerDiagramAdapter,
+  relationFor,
+  resolveShape,
+  serializeMermaid,
+  serializeMeta,
+  splitSource,
+  splitStatements,
+  stateGrammar,
+  supportTierOf,
+  validateDiagramEdit
+};
+//# sourceMappingURL=index.js.map