@x12i/diagrams 1.0.0 → 1.1.0

package/dist/chunk-3DJFQRU3.js

@@ -0,0 +1,2708 @@
+// src/schema.ts
+var DIAGRAM_VERSION = 1;
+var NODE_KINDS = [
+  "start",
+  "task",
+  "decision",
+  "end",
+  "group",
+  "subflow",
+  "note",
+  "image",
+  "entity",
+  "code",
+  "chart",
+  "agent"
+];
+var NODE_STATUSES = ["neutral", "success", "warning", "danger", "info"];
+var EDGE_KINDS = ["straight", "bezier", "step", "smooth-step"];
+var DIAGRAM_KINDS = ["graph", "flowchart", "dag", "tree"];
+function isContainerKind(kind) {
+  return kind === "group" || kind === "subflow";
+}
+function defineDiagram(document) {
+  return document;
+}
+function createDiagram(title = "", extra = {}) {
+  return { version: DIAGRAM_VERSION, title, nodes: [], edges: [], ...extra };
+}
+
+// src/ids.ts
+function generateId(prefix = "id", random = Math.random) {
+  let suffix = "";
+  while (suffix.length < 8) suffix += random().toString(36).slice(2);
+  return `${prefix}-${suffix.slice(0, 8)}`;
+}
+function nextId(taken, prefix) {
+  const set = taken instanceof Set ? taken : new Set(taken);
+  let n = 1;
+  while (set.has(`${prefix}${n}`)) n += 1;
+  return `${prefix}${n}`;
+}
+function createIdAllocator(taken = []) {
+  const used = new Set(taken);
+  const counters = /* @__PURE__ */ new Map();
+  return {
+    next(prefix) {
+      let n = counters.get(prefix) ?? 1;
+      while (used.has(`${prefix}${n}`)) n += 1;
+      counters.set(prefix, n + 1);
+      const id = `${prefix}${n}`;
+      used.add(id);
+      return id;
+    },
+    reserve(id) {
+      used.add(id);
+    },
+    has(id) {
+      return used.has(id);
+    }
+  };
+}
+function idStem(id, fallback) {
+  const stem = id.replace(/[-_]?\d+$/, "");
+  return stem === "" ? fallback : stem;
+}
+
+// src/graph.ts
+function buildIndex(doc) {
+  const nodesById = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) if (!nodesById.has(node.id)) nodesById.set(node.id, node);
+  const edgesById = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  for (const edge of doc.edges) {
+    if (!edgesById.has(edge.id)) edgesById.set(edge.id, edge);
+    if (!nodesById.has(edge.source) || !nodesById.has(edge.target)) continue;
+    const out = outgoing.get(edge.source);
+    if (out) out.push(edge);
+    else outgoing.set(edge.source, [edge]);
+    const inc = incoming.get(edge.target);
+    if (inc) inc.push(edge);
+    else incoming.set(edge.target, [edge]);
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    if (node.parentId === void 0 || !nodesById.has(node.parentId) || node.parentId === node.id) continue;
+    const list = children.get(node.parentId);
+    if (list) list.push(node.id);
+    else children.set(node.parentId, [node.id]);
+  }
+  return { nodesById, edgesById, outgoing, incoming, children };
+}
+function getAncestors(index, id) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([id]);
+  let current = index.nodesById.get(id)?.parentId;
+  while (current !== void 0 && !seen.has(current) && index.nodesById.has(current)) {
+    chain.push(current);
+    seen.add(current);
+    current = index.nodesById.get(current)?.parentId;
+  }
+  return chain;
+}
+function getDescendants(index, id) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set([id]);
+  const stack = [...index.children.get(id) ?? []].reverse();
+  while (stack.length > 0) {
+    const next = stack.pop();
+    if (seen.has(next)) continue;
+    seen.add(next);
+    result.push(next);
+    const kids = index.children.get(next);
+    if (kids) for (let i = kids.length - 1; i >= 0; i -= 1) stack.push(kids[i]);
+  }
+  return result;
+}
+function findCycle(doc, index = buildIndex(doc)) {
+  const state = /* @__PURE__ */ new Map();
+  for (const root of doc.nodes) {
+    if (state.has(root.id)) continue;
+    const path = [];
+    const cursors = [];
+    path.push(root.id);
+    cursors.push(0);
+    state.set(root.id, 1);
+    while (path.length > 0) {
+      const current = path[path.length - 1];
+      const edges = index.outgoing.get(current) ?? [];
+      const cursor = cursors[cursors.length - 1];
+      if (cursor >= edges.length) {
+        state.set(current, 2);
+        path.pop();
+        cursors.pop();
+        continue;
+      }
+      cursors[cursors.length - 1] = cursor + 1;
+      const next = edges[cursor].target;
+      const seen = state.get(next);
+      if (seen === 1) return path.slice(path.indexOf(next));
+      if (seen === void 0) {
+        state.set(next, 1);
+        path.push(next);
+        cursors.push(0);
+      }
+    }
+  }
+  return void 0;
+}
+function hasPath(index, from, to) {
+  if (from === to) return true;
+  const seen = /* @__PURE__ */ new Set([from]);
+  const queue = [from];
+  for (let head = 0; head < queue.length; head += 1) {
+    for (const edge of index.outgoing.get(queue[head]) ?? []) {
+      if (edge.target === to) return true;
+      if (!seen.has(edge.target)) {
+        seen.add(edge.target);
+        queue.push(edge.target);
+      }
+    }
+  }
+  return false;
+}
+function getRoots(doc, index = buildIndex(doc)) {
+  return doc.nodes.filter((node) => !index.incoming.has(node.id)).map((node) => node.id);
+}
+function getNeighbors(index, id) {
+  const result = /* @__PURE__ */ new Set();
+  for (const edge of index.outgoing.get(id) ?? []) result.add(edge.target);
+  for (const edge of index.incoming.get(id) ?? []) result.add(edge.source);
+  result.delete(id);
+  return [...result];
+}
+function topologicalOrder(doc, index = buildIndex(doc)) {
+  const indegree = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) indegree.set(node.id, 0);
+  for (const edges of index.outgoing.values()) {
+    for (const edge of edges) indegree.set(edge.target, (indegree.get(edge.target) ?? 0) + 1);
+  }
+  const queue = doc.nodes.filter((node) => indegree.get(node.id) === 0).map((node) => node.id);
+  const order = [];
+  for (let head = 0; head < queue.length; head += 1) {
+    const id = queue[head];
+    order.push(id);
+    for (const edge of index.outgoing.get(id) ?? []) {
+      const left = (indegree.get(edge.target) ?? 0) - 1;
+      indegree.set(edge.target, left);
+      if (left === 0) queue.push(edge.target);
+    }
+  }
+  if (order.length < doc.nodes.length) {
+    const placed = new Set(order);
+    for (const node of doc.nodes) if (!placed.has(node.id)) order.push(node.id);
+  }
+  return order;
+}
+
+// src/connection.ts
+function resolveConnectionRules(kind, rules = {}) {
+  const strict = kind === "dag" || kind === "tree";
+  return {
+    allowSelfLoops: rules.allowSelfLoops ?? !strict,
+    allowDuplicates: rules.allowDuplicates ?? false,
+    acyclic: rules.acyclic ?? strict,
+    singleParent: rules.singleParent ?? kind === "tree"
+  };
+}
+function portTypesCompatible(a, b) {
+  return a === void 0 || b === void 0 || a === "any" || b === "any" || a === b;
+}
+var reject = (code, message) => ({ ok: false, code, message });
+function checkPort(node, portId, wanted) {
+  if (portId === void 0) return void 0;
+  const port = node.ports?.find((candidate) => candidate.id === portId);
+  if (!port) return wanted === "out" ? "source-port-missing" : "target-port-missing";
+  if (port.direction !== wanted) return wanted === "out" ? "source-port-not-output" : "target-port-not-input";
+  return void 0;
+}
+function checkConnection(doc, connection, rules = {}, index = buildIndex(doc)) {
+  const resolved = resolveConnectionRules(doc.kind, rules);
+  const source = index.nodesById.get(connection.source);
+  const target = index.nodesById.get(connection.target);
+  if (!source) return reject("unknown-source", `Unknown source node "${connection.source}".`);
+  if (!target) return reject("unknown-target", `Unknown target node "${connection.target}".`);
+  if (source.locked === true || target.locked === true) {
+    return reject("locked", "A locked node cannot be connected.");
+  }
+  if (source.id === target.id && !resolved.allowSelfLoops) {
+    return reject("self-loop", "A node cannot connect to itself in this diagram.");
+  }
+  if (source.id !== target.id) {
+    if (getAncestors(index, target.id).includes(source.id) || getAncestors(index, source.id).includes(target.id)) {
+      return reject("container-descendant", "A group cannot connect to a node inside it.");
+    }
+  }
+  const sourceProblem = checkPort(source, connection.sourcePort, "out");
+  if (sourceProblem) return reject(sourceProblem, `The source port "${connection.sourcePort}" cannot start a connection.`);
+  const targetProblem = checkPort(target, connection.targetPort, "in");
+  if (targetProblem) return reject(targetProblem, `The target port "${connection.targetPort}" cannot receive a connection.`);
+  if (connection.sourcePort !== void 0 && connection.targetPort !== void 0) {
+    const sourceType = source.ports?.find((port) => port.id === connection.sourcePort)?.type;
+    const targetType = target.ports?.find((port) => port.id === connection.targetPort)?.type;
+    if (!portTypesCompatible(sourceType, targetType)) {
+      return reject("port-type-mismatch", `Port types "${sourceType}" and "${targetType}" are not compatible.`);
+    }
+  }
+  if (!resolved.allowDuplicates) {
+    const duplicate = (index.outgoing.get(source.id) ?? []).some(
+      (edge) => edge.target === target.id && edge.sourcePort === connection.sourcePort && edge.targetPort === connection.targetPort
+    );
+    if (duplicate) return reject("duplicate", "These nodes are already connected.");
+  }
+  if (resolved.singleParent && (index.incoming.get(target.id)?.length ?? 0) > 0) {
+    return reject("multiple-parents", "This node already has a parent.");
+  }
+  if (resolved.acyclic && hasPath(index, target.id, source.id)) {
+    return reject("cycle", "This connection would create a cycle.");
+  }
+  return { ok: true };
+}
+
+// src/validate.ts
+var isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function validateDiagram(doc, options = {}) {
+  const issues = [];
+  const add2 = (issue) => issues.push({ severity: "error", ...issue });
+  const kind = options.kind ?? doc.kind ?? "graph";
+  if (doc.version !== DIAGRAM_VERSION) {
+    add2({
+      code: "unsupported-version",
+      message: `Unsupported diagram version ${String(doc.version)}. Expected ${DIAGRAM_VERSION}.`,
+      path: ["version"]
+    });
+  }
+  if (typeof doc.title !== "string" || doc.title.trim() === "") {
+    add2({
+      code: "missing-title",
+      severity: "warning",
+      message: "Every diagram needs a title that states what it shows.",
+      path: ["title"]
+    });
+  }
+  const index = buildIndex(doc);
+  const seenNodes = /* @__PURE__ */ new Set();
+  doc.nodes.forEach((node, i) => {
+    if (typeof node.id !== "string" || node.id === "") {
+      add2({ code: "empty-id", message: "A node needs a non-empty id.", path: ["nodes", i, "id"] });
+    } else if (seenNodes.has(node.id)) {
+      add2({
+        code: "duplicate-node-id",
+        message: `Node id "${node.id}" is used more than once.`,
+        path: ["nodes", i, "id"],
+        nodeId: node.id
+      });
+    }
+    seenNodes.add(node.id);
+    if (!NODE_KINDS.includes(node.kind)) {
+      add2({
+        code: "invalid-node-kind",
+        message: `Unknown node kind "${String(node.kind)}".`,
+        path: ["nodes", i, "kind"],
+        nodeId: node.id
+      });
+    }
+    if (node.status !== void 0 && !NODE_STATUSES.includes(node.status)) {
+      add2({
+        code: "invalid-status",
+        message: `Unknown node status "${String(node.status)}".`,
+        path: ["nodes", i, "status"],
+        nodeId: node.id
+      });
+    }
+    if (!node.position || !isFiniteNumber(node.position.x) || !isFiniteNumber(node.position.y)) {
+      add2({
+        code: "invalid-position",
+        message: `Node "${node.id}" needs a finite position.`,
+        path: ["nodes", i, "position"],
+        nodeId: node.id
+      });
+    }
+    for (const key of ["width", "height"]) {
+      const value = node[key];
+      if (value !== void 0 && (!isFiniteNumber(value) || value <= 0)) {
+        add2({
+          code: "invalid-size",
+          message: `Node "${node.id}" has an invalid ${key}.`,
+          path: ["nodes", i, key],
+          nodeId: node.id
+        });
+      }
+    }
+    if ((options.warnOnEmptyLabels ?? true) && (typeof node.label !== "string" || node.label.trim() === "")) {
+      add2({
+        code: "empty-label",
+        severity: "warning",
+        message: `Node "${node.id}" has no label, so screen readers cannot name it.`,
+        path: ["nodes", i, "label"],
+        nodeId: node.id
+      });
+    }
+    const portIds = /* @__PURE__ */ new Set();
+    node.ports?.forEach((port, p) => {
+      if (portIds.has(port.id)) {
+        add2({
+          code: "duplicate-port-id",
+          message: `Port id "${port.id}" is used twice on node "${node.id}".`,
+          path: ["nodes", i, "ports", p, "id"],
+          nodeId: node.id
+        });
+      }
+      portIds.add(port.id);
+    });
+    if (node.parentId !== void 0) {
+      const parent = index.nodesById.get(node.parentId);
+      if (node.parentId === node.id) {
+        add2({
+          code: "parent-self",
+          message: `Node "${node.id}" is its own parent.`,
+          path: ["nodes", i, "parentId"],
+          nodeId: node.id
+        });
+      } else if (!parent) {
+        add2({
+          code: "parent-missing",
+          message: `Node "${node.id}" refers to a missing parent "${node.parentId}".`,
+          path: ["nodes", i, "parentId"],
+          nodeId: node.id
+        });
+      } else {
+        if (!isContainerKind(parent.kind)) {
+          add2({
+            code: "parent-not-container",
+            message: `Parent "${parent.id}" is a ${parent.kind}, not a group or subflow.`,
+            path: ["nodes", i, "parentId"],
+            nodeId: node.id
+          });
+        }
+        if (hasParentLoop(index, node.id)) {
+          add2({
+            code: "parent-cycle",
+            message: `Node "${node.id}" is inside a loop of groups.`,
+            path: ["nodes", i, "parentId"],
+            nodeId: node.id
+          });
+        }
+      }
+    }
+  });
+  const seenEdges = /* @__PURE__ */ new Set();
+  const seenPairs = /* @__PURE__ */ new Set();
+  doc.edges.forEach((edge, i) => {
+    if (typeof edge.id !== "string" || edge.id === "") {
+      add2({ code: "empty-id", message: "An edge needs a non-empty id.", path: ["edges", i, "id"] });
+    } else if (seenEdges.has(edge.id)) {
+      add2({
+        code: "duplicate-edge-id",
+        message: `Edge id "${edge.id}" is used more than once.`,
+        path: ["edges", i, "id"],
+        edgeId: edge.id
+      });
+    }
+    seenEdges.add(edge.id);
+    if (edge.kind !== void 0 && !EDGE_KINDS.includes(edge.kind)) {
+      add2({
+        code: "invalid-edge-kind",
+        message: `Unknown edge kind "${String(edge.kind)}".`,
+        path: ["edges", i, "kind"],
+        edgeId: edge.id
+      });
+    }
+    if (edge.status !== void 0 && !NODE_STATUSES.includes(edge.status)) {
+      add2({
+        code: "invalid-status",
+        message: `Unknown edge status "${String(edge.status)}".`,
+        path: ["edges", i, "status"],
+        edgeId: edge.id
+      });
+    }
+    const source = index.nodesById.get(edge.source);
+    const target = index.nodesById.get(edge.target);
+    if (!source) {
+      add2({
+        code: "dangling-source",
+        message: `Edge "${edge.id}" starts at a missing node "${edge.source}".`,
+        path: ["edges", i, "source"],
+        edgeId: edge.id
+      });
+    }
+    if (!target) {
+      add2({
+        code: "dangling-target",
+        message: `Edge "${edge.id}" ends at a missing node "${edge.target}".`,
+        path: ["edges", i, "target"],
+        edgeId: edge.id
+      });
+    }
+    if (!source || !target) return;
+    const sourcePort = edge.sourcePort === void 0 ? void 0 : source.ports?.find((p) => p.id === edge.sourcePort);
+    const targetPort = edge.targetPort === void 0 ? void 0 : target.ports?.find((p) => p.id === edge.targetPort);
+    if (edge.sourcePort !== void 0) {
+      if (!sourcePort) {
+        add2({
+          code: "unknown-source-port",
+          message: `Edge "${edge.id}" uses port "${edge.sourcePort}", which node "${source.id}" does not have.`,
+          path: ["edges", i, "sourcePort"],
+          edgeId: edge.id
+        });
+      } else if (sourcePort.direction !== "out") {
+        add2({
+          code: "source-port-direction",
+          message: `Port "${sourcePort.id}" on "${source.id}" is an input and cannot start an edge.`,
+          path: ["edges", i, "sourcePort"],
+          edgeId: edge.id
+        });
+      }
+    }
+    if (edge.targetPort !== void 0) {
+      if (!targetPort) {
+        add2({
+          code: "unknown-target-port",
+          message: `Edge "${edge.id}" uses port "${edge.targetPort}", which node "${target.id}" does not have.`,
+          path: ["edges", i, "targetPort"],
+          edgeId: edge.id
+        });
+      } else if (targetPort.direction !== "in") {
+        add2({
+          code: "target-port-direction",
+          message: `Port "${targetPort.id}" on "${target.id}" is an output and cannot end an edge.`,
+          path: ["edges", i, "targetPort"],
+          edgeId: edge.id
+        });
+      }
+    }
+    if (sourcePort && targetPort && !portTypesCompatible(sourcePort.type, targetPort.type)) {
+      add2({
+        code: "port-type-mismatch",
+        message: `Edge "${edge.id}" joins incompatible port types "${sourcePort.type}" and "${targetPort.type}".`,
+        path: ["edges", i],
+        edgeId: edge.id
+      });
+    }
+    const pair = JSON.stringify([edge.source, edge.sourcePort ?? null, edge.target, edge.targetPort ?? null]);
+    if (seenPairs.has(pair)) {
+      add2({
+        code: "duplicate-edge",
+        severity: "warning",
+        message: `Edge "${edge.id}" repeats an existing connection.`,
+        path: ["edges", i],
+        edgeId: edge.id
+      });
+    }
+    seenPairs.add(pair);
+    if (edge.source === edge.target && (kind === "dag" || kind === "tree")) {
+      add2({
+        code: "self-loop",
+        message: `Edge "${edge.id}" connects node "${edge.source}" to itself, which a ${kind} does not allow.`,
+        path: ["edges", i],
+        edgeId: edge.id
+      });
+    }
+  });
+  if (kind === "dag" || kind === "tree") {
+    const cycle = findCycle(doc, index);
+    if (cycle && !(cycle.length === 1 && issues.some((issue) => issue.code === "self-loop"))) {
+      add2({
+        code: "cycle",
+        message: `The diagram has a cycle: ${[...cycle, cycle[0]].join(" -> ")}.`,
+        path: ["edges"],
+        nodeId: cycle[0]
+      });
+    }
+  }
+  if (kind === "tree") {
+    for (const [id, edges] of index.incoming) {
+      if (edges.length > 1) {
+        add2({
+          code: "multiple-parents",
+          message: `Node "${id}" has ${edges.length} incoming edges, but a tree node has one parent.`,
+          path: ["edges"],
+          nodeId: id
+        });
+      }
+    }
+  }
+  const errors = issues.filter((issue) => issue.severity === "error");
+  const warnings = issues.filter((issue) => issue.severity === "warning");
+  return { valid: errors.length === 0, issues, errors, warnings };
+}
+function hasParentLoop(index, id) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = id;
+  while (current !== void 0) {
+    if (seen.has(current)) return true;
+    seen.add(current);
+    current = index.nodesById.get(current)?.parentId;
+    if (current !== void 0 && !index.nodesById.has(current)) return false;
+  }
+  return false;
+}
+
+// src/geometry.ts
+var GRID_SIZE = 8;
+var DEFAULT_NODE_SIZE = {
+  start: { width: 128, height: 48 },
+  end: { width: 128, height: 48 },
+  task: { width: 176, height: 64 },
+  decision: { width: 160, height: 96 },
+  group: { width: 320, height: 200 },
+  subflow: { width: 320, height: 200 },
+  note: { width: 176, height: 96 },
+  image: { width: 160, height: 128 },
+  entity: { width: 192, height: 128 },
+  code: { width: 240, height: 128 },
+  chart: { width: 240, height: 160 },
+  agent: { width: 192, height: 80 }
+};
+var COLLAPSED_HEIGHT = 48;
+var TEXT_METRICS = { charWidth: 7, lineHeight: 20, nodePaddingX: 32, nodePaddingY: 24 };
+var roundUp = (value, step) => Math.ceil(value / step) * step;
+function estimateTextWidth(text, charWidth = TEXT_METRICS.charWidth) {
+  let units = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    units += code >= 11904 ? 2 : 1;
+  }
+  return units * charWidth;
+}
+function wrapText(text, maxWidth, charWidth = TEXT_METRICS.charWidth) {
+  const maxChars = Math.max(1, Math.floor(maxWidth / charWidth));
+  const lines = [];
+  for (const paragraph of text.split(/\r?\n/)) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      let rest = word;
+      while (rest.length > maxChars) {
+        if (line !== "") {
+          lines.push(line);
+          line = "";
+        }
+        lines.push(rest.slice(0, maxChars));
+        rest = rest.slice(maxChars);
+      }
+      const candidate = line === "" ? rest : `${line} ${rest}`;
+      if (candidate.length <= maxChars) line = candidate;
+      else {
+        lines.push(line);
+        line = rest;
+      }
+    }
+    lines.push(line);
+  }
+  return lines.length === 0 ? [""] : lines;
+}
+function dataList(node, key) {
+  const value = node.data?.[key];
+  return Array.isArray(value) ? value : [];
+}
+function getNodeSize(node) {
+  const base = DEFAULT_NODE_SIZE[node.kind] ?? DEFAULT_NODE_SIZE.task;
+  if (node.collapsed === true && isContainerKind(node.kind)) {
+    return { width: node.width ?? base.width, height: COLLAPSED_HEIGHT };
+  }
+  if (node.width !== void 0 && node.height !== void 0) return { width: node.width, height: node.height };
+  let { width, height } = base;
+  switch (node.kind) {
+    case "start":
+    case "end":
+    case "task":
+    case "agent":
+    case "note":
+    case "decision": {
+      const diamond = node.kind === "decision";
+      const usable = (w) => diamond ? w * 0.5 : w - TEXT_METRICS.nodePaddingX;
+      const needed = estimateTextWidth(node.label);
+      if (needed > usable(width)) {
+        const maxWidth = base.width * 2;
+        const wanted = diamond ? needed * 2 : needed + TEXT_METRICS.nodePaddingX;
+        width = Math.min(maxWidth, roundUp(wanted, 8));
+        const lines = wrapText(node.label, usable(width)).length;
+        const textHeight = lines * TEXT_METRICS.lineHeight;
+        height = Math.max(base.height, roundUp(diamond ? textHeight * 2 + 16 : textHeight + TEXT_METRICS.nodePaddingY + 8, 8));
+      }
+      break;
+    }
+    case "entity": {
+      const rows = dataList(node, "fields").length;
+      height = Math.max(base.height, roundUp(32 + rows * 24 + 8, 8));
+      break;
+    }
+    case "code": {
+      const code = typeof node.data?.code === "string" ? node.data.code : "";
+      const lines = Math.min(12, code === "" ? 0 : code.split(/\r?\n/).length);
+      height = Math.max(base.height, roundUp(40 + lines * TEXT_METRICS.lineHeight, 8));
+      break;
+    }
+    default:
+      break;
+  }
+  return { width: node.width ?? width, height: node.height ?? height };
+}
+function getNodeBounds(node) {
+  const size = getNodeSize(node);
+  return { x: node.position.x, y: node.position.y, ...size };
+}
+function rectCenter(rect) {
+  return { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+}
+function unionRects(rects) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const rect of rects) {
+    minX = Math.min(minX, rect.x);
+    minY = Math.min(minY, rect.y);
+    maxX = Math.max(maxX, rect.x + rect.width);
+    maxY = Math.max(maxY, rect.y + rect.height);
+  }
+  if (minX === Infinity) return { x: 0, y: 0, width: 0, height: 0 };
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function rectsIntersect(a, b) {
+  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+function rectContainsPoint(rect, point) {
+  return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+}
+function getAbsolutePositions(doc, index = buildIndex(doc)) {
+  const result = /* @__PURE__ */ new Map();
+  const resolve = (id) => {
+    const known = result.get(id);
+    if (known) return known;
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = index.nodesById.get(id);
+    let base = { x: 0, y: 0 };
+    while (current) {
+      if (seen.has(current.id)) break;
+      seen.add(current.id);
+      const cached = result.get(current.id);
+      if (cached) {
+        base = cached;
+        break;
+      }
+      chain.push(current);
+      current = current.parentId === void 0 ? void 0 : index.nodesById.get(current.parentId);
+    }
+    for (let i = chain.length - 1; i >= 0; i -= 1) {
+      const node = chain[i];
+      base = { x: base.x + node.position.x, y: base.y + node.position.y };
+      result.set(node.id, base);
+    }
+    return result.get(id) ?? base;
+  };
+  for (const node of doc.nodes) resolve(node.id);
+  return result;
+}
+function getAbsolutePosition(doc, id) {
+  return getAbsolutePositions(doc).get(id);
+}
+function getAbsoluteBounds(doc, index = buildIndex(doc)) {
+  const positions = getAbsolutePositions(doc, index);
+  const bounds = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    const at = positions.get(node.id) ?? node.position;
+    bounds.set(node.id, { x: at.x, y: at.y, ...getNodeSize(node) });
+  }
+  return bounds;
+}
+function getDocumentBounds(doc) {
+  return unionRects(getAbsoluteBounds(doc).values());
+}
+function snapValue(value, grid = GRID_SIZE) {
+  return grid > 0 ? Math.round(value / grid) * grid : value;
+}
+function snapPoint(point, grid = GRID_SIZE) {
+  return { x: snapValue(point.x, grid), y: snapValue(point.y, grid) };
+}
+function directionSides(direction) {
+  switch (direction) {
+    case "TB":
+      return { source: "bottom", target: "top" };
+    case "BT":
+      return { source: "top", target: "bottom" };
+    case "LR":
+      return { source: "right", target: "left" };
+    case "RL":
+      return { source: "left", target: "right" };
+  }
+}
+function mirrorDirection(direction, rtl) {
+  if (!rtl) return direction;
+  if (direction === "LR") return "RL";
+  if (direction === "RL") return "LR";
+  return direction;
+}
+function isHorizontal(direction) {
+  return direction === "LR" || direction === "RL";
+}
+function getPortPlacements(node, direction = "TB", rtl = false) {
+  const sides = directionSides(direction);
+  const mirror2 = (offset, side) => rtl && (side === "top" || side === "bottom") ? 1 - offset : offset;
+  if (!node.ports || node.ports.length === 0) {
+    const placements2 = [];
+    if (node.kind !== "start") placements2.push({ id: void 0, direction: "in", side: sides.target, offset: 0.5 });
+    if (node.kind !== "end") placements2.push({ id: void 0, direction: "out", side: sides.source, offset: 0.5 });
+    return placements2;
+  }
+  const placements = [];
+  for (const dir of ["in", "out"]) {
+    const ports = node.ports.filter((port) => port.direction === dir);
+    const side = dir === "in" ? sides.target : sides.source;
+    ports.forEach((port, i) => {
+      const placement = {
+        id: port.id,
+        direction: dir,
+        side,
+        offset: mirror2((i + 1) / (ports.length + 1), side)
+      };
+      if (port.type !== void 0) placement.type = port.type;
+      placements.push(placement);
+    });
+  }
+  return placements;
+}
+function sideAnchor(rect, side, offset = 0.5) {
+  switch (side) {
+    case "top":
+      return { x: rect.x + rect.width * offset, y: rect.y };
+    case "bottom":
+      return { x: rect.x + rect.width * offset, y: rect.y + rect.height };
+    case "left":
+      return { x: rect.x, y: rect.y + rect.height * offset };
+    case "right":
+      return { x: rect.x + rect.width, y: rect.y + rect.height * offset };
+  }
+}
+var SIDE_VECTOR = {
+  top: { x: 0, y: -1 },
+  right: { x: 1, y: 0 },
+  bottom: { x: 0, y: 1 },
+  left: { x: -1, y: 0 }
+};
+function sideVector(side) {
+  return SIDE_VECTOR[side];
+}
+var fmt = (value) => {
+  const rounded = Math.round(value * 100) / 100;
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+};
+var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+var scale = (a, k) => ({ x: a.x * k, y: a.y * k });
+var dot = (a, b) => a.x * b.x + a.y * b.y;
+var same = (a, b) => a.x === b.x && a.y === b.y;
+var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+function controlOffset(delta, curvature) {
+  return delta >= 0 ? 0.5 * delta : curvature * 25 * Math.sqrt(-delta);
+}
+function controlPoint(side, from, to, curvature) {
+  switch (side) {
+    case "left":
+      return { x: from.x - controlOffset(from.x - to.x, curvature), y: from.y };
+    case "right":
+      return { x: from.x + controlOffset(to.x - from.x, curvature), y: from.y };
+    case "top":
+      return { x: from.x, y: from.y - controlOffset(from.y - to.y, curvature) };
+    case "bottom":
+      return { x: from.x, y: from.y + controlOffset(to.y - from.y, curvature) };
+  }
+}
+function sidestep(a, b, gap) {
+  return Math.abs(a - b) >= gap * 2 ? (a + b) / 2 : Math.max(a, b) + gap * 2;
+}
+function orthogonalPoints(s, ss, t, ts, gap) {
+  const sv = SIDE_VECTOR[ss];
+  const tv = SIDE_VECTOR[ts];
+  const s1 = add(s, scale(sv, gap));
+  const t1 = add(t, scale(tv, gap));
+  const sVertical = sv.y !== 0;
+  const tVertical = tv.y !== 0;
+  let points;
+  if (sVertical === tVertical) {
+    const opposite = sv.x === -tv.x && sv.y === -tv.y;
+    if (opposite && dot(sub(t1, s1), sv) >= 0) {
+      if (sVertical) {
+        const y = (s.y + t.y) / 2;
+        points = [s, { x: s.x, y }, { x: t.x, y }, t];
+      } else {
+        const x = (s.x + t.x) / 2;
+        points = [s, { x, y: s.y }, { x, y: t.y }, t];
+      }
+    } else if (!opposite) {
+      if (sVertical) {
+        const y = sv.y > 0 ? Math.max(s1.y, t1.y) : Math.min(s1.y, t1.y);
+        points = [s, { x: s.x, y }, { x: t.x, y }, t];
+      } else {
+        const x = sv.x > 0 ? Math.max(s1.x, t1.x) : Math.min(s1.x, t1.x);
+        points = [s, { x, y: s.y }, { x, y: t.y }, t];
+      }
+    } else if (sVertical) {
+      const x = sidestep(s.x, t.x, gap);
+      points = [s, s1, { x, y: s1.y }, { x, y: t1.y }, t1, t];
+    } else {
+      const y = sidestep(s.y, t.y, gap);
+      points = [s, s1, { x: s1.x, y }, { x: t1.x, y }, t1, t];
+    }
+  } else if (sVertical) {
+    const corner = { x: s.x, y: t.y };
+    const leavesOk = dot(sub(corner, s), sv) >= gap;
+    const arrivesOk = dot(sub(t, corner), scale(tv, -1)) >= gap;
+    points = leavesOk && arrivesOk ? [s, corner, t] : [s, s1, { x: s1.x, y: t1.y }, t1, t];
+  } else {
+    const corner = { x: t.x, y: s.y };
+    const leavesOk = dot(sub(corner, s), sv) >= gap;
+    const arrivesOk = dot(sub(t, corner), scale(tv, -1)) >= gap;
+    points = leavesOk && arrivesOk ? [s, corner, t] : [s, s1, { x: t1.x, y: s1.y }, t1, t];
+  }
+  return simplify(points);
+}
+function simplify(points) {
+  const out = [];
+  for (const point of points) {
+    const last = out[out.length - 1];
+    if (last && same(last, point)) continue;
+    out.push(point);
+  }
+  for (let i = out.length - 2; i >= 1; i -= 1) {
+    const a = out[i - 1];
+    const b = out[i];
+    const c = out[i + 1];
+    if (a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y) out.splice(i, 1);
+  }
+  return out;
+}
+function polylineMidpoint(points) {
+  let total = 0;
+  for (let i = 1; i < points.length; i += 1) total += distance(points[i - 1], points[i]);
+  let remaining = total / 2;
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const length = distance(a, b);
+    if (remaining <= length && length > 0) {
+      const t = remaining / length;
+      return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+    }
+    remaining -= length;
+  }
+  return points[0] ?? { x: 0, y: 0 };
+}
+function polylinePath(points, radius) {
+  const first = points[0];
+  if (!first) return "";
+  let d = `M ${fmt(first.x)} ${fmt(first.y)}`;
+  for (let i = 1; i < points.length; i += 1) {
+    const prev = points[i - 1];
+    const current = points[i];
+    const next = points[i + 1];
+    if (radius > 0 && next) {
+      const r = Math.min(radius, distance(prev, current) / 2, distance(current, next) / 2);
+      const toPrev = sub(prev, current);
+      const toNext = sub(next, current);
+      const a = add(current, scale(toPrev, r / (distance(prev, current) || 1)));
+      const b = add(current, scale(toNext, r / (distance(current, next) || 1)));
+      d += ` L ${fmt(a.x)} ${fmt(a.y)} Q ${fmt(current.x)} ${fmt(current.y)} ${fmt(b.x)} ${fmt(b.y)}`;
+    } else {
+      d += ` L ${fmt(current.x)} ${fmt(current.y)}`;
+    }
+  }
+  return d;
+}
+function computeEdgePath(input) {
+  const { source, target, sourceSide, targetSide } = input;
+  const kind = input.kind ?? "smooth-step";
+  const offset = input.offset ?? 24;
+  const radius = input.radius ?? 8;
+  const curvature = input.curvature ?? 0.25;
+  if (input.loopSize !== void 0) {
+    const size = input.loopSize;
+    const bulge = sideVector(sourceSide).y !== 0 ? { x: 1, y: 0 } : { x: 0, y: 1 };
+    const c1 = add(add(source, scale(SIDE_VECTOR[sourceSide], size)), scale(bulge, size));
+    const c2 = add(add(target, scale(SIDE_VECTOR[targetSide], size)), scale(bulge, size));
+    const label = {
+      x: (source.x + 3 * c1.x + 3 * c2.x + target.x) / 8,
+      y: (source.y + 3 * c1.y + 3 * c2.y + target.y) / 8
+    };
+    return {
+      path: `M ${fmt(source.x)} ${fmt(source.y)} C ${fmt(c1.x)} ${fmt(c1.y)} ${fmt(c2.x)} ${fmt(c2.y)} ${fmt(target.x)} ${fmt(target.y)}`,
+      label,
+      points: [source, c1, c2, target]
+    };
+  }
+  if (kind === "straight") {
+    return {
+      path: `M ${fmt(source.x)} ${fmt(source.y)} L ${fmt(target.x)} ${fmt(target.y)}`,
+      label: { x: (source.x + target.x) / 2, y: (source.y + target.y) / 2 },
+      points: [source, target]
+    };
+  }
+  if (kind === "bezier") {
+    const c1 = controlPoint(sourceSide, source, target, curvature);
+    const c2 = controlPoint(targetSide, target, source, curvature);
+    return {
+      path: `M ${fmt(source.x)} ${fmt(source.y)} C ${fmt(c1.x)} ${fmt(c1.y)} ${fmt(c2.x)} ${fmt(c2.y)} ${fmt(target.x)} ${fmt(target.y)}`,
+      label: {
+        x: (source.x + 3 * c1.x + 3 * c2.x + target.x) / 8,
+        y: (source.y + 3 * c1.y + 3 * c2.y + target.y) / 8
+      },
+      points: [source, c1, c2, target]
+    };
+  }
+  const points = orthogonalPoints(source, sourceSide, target, targetSide, offset);
+  return {
+    path: polylinePath(points, kind === "smooth-step" ? radius : 0),
+    label: polylineMidpoint(points),
+    points
+  };
+}
+function createGeometryContext(doc, options = {}) {
+  const index = buildIndex(doc);
+  return {
+    doc,
+    index,
+    direction: options.direction ?? "TB",
+    rtl: options.rtl ?? false,
+    edgeKind: options.edgeKind ?? "smooth-step",
+    bounds: getAbsoluteBounds(doc, index)
+  };
+}
+function anchorFor(node, rect, wanted, portId, direction, rtl) {
+  const placements = getPortPlacements(node, direction, rtl);
+  const sides = directionSides(direction);
+  const match = placements.find((placement) => placement.direction === wanted && placement.id === portId) ?? placements.find((placement) => placement.direction === wanted && portId === void 0);
+  const side = match?.side ?? (wanted === "out" ? sides.source : sides.target);
+  return { point: sideAnchor(rect, side, match?.offset ?? 0.5), side };
+}
+function getEdgeGeometry(context, edge) {
+  const sourceNode = context.index.nodesById.get(edge.source);
+  const targetNode = context.index.nodesById.get(edge.target);
+  const sourceRect = context.bounds.get(edge.source);
+  const targetRect = context.bounds.get(edge.target);
+  if (!sourceNode || !targetNode || !sourceRect || !targetRect) return void 0;
+  const from = anchorFor(sourceNode, sourceRect, "out", edge.sourcePort, context.direction, context.rtl);
+  const to = anchorFor(targetNode, targetRect, "in", edge.targetPort, context.direction, context.rtl);
+  const selfLoop = edge.source === edge.target;
+  const halfExtent = sideVector(from.side).y !== 0 ? sourceRect.width / 2 : sourceRect.height / 2;
+  const path = computeEdgePath({
+    source: from.point,
+    target: to.point,
+    sourceSide: from.side,
+    targetSide: to.side,
+    kind: edge.kind ?? context.edgeKind,
+    ...selfLoop ? { loopSize: Math.ceil(halfExtent / 0.75) + 24 } : {}
+  });
+  return { ...path, source: from.point, target: to.point, sourceSide: from.side, targetSide: to.side, selfLoop };
+}
+function getReadingOrder(doc, options = {}) {
+  const { direction = "TB", rtl = false, tolerance = 24 } = options;
+  const index = buildIndex(doc);
+  const horizontal = isHorizontal(direction);
+  const primarySign = direction === "BT" || direction === "RL" ? -1 : 1;
+  const secondarySign = horizontal ? 1 : rtl ? -1 : 1;
+  const sortSiblings = (ids) => {
+    const entries = ids.map((id) => {
+      const node = index.nodesById.get(id);
+      const c = rectCenter(getNodeBounds(node));
+      return { id, p: (horizontal ? c.x : c.y) * primarySign, s: (horizontal ? c.y : c.x) * secondarySign };
+    });
+    entries.sort((a, b) => a.p - b.p);
+    const rows = [];
+    let anchor = -Infinity;
+    for (const entry of entries) {
+      const row = rows[rows.length - 1];
+      if (row && entry.p - anchor <= tolerance) row.push(entry);
+      else {
+        rows.push([entry]);
+        anchor = entry.p;
+      }
+    }
+    return rows.flatMap((row) => row.sort((a, b) => a.s - b.s).map((entry) => entry.id));
+  };
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (visited.has(id)) return;
+    visited.add(id);
+    result.push(id);
+    const kids = index.children.get(id);
+    if (kids) for (const child of sortSiblings(kids)) visit(child);
+  };
+  const roots = doc.nodes.filter((node) => node.parentId === void 0 || !index.nodesById.has(node.parentId) || node.parentId === node.id).map((node) => node.id);
+  for (const id of sortSiblings(roots)) visit(id);
+  for (const node of doc.nodes) visit(node.id);
+  return result;
+}
+var FOCUS_VECTOR = {
+  up: { x: 0, y: -1 },
+  down: { x: 0, y: 1 },
+  left: { x: -1, y: 0 },
+  right: { x: 1, y: 0 }
+};
+function findDirectionalNeighbor(doc, fromId, direction, options = {}) {
+  const index = buildIndex(doc);
+  const bounds = getAbsoluteBounds(doc, index);
+  const origin = bounds.get(fromId);
+  if (!origin) return void 0;
+  const from = rectCenter(origin);
+  const vector = FOCUS_VECTOR[direction];
+  const connected = new Set(getNeighbors(index, fromId));
+  const allowed = options.candidates === void 0 ? void 0 : new Set(options.candidates);
+  let best;
+  for (const node of doc.nodes) {
+    if (node.id === fromId || allowed && !allowed.has(node.id)) continue;
+    const rect = bounds.get(node.id);
+    if (!rect) continue;
+    const delta = sub(rectCenter(rect), from);
+    const along = dot(delta, vector);
+    const across = Math.abs(delta.x * vector.y - delta.y * vector.x);
+    if (along <= 0 || across > along * 2) continue;
+    const score = along + across * 2;
+    const linked = connected.has(node.id);
+    if (!best || linked && !best.linked || linked === best.linked && score < best.score) {
+      best = { id: node.id, score, linked };
+    }
+  }
+  return best?.id;
+}
+
+// src/mutations.ts
+var DiagramMutationError = class extends Error {
+  code;
+  /** For `invalid-connection`: the `ConnectionRejection` code. */
+  detail;
+  constructor(code, message, detail) {
+    super(message);
+    this.name = "DiagramMutationError";
+    this.code = code;
+    if (detail !== void 0) this.detail = detail;
+  }
+};
+var withoutUndefined = (value) => {
+  const result = { ...value };
+  for (const key of Object.keys(result)) if (result[key] === void 0) delete result[key];
+  return result;
+};
+function nextNodeId(doc, prefix = "node") {
+  return nextId(
+    doc.nodes.map((node) => node.id),
+    prefix
+  );
+}
+function nextEdgeId(doc, prefix = "edge") {
+  return nextId(
+    doc.edges.map((edge) => edge.id),
+    prefix
+  );
+}
+function createNode(doc, input) {
+  const id = input.id ?? nextNodeId(doc, input.kind);
+  return withoutUndefined({
+    ...input,
+    id,
+    label: input.label ?? "",
+    position: input.position ?? { x: 0, y: 0 }
+  });
+}
+function requireContainer(doc, parentId) {
+  const parent = doc.nodes.find((node) => node.id === parentId);
+  if (!parent) throw new DiagramMutationError("parent-not-found", `Parent node "${parentId}" does not exist.`);
+  if (!isContainerKind(parent.kind)) {
+    throw new DiagramMutationError("parent-not-container", `Node "${parentId}" is a ${parent.kind}, not a group or subflow.`);
+  }
+}
+function addNode(doc, input) {
+  const node = createNode(doc, input);
+  if (doc.nodes.some((existing) => existing.id === node.id)) {
+    throw new DiagramMutationError("duplicate-id", `A node with id "${node.id}" already exists.`);
+  }
+  if (node.parentId !== void 0) requireContainer(doc, node.parentId);
+  return { ...doc, nodes: [...doc.nodes, node] };
+}
+function updateNode(doc, id, patch) {
+  const current = doc.nodes.find((node) => node.id === id);
+  if (!current) throw new DiagramMutationError("node-not-found", `No node with id "${id}".`);
+  const resolved = typeof patch === "function" ? patch(current) : patch;
+  const { ...rest } = resolved;
+  delete rest.id;
+  if (rest.parentId !== void 0) requireContainer(doc, rest.parentId);
+  const next = withoutUndefined({ ...current, ...rest });
+  return { ...doc, nodes: doc.nodes.map((node) => node === current ? next : node) };
+}
+function removeNodes(doc, ids, options = {}) {
+  const index = buildIndex(doc);
+  const removed = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!index.nodesById.has(id)) continue;
+    removed.add(id);
+    if (options.children === "remove") for (const descendant of getDescendants(index, id)) removed.add(descendant);
+  }
+  if (removed.size === 0) return doc;
+  const nodes = [];
+  for (const node of doc.nodes) {
+    if (removed.has(node.id)) continue;
+    if (node.parentId !== void 0 && removed.has(node.parentId)) {
+      let x = node.position.x;
+      let y = node.position.y;
+      let parentId = node.parentId;
+      const seen = /* @__PURE__ */ new Set();
+      while (parentId !== void 0 && removed.has(parentId) && !seen.has(parentId)) {
+        seen.add(parentId);
+        const parent = index.nodesById.get(parentId);
+        x += parent.position.x;
+        y += parent.position.y;
+        parentId = parent.parentId;
+      }
+      const released = { ...node, position: { x, y } };
+      if (parentId === void 0 || removed.has(parentId)) delete released.parentId;
+      else released.parentId = parentId;
+      nodes.push(released);
+    } else {
+      nodes.push(node);
+    }
+  }
+  const edges = doc.edges.filter((edge) => !removed.has(edge.source) && !removed.has(edge.target));
+  return { ...doc, nodes, edges };
+}
+function removeNode(doc, id, options = {}) {
+  if (!doc.nodes.some((node) => node.id === id)) throw new DiagramMutationError("node-not-found", `No node with id "${id}".`);
+  return removeNodes(doc, [id], options);
+}
+function moveNodes(doc, positions) {
+  let changed = false;
+  const nodes = doc.nodes.map((node) => {
+    const next = positions[node.id];
+    if (!next || next.x === node.position.x && next.y === node.position.y) return node;
+    changed = true;
+    return { ...node, position: { x: next.x, y: next.y } };
+  });
+  return changed ? { ...doc, nodes } : doc;
+}
+function translateNodes(doc, ids, dx, dy) {
+  const wanted = new Set(ids);
+  if (dx === 0 && dy === 0 || wanted.size === 0) return doc;
+  const nodes = doc.nodes.map((node) => {
+    if (!wanted.has(node.id)) return node;
+    return { ...node, position: { x: node.position.x + dx, y: node.position.y + dy } };
+  });
+  return { ...doc, nodes };
+}
+function resizeNode(doc, id, size, position) {
+  return updateNode(doc, id, { width: size.width, height: size.height, ...position ? { position } : {} });
+}
+function setNodeParent(doc, id, parentId) {
+  const index = buildIndex(doc);
+  const node = index.nodesById.get(id);
+  if (!node) throw new DiagramMutationError("node-not-found", `No node with id "${id}".`);
+  if (parentId !== void 0) {
+    requireContainer(doc, parentId);
+    if (parentId === id || getAncestors(index, parentId).includes(id)) {
+      throw new DiagramMutationError("cannot-group", "A group cannot be moved inside itself.");
+    }
+  }
+  const absolute = getAbsolutePositions(doc, index);
+  const at = absolute.get(id);
+  const base = parentId === void 0 ? { x: 0, y: 0 } : absolute.get(parentId);
+  const next = { ...node, position: { x: at.x - base.x, y: at.y - base.y } };
+  if (parentId === void 0) delete next.parentId;
+  else next.parentId = parentId;
+  return { ...doc, nodes: doc.nodes.map((candidate) => candidate === node ? next : candidate) };
+}
+function connect(doc, input, options = {}) {
+  const { validate = true, ...rules } = options;
+  if (validate) {
+    const check = checkConnection(doc, input, rules);
+    if (!check.ok) throw new DiagramMutationError("invalid-connection", check.message, check.code);
+  }
+  const id = input.id ?? nextEdgeId(doc);
+  if (doc.edges.some((edge2) => edge2.id === id)) {
+    throw new DiagramMutationError("duplicate-id", `An edge with id "${id}" already exists.`);
+  }
+  const edge = withoutUndefined({ ...input, id });
+  return { ...doc, edges: [...doc.edges, edge] };
+}
+function disconnect(doc, target) {
+  if (typeof target === "string") {
+    if (!doc.edges.some((edge) => edge.id === target)) {
+      throw new DiagramMutationError("edge-not-found", `No edge with id "${target}".`);
+    }
+    return { ...doc, edges: doc.edges.filter((edge) => edge.id !== target) };
+  }
+  const edges = doc.edges.filter(
+    (edge) => !(edge.source === target.source && edge.target === target.target && (target.sourcePort === void 0 || edge.sourcePort === target.sourcePort) && (target.targetPort === void 0 || edge.targetPort === target.targetPort))
+  );
+  return edges.length === doc.edges.length ? doc : { ...doc, edges };
+}
+function removeEdges(doc, ids) {
+  const wanted = new Set(ids);
+  if (wanted.size === 0) return doc;
+  const edges = doc.edges.filter((edge) => !wanted.has(edge.id));
+  return edges.length === doc.edges.length ? doc : { ...doc, edges };
+}
+function updateEdge(doc, id, patch) {
+  const current = doc.edges.find((edge) => edge.id === id);
+  if (!current) throw new DiagramMutationError("edge-not-found", `No edge with id "${id}".`);
+  const next = withoutUndefined({ ...current, ...patch, id });
+  return { ...doc, edges: doc.edges.map((edge) => edge === current ? next : edge) };
+}
+function groupNodes(doc, ids, options = {}) {
+  const index = buildIndex(doc);
+  const selected = /* @__PURE__ */ new Set();
+  for (const id2 of ids) if (index.nodesById.has(id2)) selected.add(id2);
+  const members = [...selected].filter((id2) => !getAncestors(index, id2).some((ancestor) => selected.has(ancestor)));
+  if (members.length === 0) throw new DiagramMutationError("cannot-group", "Select at least one node to group.");
+  const parents = new Set(members.map((id2) => index.nodesById.get(id2)?.parentId));
+  if (parents.size > 1) throw new DiagramMutationError("cannot-group", "Nodes must share the same parent to be grouped.");
+  const parentId = [...parents][0];
+  const kind = options.kind ?? "group";
+  const padding = options.padding ?? 32;
+  const header = options.header ?? 40;
+  const id = options.id ?? nextNodeId(doc, kind);
+  if (index.nodesById.has(id)) throw new DiagramMutationError("duplicate-id", `A node with id "${id}" already exists.`);
+  const bounds = getAbsoluteBounds(doc, index);
+  const box = unionRects(members.map((member) => bounds.get(member)));
+  const groupAbsolute = { x: box.x - padding, y: box.y - padding - header };
+  const parentAbsolute = parentId === void 0 ? { x: 0, y: 0 } : getAbsolutePositions(doc, index).get(parentId);
+  const group = {
+    id,
+    kind,
+    label: options.label ?? "",
+    position: { x: groupAbsolute.x - parentAbsolute.x, y: groupAbsolute.y - parentAbsolute.y },
+    width: box.width + padding * 2,
+    height: box.height + padding * 2 + header
+  };
+  if (parentId !== void 0) group.parentId = parentId;
+  const memberSet = new Set(members);
+  const nodes = [];
+  let inserted = false;
+  for (const node of doc.nodes) {
+    if (memberSet.has(node.id)) {
+      if (!inserted) {
+        nodes.push(group);
+        inserted = true;
+      }
+      const at = bounds.get(node.id);
+      nodes.push({ ...node, parentId: id, position: { x: at.x - groupAbsolute.x, y: at.y - groupAbsolute.y } });
+    } else {
+      nodes.push(node);
+    }
+  }
+  return { ...doc, nodes };
+}
+function ungroupNode(doc, groupId) {
+  return removeNode(doc, groupId, { children: "release" });
+}
+function extractFragment(doc, ids) {
+  const index = buildIndex(doc);
+  const wanted = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!index.nodesById.has(id)) continue;
+    wanted.add(id);
+    for (const descendant of getDescendants(index, id)) wanted.add(descendant);
+  }
+  const absolute = getAbsolutePositions(doc, index);
+  const nodes = [];
+  for (const node of doc.nodes) {
+    if (!wanted.has(node.id)) continue;
+    if (node.parentId !== void 0 && wanted.has(node.parentId)) {
+      nodes.push(structuredClone(node));
+    } else {
+      const copy = structuredClone(node);
+      delete copy.parentId;
+      const at = absolute.get(node.id);
+      copy.position = { x: at.x, y: at.y };
+      nodes.push(copy);
+    }
+  }
+  const edges = doc.edges.filter((edge) => wanted.has(edge.source) && wanted.has(edge.target)).map((edge) => structuredClone(edge));
+  return { nodes, edges };
+}
+function pasteFragment(doc, fragment, options = {}) {
+  const offset = options.offset ?? { x: 24, y: 24 };
+  if (options.parentId !== void 0) requireContainer(doc, options.parentId);
+  const parentAbsolute = options.parentId === void 0 ? { x: 0, y: 0 } : getAbsolutePositions(doc).get(options.parentId);
+  const nodeIds = createIdAllocator(doc.nodes.map((node) => node.id));
+  const edgeIds = createIdAllocator(doc.edges.map((edge) => edge.id));
+  const idMap = {};
+  for (const node of fragment.nodes) idMap[node.id] = nodeIds.next(idStem(node.id, node.kind));
+  const fragmentIds = new Set(fragment.nodes.map((node) => node.id));
+  const rootIds = [];
+  const nodes = fragment.nodes.map((node) => {
+    const copy = structuredClone(node);
+    copy.id = idMap[node.id];
+    if (node.parentId !== void 0 && fragmentIds.has(node.parentId)) {
+      copy.parentId = idMap[node.parentId];
+    } else {
+      delete copy.parentId;
+      if (options.parentId !== void 0) copy.parentId = options.parentId;
+      copy.position = {
+        x: node.position.x + offset.x - parentAbsolute.x,
+        y: node.position.y + offset.y - parentAbsolute.y
+      };
+      rootIds.push(copy.id);
+    }
+    return copy;
+  });
+  const edges = fragment.edges.filter((edge) => fragmentIds.has(edge.source) && fragmentIds.has(edge.target)).map((edge) => {
+    const copy = structuredClone(edge);
+    copy.id = edgeIds.next(idStem(edge.id, "edge"));
+    copy.source = idMap[edge.source];
+    copy.target = idMap[edge.target];
+    return copy;
+  });
+  return {
+    document: { ...doc, nodes: [...doc.nodes, ...nodes], edges: [...doc.edges, ...edges] },
+    nodeIds: nodes.map((node) => node.id),
+    rootIds,
+    edgeIds: edges.map((edge) => edge.id),
+    idMap
+  };
+}
+function duplicateNodes(doc, ids, options = {}) {
+  const selected = [...ids];
+  const index = buildIndex(doc);
+  const fragment = extractFragment(doc, selected);
+  const parents = new Set(
+    selected.filter((id) => index.nodesById.has(id)).map((id) => index.nodesById.get(id)?.parentId)
+  );
+  const parentId = parents.size === 1 ? [...parents][0] : void 0;
+  return pasteFragment(doc, fragment, { ...parentId !== void 0 ? { parentId } : {}, ...options });
+}
+function setAbsolute(doc, targets) {
+  const absolute = getAbsolutePositions(doc);
+  const nodes = doc.nodes.map((node) => {
+    const target = targets.get(node.id);
+    if (!target) return node;
+    const parent = node.parentId === void 0 ? void 0 : absolute.get(node.parentId);
+    return { ...node, position: { x: target.x - (parent?.x ?? 0), y: target.y - (parent?.y ?? 0) } };
+  });
+  return { ...doc, nodes };
+}
+function alignNodes(doc, ids, alignment) {
+  const bounds = getAbsoluteBounds(doc);
+  const rects = [...new Set(ids)].flatMap((id) => {
+    const rect = bounds.get(id);
+    return rect ? [{ id, rect }] : [];
+  });
+  if (rects.length < 2) return doc;
+  const box = unionRects(rects.map((entry) => entry.rect));
+  const targets = /* @__PURE__ */ new Map();
+  for (const { id, rect } of rects) {
+    let { x, y } = rect;
+    if (alignment === "left") x = box.x;
+    else if (alignment === "right") x = box.x + box.width - rect.width;
+    else if (alignment === "center") x = box.x + (box.width - rect.width) / 2;
+    else if (alignment === "top") y = box.y;
+    else if (alignment === "bottom") y = box.y + box.height - rect.height;
+    else y = box.y + (box.height - rect.height) / 2;
+    targets.set(id, { x, y });
+  }
+  return setAbsolute(doc, targets);
+}
+function distributeNodes(doc, ids, axis) {
+  const bounds = getAbsoluteBounds(doc);
+  const horizontal = axis === "horizontal";
+  const entries = [...new Set(ids)].flatMap((id) => {
+    const rect = bounds.get(id);
+    return rect ? [{ id, rect }] : [];
+  }).sort((a, b) => horizontal ? a.rect.x - b.rect.x : a.rect.y - b.rect.y);
+  if (entries.length < 3) return doc;
+  const first = entries[0];
+  const last = entries[entries.length - 1];
+  const total = horizontal ? last.rect.x + last.rect.width - first.rect.x : last.rect.y + last.rect.height - first.rect.y;
+  const occupied = entries.reduce((sum, entry) => sum + (horizontal ? entry.rect.width : entry.rect.height), 0);
+  const gap = (total - occupied) / (entries.length - 1);
+  const targets = /* @__PURE__ */ new Map();
+  let cursor = horizontal ? first.rect.x : first.rect.y;
+  for (const { id, rect } of entries) {
+    targets.set(id, horizontal ? { x: cursor, y: rect.y } : { x: rect.x, y: cursor });
+    cursor += (horizontal ? rect.width : rect.height) + gap;
+  }
+  return setAbsolute(doc, targets);
+}
+
+// src/layout.ts
+import { Graph, layout as dagreLayout } from "@dagrejs/dagre";
+import { cluster, hierarchy, tree } from "d3-hierarchy";
+var ROOT = "\0root";
+var VIRTUAL = "\0virtual";
+function layoutDiagram(doc, options = {}) {
+  const algorithm = options.algorithm ?? "layered";
+  const rtl = options.rtl ?? false;
+  const direction = mirrorDirection(options.direction ?? "TB", rtl);
+  const spacing = typeof options.spacing === "number" ? { node: options.spacing } : options.spacing ?? {};
+  const resolved = {
+    algorithm,
+    direction,
+    rtl,
+    nodeSep: spacing.node ?? 48,
+    rankSep: spacing.rank ?? 80,
+    pad: spacing.group ?? 32,
+    header: options.groupHeader ?? 40,
+    grid: options.grid ?? GRID_SIZE,
+    options
+  };
+  const index = buildIndex(doc);
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    let parent = node.parentId !== node.id && node.parentId !== void 0 && index.nodesById.has(node.parentId) ? node.parentId : void 0;
+    const seen = /* @__PURE__ */ new Set([node.id]);
+    for (let walker = parent; walker !== void 0; walker = index.nodesById.get(walker)?.parentId) {
+      if (seen.has(walker)) {
+        parent = void 0;
+        break;
+      }
+      seen.add(walker);
+    }
+    parentOf.set(node.id, parent);
+  }
+  const kidsOf = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    const key = parentOf.get(node.id) ?? ROOT;
+    const list = kidsOf.get(key);
+    if (list) list.push(node.id);
+    else kidsOf.set(key, [node.id]);
+  }
+  const pathTo = (id) => {
+    const chain = [id];
+    for (let p = parentOf.get(id); p !== void 0; p = parentOf.get(p)) chain.push(p);
+    return chain.reverse();
+  };
+  const levelEdges = /* @__PURE__ */ new Map();
+  for (const edge of doc.edges) {
+    if (edge.source === edge.target || !index.nodesById.has(edge.source) || !index.nodesById.has(edge.target)) continue;
+    const a = pathTo(edge.source);
+    const b = pathTo(edge.target);
+    let common = 0;
+    while (common < a.length && common < b.length && a[common] === b[common]) common += 1;
+    if (common === a.length || common === b.length) continue;
+    const level = common === 0 ? ROOT : a[common - 1];
+    const ua = a[common];
+    const ub = b[common];
+    const map = levelEdges.get(level) ?? /* @__PURE__ */ new Map();
+    levelEdges.set(level, map);
+    const key = `${ua}\0${ub}`;
+    const existing = map.get(key);
+    const labelWidth = edge.label ? estimateTextWidth(edge.label) + 16 : 0;
+    const labelHeight = edge.label ? 24 : 0;
+    if (existing) {
+      existing.labelWidth = Math.max(existing.labelWidth, labelWidth);
+      existing.labelHeight = Math.max(existing.labelHeight, labelHeight);
+    } else {
+      map.set(key, { source: ua, target: ub, labelWidth, labelHeight });
+    }
+  }
+  const positions = {};
+  const sizes = {};
+  const fitted = /* @__PURE__ */ new Map();
+  const layoutLevel = (parent) => {
+    const kids = kidsOf.get(parent) ?? [];
+    for (const kid of kids) {
+      if (!kidsOf.has(kid)) continue;
+      const content = layoutLevel(kid);
+      const width = snapUp(content.width + resolved.pad * 2, resolved.grid);
+      const height = snapUp(content.height + resolved.pad * 2 + resolved.header, resolved.grid);
+      const collapsed = index.nodesById.get(kid)?.collapsed === true;
+      fitted.set(kid, collapsed ? { width, height: COLLAPSED_HEIGHT } : { width, height });
+      sizes[kid] = { width, height };
+      for (const child of kidsOf.get(kid) ?? []) {
+        const at = positions[child];
+        positions[child] = { x: at.x + resolved.pad, y: at.y + resolved.pad + resolved.header };
+      }
+    }
+    const items = kids.map((id) => {
+      const size = fitted.get(id) ?? getNodeSize(index.nodesById.get(id));
+      return { id, width: size.width, height: size.height };
+    });
+    const edges = [...levelEdges.get(parent)?.values() ?? []];
+    let placement = place(items, edges, resolved);
+    placement = normalize(placement, items, resolved);
+    const mirrorX = resolved.rtl && (algorithm === "radial" || !isHorizontal(options.direction ?? "TB"));
+    if (mirrorX) placement = mirror(placement, items);
+    placement = normalize(placement, items, resolved);
+    for (const item of items) {
+      const at = placement.get(item.id);
+      positions[item.id] = { x: at.x, y: at.y };
+    }
+    return extent(placement, items);
+  };
+  layoutLevel(ROOT);
+  const origin = options.origin ?? { x: 0, y: 0 };
+  for (const id of kidsOf.get(ROOT) ?? []) {
+    const at = positions[id];
+    positions[id] = { x: at.x + origin.x, y: at.y + origin.y };
+  }
+  const absolute = /* @__PURE__ */ new Map();
+  const resolveAbsolute = (id) => {
+    const known = absolute.get(id);
+    if (known) return known;
+    const own = positions[id];
+    const parent = parentOf.get(id);
+    const base = parent === void 0 ? { x: 0, y: 0 } : resolveAbsolute(parent);
+    const result = { x: base.x + own.x, y: base.y + own.y };
+    absolute.set(id, result);
+    return result;
+  };
+  const rects = [];
+  for (const node of doc.nodes) {
+    const at = resolveAbsolute(node.id);
+    const size = fitted.get(node.id) ?? getNodeSize(node);
+    rects.push({ x: at.x, y: at.y, ...size });
+  }
+  return { positions, sizes, bounds: unionRects(rects), algorithm, direction };
+}
+function applyLayout(doc, result) {
+  return {
+    ...doc,
+    nodes: doc.nodes.map((node) => {
+      const position = result.positions[node.id];
+      const size = result.sizes[node.id];
+      if (!position && !size) return node;
+      return { ...node, ...position ? { position: { ...position } } : {}, ...size ? { width: size.width, height: size.height } : {} };
+    })
+  };
+}
+function layoutedDiagram(doc, options = {}) {
+  return applyLayout(doc, layoutDiagram(doc, options));
+}
+function snapUp(value, grid) {
+  return grid > 0 ? Math.ceil(value / grid) * grid : value;
+}
+function extent(placement, items) {
+  let width = 0;
+  let height = 0;
+  for (const item of items) {
+    const at = placement.get(item.id);
+    width = Math.max(width, at.x + item.width);
+    height = Math.max(height, at.y + item.height);
+  }
+  return { width, height };
+}
+function normalize(placement, items, resolved) {
+  let minX = Infinity;
+  let minY = Infinity;
+  for (const item of items) {
+    const at = placement.get(item.id);
+    minX = Math.min(minX, at.x);
+    minY = Math.min(minY, at.y);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const at = placement.get(item.id);
+    result.set(item.id, {
+      x: snapValue(at.x - (minX === Infinity ? 0 : minX), resolved.grid),
+      y: snapValue(at.y - (minY === Infinity ? 0 : minY), resolved.grid)
+    });
+  }
+  return result;
+}
+function mirror(placement, items) {
+  let right = 0;
+  for (const item of items) right = Math.max(right, placement.get(item.id).x + item.width);
+  const result = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const at = placement.get(item.id);
+    result.set(item.id, { x: right - (at.x + item.width), y: at.y });
+  }
+  return result;
+}
+function place(items, edges, resolved) {
+  if (items.length === 0) return /* @__PURE__ */ new Map();
+  switch (resolved.algorithm) {
+    case "tree":
+      return placeTree(items, edges, resolved);
+    case "radial":
+      return placeRadial(items, edges, resolved);
+    case "grid":
+      return placeGrid(items, resolved);
+    case "layered":
+      return placeLayered(items, edges, resolved);
+  }
+}
+var LARGE_LEVEL = 400;
+function placeLayered(items, edges, resolved) {
+  const graph = new Graph();
+  const ranker = resolved.options.ranker ?? (items.length + edges.length > LARGE_LEVEL ? "tight-tree" : "network-simplex");
+  graph.setGraph({
+    rankdir: resolved.direction,
+    nodesep: resolved.nodeSep,
+    ranksep: resolved.rankSep,
+    edgesep: Math.max(8, Math.round(resolved.nodeSep / 2)),
+    marginx: 0,
+    marginy: 0,
+    ranker
+  });
+  graph.setDefaultEdgeLabel(() => ({}));
+  for (const item of [...items].reverse()) graph.setNode(item.id, { width: item.width, height: item.height });
+  for (const edge of [...edges].reverse()) {
+    graph.setEdge(
+      edge.source,
+      edge.target,
+      edge.labelWidth > 0 ? { width: edge.labelWidth, height: edge.labelHeight, labelpos: "c" } : {}
+    );
+  }
+  dagreLayout(graph);
+  const placement = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const laid = graph.node(item.id);
+    placement.set(item.id, laid ? { x: laid.x - item.width / 2, y: laid.y - item.height / 2 } : { x: 0, y: 0 });
+  }
+  return placement;
+}
+function buildForest(items, edges, rootId) {
+  const known = new Set(items.map((item) => item.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    const list = outgoing.get(edge.source);
+    if (list) list.push(edge.target);
+    else outgoing.set(edge.source, [edge.target]);
+    hasIncoming.add(edge.target);
+  }
+  const assigned = /* @__PURE__ */ new Set();
+  const forest = [];
+  const grow = (id) => {
+    if (assigned.has(id)) return;
+    assigned.add(id);
+    const root = { id, children: [] };
+    const lookup = /* @__PURE__ */ new Map([[id, root]]);
+    const queue = [id];
+    for (let head = 0; head < queue.length; head += 1) {
+      const current = queue[head];
+      const parent = lookup.get(current);
+      for (const target of outgoing.get(current) ?? []) {
+        if (assigned.has(target)) continue;
+        assigned.add(target);
+        const child = { id: target, children: [] };
+        parent.children.push(child);
+        lookup.set(target, child);
+        queue.push(target);
+      }
+    }
+    forest.push(root);
+  };
+  if (rootId !== void 0 && known.has(rootId)) grow(rootId);
+  for (const item of items) if (!hasIncoming.has(item.id)) grow(item.id);
+  for (const item of items) grow(item.id);
+  return forest;
+}
+function runTreeLayout(items, edges, resolved, separation) {
+  const forest = buildForest(items, edges, resolved.options.root);
+  const virtual = forest.length > 1;
+  const top = virtual ? { id: VIRTUAL, children: forest } : forest[0];
+  const root = hierarchy(top, (d) => d.children);
+  const laid = resolved.options.treeVariant === "cluster" ? cluster().nodeSize([1, 1]).separation(separation)(root) : tree().nodeSize([1, 1]).separation(separation)(root);
+  return { root: laid, virtual };
+}
+function placeTree(items, edges, resolved) {
+  const sizes = new Map(items.map((item) => [item.id, item]));
+  const horizontal = isHorizontal(resolved.direction);
+  const breadthOf = (id) => {
+    const item = sizes.get(id);
+    return item ? horizontal ? item.height : item.width : 0;
+  };
+  const depthExtentOf = (id) => {
+    const item = sizes.get(id);
+    return item ? horizontal ? item.width : item.height : 0;
+  };
+  const { root, virtual } = runTreeLayout(
+    items,
+    edges,
+    resolved,
+    (a, b) => (breadthOf(a.data.id) + breadthOf(b.data.id)) / 2 + resolved.nodeSep
+  );
+  const nodes = root.descendants().filter((node) => node.data.id !== VIRTUAL);
+  const base = virtual ? 1 : 0;
+  const maxDepth = Math.max(0, ...nodes.map((node) => node.depth - base));
+  const levelOf = (node) => resolved.options.treeVariant === "cluster" && !node.children ? maxDepth : node.depth - base;
+  const thickness = Array.from({ length: maxDepth + 1 }, () => 0);
+  for (const node of nodes) {
+    const level = levelOf(node);
+    thickness[level] = Math.max(thickness[level], depthExtentOf(node.data.id));
+  }
+  const centers = [];
+  let cursor = 0;
+  for (const level of thickness) {
+    centers.push(cursor + level / 2);
+    cursor += level + resolved.rankSep;
+  }
+  const total = cursor - resolved.rankSep;
+  const placement = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const item = sizes.get(node.data.id);
+    let along = centers[levelOf(node)];
+    if (resolved.direction === "BT" || resolved.direction === "RL") along = total - along;
+    const breadth = node.x;
+    const center = horizontal ? { x: along, y: breadth } : { x: breadth, y: along };
+    placement.set(item.id, { x: center.x - item.width / 2, y: center.y - item.height / 2 });
+  }
+  return placement;
+}
+function placeRadial(items, edges, resolved) {
+  const sizes = new Map(items.map((item) => [item.id, item]));
+  const thick = (id) => {
+    const item = sizes.get(id);
+    return item ? Math.max(item.width, item.height) : 0;
+  };
+  const { root } = runTreeLayout(items, edges, resolved, (a, b) => a.parent === b.parent ? 1 : 2);
+  const nodes = root.descendants();
+  const xs = nodes.map((node) => node.x);
+  const minX = Math.min(...xs);
+  const span = Math.max(...xs) - minX;
+  const slots = span + 2;
+  const maxDepth = Math.max(...nodes.map((node) => node.depth));
+  const widest = Array.from({ length: maxDepth + 1 }, () => 0);
+  for (const node of nodes) widest[node.depth] = Math.max(widest[node.depth], thick(node.data.id));
+  const radius = [0];
+  for (let depth = 1; depth <= maxDepth; depth += 1) {
+    const previous = radius[depth - 1];
+    const current = widest[depth];
+    const fromInside = previous + resolved.rankSep + (widest[depth - 1] + current) / 2;
+    const fromCircumference = slots * (current + resolved.nodeSep) / (2 * Math.PI);
+    radius.push(Math.max(fromInside, fromCircumference));
+  }
+  const placement = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.data.id === VIRTUAL) continue;
+    const item = sizes.get(node.data.id);
+    const angle = (node.x - minX) / slots * 2 * Math.PI - Math.PI / 2;
+    const r = radius[node.depth];
+    placement.set(item.id, {
+      x: r * Math.cos(angle) - item.width / 2,
+      y: r * Math.sin(angle) - item.height / 2
+    });
+  }
+  return placement;
+}
+function placeGrid(items, resolved) {
+  const perLine = Math.max(1, Math.floor(resolved.options.columns ?? Math.ceil(Math.sqrt(items.length))));
+  const horizontal = isHorizontal(resolved.direction);
+  const lineCount = Math.ceil(items.length / perLine);
+  const at = (i) => ({ line: Math.floor(i / perLine), slot: i % perLine });
+  const lineThickness = Array.from({ length: lineCount }, () => 0);
+  const slotThickness = Array.from({ length: perLine }, () => 0);
+  items.forEach((item, i) => {
+    const { line, slot } = at(i);
+    lineThickness[line] = Math.max(lineThickness[line], horizontal ? item.width : item.height);
+    slotThickness[slot] = Math.max(slotThickness[slot], horizontal ? item.height : item.width);
+  });
+  const offsets = (sizes, gap) => {
+    let cursor = 0;
+    return sizes.map((size) => {
+      const start = cursor;
+      cursor += size + gap;
+      return start;
+    });
+  };
+  const lineStart = offsets(lineThickness, resolved.rankSep / 2);
+  const slotStart = offsets(slotThickness, resolved.nodeSep);
+  const lineTotal = (lineStart[lineCount - 1] ?? 0) + (lineThickness[lineCount - 1] ?? 0);
+  const reverseLines = resolved.direction === "BT" || resolved.direction === "RL";
+  const placement = /* @__PURE__ */ new Map();
+  items.forEach((item, i) => {
+    const { line, slot } = at(i);
+    const thickness = lineThickness[line];
+    let along = lineStart[line];
+    if (reverseLines) along = lineTotal - along - thickness;
+    const across = slotStart[slot];
+    placement.set(item.id, horizontal ? { x: along, y: across } : { x: across, y: along });
+  });
+  return placement;
+}
+
+// src/history.ts
+function createHistory(initial) {
+  return { past: [], present: initial, future: [] };
+}
+function canUndo(state) {
+  return state.past.length > 0;
+}
+function canRedo(state) {
+  return state.future.length > 0;
+}
+function historyReducer(state, action, options = {}) {
+  const limit = Math.max(1, options.limit ?? 100);
+  switch (action.type) {
+    case "set": {
+      if (Object.is(action.value, state.present)) return state;
+      if (action.coalesceKey !== void 0 && action.coalesceKey === state.lastKey) {
+        return { past: state.past, present: action.value, future: [], lastKey: action.coalesceKey };
+      }
+      const past = [...state.past, state.present];
+      if (past.length > limit) past.splice(0, past.length - limit);
+      const next = { past, present: action.value, future: [] };
+      if (action.coalesceKey !== void 0) next.lastKey = action.coalesceKey;
+      return next;
+    }
+    case "undo": {
+      const previous = state.past[state.past.length - 1];
+      if (state.past.length === 0 || previous === void 0) return state;
+      return { past: state.past.slice(0, -1), present: previous, future: [state.present, ...state.future] };
+    }
+    case "redo": {
+      const next = state.future[0];
+      if (state.future.length === 0 || next === void 0) return state;
+      return { past: [...state.past, state.present], present: next, future: state.future.slice(1) };
+    }
+    case "reset":
+      return createHistory(action.value);
+    case "clear":
+      return createHistory(state.present);
+  }
+}
+
+// src/outline.ts
+function diagramToOutline(diagram, { connector = "to", maxPaths = 100 } = {}) {
+  const labels = new Map(diagram.nodes.map((node) => [node.id, node.label]));
+  const outgoing = /* @__PURE__ */ new Map();
+  const hasIncoming = /* @__PURE__ */ new Set();
+  for (const edge of diagram.edges) {
+    if (!labels.has(edge.source) || !labels.has(edge.target)) continue;
+    outgoing.set(edge.source, [...outgoing.get(edge.source) ?? [], edge.target]);
+    hasIncoming.add(edge.target);
+  }
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  const label = (id) => labels.get(id) ?? id;
+  const sentence = (ids) => ids.map(label).join(` ${connector} `);
+  const walk = (id, trail) => {
+    if (lines.length >= maxPaths) return;
+    visited.add(id);
+    const path = [...trail, id];
+    const next = outgoing.get(id) ?? [];
+    if (next.length === 0) {
+      lines.push(sentence(path));
+      return;
+    }
+    for (const target of next) {
+      if (path.includes(target)) lines.push(sentence([...path, target]));
+      else walk(target, path);
+    }
+  };
+  for (const node of diagram.nodes) {
+    if (!hasIncoming.has(node.id)) walk(node.id, []);
+  }
+  for (const node of diagram.nodes) {
+    if (!visited.has(node.id)) walk(node.id, []);
+  }
+  return lines;
+}
+
+// src/outline-tree.ts
+function diagramToOutlineTree(doc, options = {}) {
+  const index = buildIndex(doc);
+  const order = getReadingOrder(doc, {
+    ...options.direction === void 0 ? {} : { direction: options.direction },
+    ...options.rtl === void 0 ? {} : { rtl: options.rtl }
+  });
+  const items = /* @__PURE__ */ new Map();
+  for (const id of order) {
+    const node = index.nodesById.get(id);
+    const item = {
+      id,
+      label: node.label,
+      kind: node.kind,
+      incoming: (index.incoming.get(id) ?? []).map((edge) => connection(edge.id, edge.source, edge.label)),
+      outgoing: (index.outgoing.get(id) ?? []).map((edge) => connection(edge.id, edge.target, edge.label)),
+      children: []
+    };
+    if (node.status !== void 0) item.status = node.status;
+    if (node.description !== void 0) item.description = node.description;
+    items.set(id, item);
+  }
+  function connection(edgeId, nodeId, edgeLabel) {
+    const result = { edgeId, nodeId, label: index.nodesById.get(nodeId)?.label ?? nodeId };
+    if (edgeLabel !== void 0 && edgeLabel !== "") result.edgeLabel = edgeLabel;
+    return result;
+  }
+  const roots = [];
+  const position = new Map(order.map((id, i) => [id, i]));
+  for (const id of order) {
+    const item = items.get(id);
+    const parent = index.nodesById.get(id)?.parentId;
+    const parentItem = parent === void 0 || parent === id ? void 0 : items.get(parent);
+    if (parentItem && (position.get(parent) ?? Infinity) < (position.get(id) ?? 0)) parentItem.children.push(item);
+    else roots.push(item);
+  }
+  return roots;
+}
+function summarizeNodes(doc) {
+  const index = buildIndex(doc);
+  const result = /* @__PURE__ */ new Map();
+  for (const node of doc.nodes) {
+    const summary = {
+      id: node.id,
+      kind: node.kind,
+      label: node.label,
+      incoming: index.incoming.get(node.id)?.length ?? 0,
+      outgoing: index.outgoing.get(node.id)?.length ?? 0
+    };
+    if (node.status !== void 0) summary.status = node.status;
+    if (node.description !== void 0) summary.description = node.description;
+    result.set(node.id, summary);
+  }
+  return result;
+}
+
+// src/svg.ts
+import { cssVar } from "@x12i/tokens";
+var defaultPalette = {
+  surface: cssVar("color.bg.surface"),
+  canvas: cssVar("color.bg.canvas"),
+  text: cssVar("color.text.primary"),
+  textMuted: cssVar("color.text.secondary"),
+  textInverse: cssVar("color.text.inverse"),
+  border: cssVar("color.border.default"),
+  borderSubtle: cssVar("color.border.subtle"),
+  edge: cssVar("color.border.strong"),
+  accent: cssVar("color.accent.default"),
+  accentSubtle: cssVar("color.accent.subtle"),
+  onAccent: cssVar("color.accent.on-accent"),
+  inverse: cssVar("color.bg.inverse"),
+  status: {
+    neutral: {
+      background: cssVar("color.bg.surface"),
+      foreground: cssVar("color.text.primary"),
+      border: cssVar("color.border.default")
+    },
+    success: {
+      background: cssVar("color.status.success.background"),
+      foreground: cssVar("color.status.success.foreground"),
+      border: cssVar("color.status.success.border")
+    },
+    warning: {
+      background: cssVar("color.status.warning.background"),
+      foreground: cssVar("color.status.warning.foreground"),
+      border: cssVar("color.status.warning.border")
+    },
+    danger: {
+      background: cssVar("color.status.danger.background"),
+      foreground: cssVar("color.status.danger.foreground"),
+      border: cssVar("color.status.danger.border")
+    },
+    info: {
+      background: cssVar("color.status.info.background"),
+      foreground: cssVar("color.status.info.foreground"),
+      border: cssVar("color.status.info.border")
+    }
+  },
+  fontSans: cssVar("font.family.sans"),
+  fontMono: cssVar("font.family.mono")
+};
+function resolvePalette(override) {
+  if (!override) return defaultPalette;
+  const status = { ...defaultPalette.status };
+  for (const key of Object.keys(override.status ?? {})) {
+    status[key] = { ...defaultPalette.status[key], ...override.status?.[key] };
+  }
+  const rest = { ...override };
+  delete rest.status;
+  return { ...defaultPalette, ...rest, status };
+}
+var XML_INVALID = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/g;
+function escapeXml(text) {
+  return text.replace(XML_INVALID, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function serializeSvg(element) {
+  const attrs = Object.entries(element.attrs ?? {}).filter((entry) => entry[1] !== void 0).map(([name, value]) => ` ${name}="${escapeXml(String(value))}"`).join("");
+  const style = element.style && Object.keys(element.style).length > 0 ? ` style="${escapeXml(
+    Object.entries(element.style).map(([name, value]) => `${name}:${value}`).join(";")
+  )}"` : "";
+  const children = element.children ?? [];
+  if (children.length === 0) return `<${element.tag}${attrs}${style}/>`;
+  const inner = children.map((child) => typeof child === "string" ? escapeXml(child) : serializeSvg(child)).join("");
+  return `<${element.tag}${attrs}${style}>${inner}</${element.tag}>`;
+}
+var el = (tag, attrs, style, children) => {
+  const element = { tag };
+  if (attrs) element.attrs = attrs;
+  if (style) element.style = style;
+  if (children) element.children = children;
+  return element;
+};
+var num = (value) => Math.round(value * 100) / 100;
+var SAFE_IMAGE = /^(?:https?:\/\/|data:image\/(?:png|gif|jpe?g|webp|avif);base64,)/i;
+function isSafeImageUrl(value) {
+  return typeof value === "string" && SAFE_IMAGE.test(value);
+}
+function dataText(node, key) {
+  const value = node.data?.[key];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function diagramToSvgTree(doc, options = {}) {
+  const palette = resolvePalette(options.palette);
+  const prefix = options.idPrefix ?? "kit-diagram";
+  const padding = options.padding ?? 24;
+  const rtl = options.rtl ?? false;
+  const highlight = new Set(options.highlight ?? []);
+  const showEdgeLabels = options.showEdgeLabels ?? true;
+  const ctx = createGeometryContext(doc, {
+    ...options.direction === void 0 ? {} : { direction: options.direction },
+    rtl,
+    ...options.edgeKind === void 0 ? {} : { edgeKind: options.edgeKind }
+  });
+  const hidden = /* @__PURE__ */ new Set();
+  for (const node of doc.nodes) {
+    if (getAncestors(ctx.index, node.id).some((id) => ctx.index.nodesById.get(id)?.collapsed === true)) hidden.add(node.id);
+  }
+  const visibleNodes = doc.nodes.filter((node) => !hidden.has(node.id));
+  const edges = [];
+  for (const edge of doc.edges) {
+    if (hidden.has(edge.source) || hidden.has(edge.target)) continue;
+    const geometry = getEdgeGeometry(ctx, edge);
+    if (geometry) edges.push({ edge, geometry });
+  }
+  const rects = visibleNodes.map((node) => ctx.bounds.get(node.id));
+  for (const { edge, geometry } of edges) {
+    for (const point of geometry.points) rects.push({ x: point.x, y: point.y, width: 0, height: 0 });
+    if (showEdgeLabels && edge.label) {
+      const width = estimateTextWidth(edge.label) + 16;
+      rects.push({ x: geometry.label.x - width / 2, y: geometry.label.y - 12, width, height: 24 });
+    }
+  }
+  const box = unionRects(rects);
+  const view = rects.length === 0 ? { x: 0, y: 0, width: 160, height: 80 } : { x: box.x - padding, y: box.y - padding, width: box.width + padding * 2, height: box.height + padding * 2 };
+  const tones = /* @__PURE__ */ new Set(["neutral"]);
+  for (const { edge } of edges) tones.add(edge.status ?? "neutral");
+  const markerId = (tone) => `${prefix}-arrow-${tone}`;
+  const markerColor = (tone) => tone === "neutral" ? palette.edge : palette.status[tone].border;
+  const defs = el(
+    "defs",
+    void 0,
+    void 0,
+    [...tones].map(
+      (tone) => el(
+        "marker",
+        {
+          id: markerId(tone),
+          viewBox: "0 0 10 10",
+          markerWidth: 8,
+          markerHeight: 8,
+          refX: 9,
+          refY: 5,
+          orient: "auto-start-reverse",
+          markerUnits: "userSpaceOnUse"
+        },
+        void 0,
+        [el("path", { d: "M 0 0 L 10 5 L 0 10 z" }, { fill: markerColor(tone) })]
+      )
+    )
+  );
+  const depth = (node) => getAncestors(ctx.index, node.id).length;
+  const containers = visibleNodes.filter((node) => isContainerKind(node.kind)).sort((a, b) => depth(a) - depth(b));
+  const others = visibleNodes.filter((node) => !isContainerKind(node.kind));
+  const colorsFor = (node) => {
+    if (node.status !== void 0 && node.status !== "neutral") {
+      const tone = palette.status[node.status];
+      return { fill: tone.background, stroke: tone.border, text: tone.foreground };
+    }
+    switch (node.kind) {
+      case "start":
+        return { fill: palette.accentSubtle, stroke: palette.accent, text: palette.text };
+      case "end":
+        return { fill: palette.inverse, stroke: palette.inverse, text: palette.textInverse };
+      case "note": {
+        const tone = palette.status.warning;
+        return { fill: tone.background, stroke: tone.border, text: tone.foreground };
+      }
+      case "agent":
+        return { fill: palette.accentSubtle, stroke: palette.accent, text: palette.text };
+      case "group":
+      case "subflow":
+        return { fill: "none", stroke: palette.border, text: palette.textMuted };
+      default:
+        return { fill: palette.surface, stroke: palette.border, text: palette.text };
+    }
+  };
+  const strokeWidth = (node) => highlight.has(node.id) || node.kind === "end" ? cssVar("border.width.emphasis") : cssVar("border.width.default");
+  const textLines = (lines2, center, colors, extra = {}) => {
+    const lineHeight = TEXT_METRICS.lineHeight;
+    const startY = center.y - (lines2.length - 1) * lineHeight / 2;
+    return lines2.map(
+      (line, i) => el(
+        "text",
+        {
+          x: num(center.x),
+          y: num(startY + i * lineHeight),
+          "text-anchor": "middle",
+          "dominant-baseline": "central",
+          ...rtl ? { direction: "rtl" } : {}
+        },
+        { fill: colors.text, ...extra },
+        [line]
+      )
+    );
+  };
+  const startText = (text, rect, y, fill, extra = {}, padX = 12) => el(
+    "text",
+    {
+      x: num(rtl ? rect.x + rect.width - padX : rect.x + padX),
+      y: num(y),
+      "text-anchor": "start",
+      "dominant-baseline": "central",
+      ...rtl ? { direction: "rtl" } : {}
+    },
+    { fill, ...extra },
+    [text]
+  );
+  const nodeElement = (node) => {
+    const rect = ctx.bounds.get(node.id);
+    const colors = colorsFor(node);
+    const center = rectCenter(rect);
+    const accent = highlight.has(node.id);
+    const shapeStyle = {
+      fill: colors.fill,
+      stroke: accent ? palette.accent : colors.stroke,
+      "stroke-width": strokeWidth(node)
+    };
+    const children = [];
+    const geometry = (x, y, w, h) => ({ x: num(x), y: num(y), width: num(w), height: num(h) });
+    switch (node.kind) {
+      case "start":
+      case "end":
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: num(rect.height / 2) }, shapeStyle));
+        children.push(...textLines(wrapText(node.label, rect.width - 32), center, colors));
+        break;
+      case "decision": {
+        const { x, y, width, height } = rect;
+        const points = [`${num(x + width / 2)},${num(y)}`, `${num(x + width)},${num(y + height / 2)}`, `${num(x + width / 2)},${num(y + height)}`, `${num(x)},${num(y + height / 2)}`].join(" ");
+        children.push(el("polygon", { points }, { ...shapeStyle, "stroke-linejoin": "round" }));
+        children.push(...textLines(wrapText(node.label, width * 0.5), center, colors));
+        break;
+      }
+      case "note": {
+        const fold = 16;
+        const { x, y, width, height } = rect;
+        const d = `M ${num(x)} ${num(y)} H ${num(x + width - fold)} L ${num(x + width)} ${num(y + fold)} V ${num(y + height)} H ${num(x)} Z`;
+        children.push(el("path", { d }, shapeStyle));
+        children.push(
+          el("path", { d: `M ${num(x + width - fold)} ${num(y)} V ${num(y + fold)} H ${num(x + width)}` }, { fill: "none", stroke: shapeStyle.stroke, "stroke-width": strokeWidth(node) })
+        );
+        children.push(...textLines(wrapText(node.label, width - 32), center, colors));
+        break;
+      }
+      case "group":
+      case "subflow": {
+        children.push(
+          el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 8 }, {
+            ...shapeStyle,
+            "stroke-dasharray": node.kind === "group" ? "6 4" : "none"
+          })
+        );
+        children.push(startText(node.label, rect, rect.y + 20, colors.text, { "font-weight": "600" }));
+        break;
+      }
+      case "entity": {
+        const fields = Array.isArray(node.data?.fields) ? node.data?.fields : [];
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 6 }, shapeStyle));
+        children.push(
+          el("path", { d: `M ${num(rect.x)} ${num(rect.y + 32)} H ${num(rect.x + rect.width)}` }, { fill: "none", stroke: palette.borderSubtle })
+        );
+        children.push(startText(node.label, rect, rect.y + 16, colors.text, { "font-weight": "600" }));
+        fields.forEach((field, i) => {
+          const name = typeof field === "string" ? field : String(field?.name ?? "");
+          const type = typeof field === "object" && field !== null ? String(field.type ?? "") : "";
+          const y = rect.y + 32 + 12 + i * 24;
+          children.push(startText(name, rect, y, colors.text));
+          if (type !== "") {
+            children.push(
+              el(
+                "text",
+                {
+                  x: num(rtl ? rect.x + 12 : rect.x + rect.width - 12),
+                  y: num(y),
+                  "text-anchor": "end",
+                  "dominant-baseline": "central",
+                  ...rtl ? { direction: "rtl" } : {}
+                },
+                { fill: palette.textMuted },
+                [type]
+              )
+            );
+          }
+        });
+        break;
+      }
+      case "code": {
+        const code = dataText(node, "code") ?? "";
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 6 }, { ...shapeStyle, fill: palette.canvas }));
+        children.push(startText(node.label, rect, rect.y + 16, palette.textMuted, { "font-size": cssVar("text.caption.size") }));
+        code.split(/\r?\n/).slice(0, 12).forEach((line, i) => {
+          children.push(
+            el(
+              "text",
+              {
+                x: num(rect.x + 12),
+                y: num(rect.y + 40 + i * TEXT_METRICS.lineHeight + 10),
+                "text-anchor": "start",
+                "dominant-baseline": "central",
+                direction: "ltr"
+              },
+              { fill: palette.text, "font-family": palette.fontMono, "font-size": cssVar("text.code.size"), "white-space": "pre" },
+              [line]
+            )
+          );
+        });
+        break;
+      }
+      case "image": {
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 6 }, shapeStyle));
+        const src = dataText(node, "src");
+        if (isSafeImageUrl(src)) {
+          children.push(
+            el("image", {
+              href: src,
+              ...geometry(rect.x + 1, rect.y + 1, rect.width - 2, rect.height - 28),
+              preserveAspectRatio: "xMidYMid slice"
+            })
+          );
+        } else {
+          const gx = rect.x + rect.width / 2;
+          const gy = rect.y + (rect.height - 24) / 2;
+          children.push(
+            el("path", { d: `M ${num(gx - 20)} ${num(gy + 12)} L ${num(gx - 6)} ${num(gy - 6)} L ${num(gx + 4)} ${num(gy + 6)} L ${num(gx + 10)} ${num(gy)} L ${num(gx + 20)} ${num(gy + 12)} Z` }, { fill: "none", stroke: palette.textMuted, "stroke-width": cssVar("border.width.default"), "stroke-linejoin": "round" })
+          );
+        }
+        children.push(...textLines([node.label], { x: center.x, y: rect.y + rect.height - 14 }, colors));
+        break;
+      }
+      case "chart": {
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 6 }, shapeStyle));
+        const baseY = rect.y + rect.height - 40;
+        [0.4, 0.7, 0.55, 0.9].forEach((ratio, i) => {
+          const h = (rect.height - 64) * ratio;
+          children.push(el("rect", geometry(rect.x + 24 + i * 24, baseY - h, 16, h), { fill: palette.accent }));
+        });
+        children.push(...textLines([node.label], { x: center.x, y: rect.y + rect.height - 16 }, colors));
+        break;
+      }
+      case "agent": {
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 12 }, shapeStyle));
+        const cx = rtl ? rect.x + rect.width - 28 : rect.x + 28;
+        children.push(el("circle", { cx: num(cx), cy: num(center.y), r: 12 }, { fill: palette.accent }));
+        const role = dataText(node, "role");
+        const textX = rtl ? rect.x + rect.width - 52 : rect.x + 52;
+        const anchor = { "text-anchor": "start", "dominant-baseline": "central", ...rtl ? { direction: "rtl" } : {} };
+        children.push(
+          el("text", { x: num(textX), y: num(role ? center.y - 9 : center.y), ...anchor }, { fill: colors.text, "font-weight": "600" }, [node.label])
+        );
+        if (role) {
+          children.push(
+            el("text", { x: num(textX), y: num(center.y + 11), ...anchor }, { fill: palette.textMuted, "font-size": cssVar("text.caption.size") }, [role])
+          );
+        }
+        break;
+      }
+      default: {
+        children.push(el("rect", { ...geometry(rect.x, rect.y, rect.width, rect.height), rx: 6 }, shapeStyle));
+        children.push(...textLines(wrapText(node.label, rect.width - 32), center, colors));
+      }
+    }
+    return el("g", { "data-node-id": node.id, "data-kind": node.kind, ...node.status ? { "data-status": node.status } : {} }, void 0, children);
+  };
+  const edgeElement = ({ edge, geometry }) => {
+    const tone = edge.status ?? "neutral";
+    const color = markerColor(tone);
+    const children = [
+      el(
+        "path",
+        {
+          d: geometry.path,
+          "marker-end": `url(#${markerId(tone)})`,
+          ...edge.bidirectional ? { "marker-start": `url(#${markerId(tone)})` } : {}
+        },
+        {
+          fill: "none",
+          stroke: color,
+          "stroke-width": cssVar("border.width.default"),
+          "stroke-linecap": "round",
+          // A static picture cannot animate, so an animated edge is drawn dashed.
+          ...edge.dashed || edge.animated ? { "stroke-dasharray": "6 4" } : {}
+        }
+      )
+    ];
+    if (showEdgeLabels && edge.label) {
+      const width = estimateTextWidth(edge.label) + 16;
+      children.push(
+        el("rect", { x: num(geometry.label.x - width / 2), y: num(geometry.label.y - 12), width: num(width), height: 24, rx: 4 }, { fill: palette.surface, stroke: palette.borderSubtle })
+      );
+      children.push(
+        el(
+          "text",
+          { x: num(geometry.label.x), y: num(geometry.label.y), "text-anchor": "middle", "dominant-baseline": "central", ...rtl ? { direction: "rtl" } : {} },
+          { fill: palette.textMuted, "font-size": cssVar("text.caption.size") },
+          [edge.label]
+        )
+      );
+    }
+    return el("g", { "data-edge-id": edge.id, ...edge.status ? { "data-status": edge.status } : {} }, void 0, children);
+  };
+  const title = options.title ?? doc.title;
+  const lines = diagramToOutline(doc, options.connector === void 0 ? {} : { connector: options.connector });
+  const description = options.description ?? [doc.description, ...lines].filter((part) => Boolean(part)).join(". ");
+  const titleId = `${prefix}-title`;
+  const descId = `${prefix}-desc`;
+  return el(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      viewBox: `${num(view.x)} ${num(view.y)} ${num(view.width)} ${num(view.height)}`,
+      ...options.width === void 0 ? {} : { width: options.width },
+      ...options.height === void 0 ? {} : { height: options.height },
+      role: "img",
+      "aria-labelledby": description === "" ? titleId : `${titleId} ${descId}`,
+      ...options.lang === void 0 ? {} : { lang: options.lang },
+      ...rtl ? { direction: "rtl" } : {},
+      "data-kit": "diagram-static"
+    },
+    { "font-family": palette.fontSans, "font-size": cssVar("text.label.size") },
+    [
+      el("title", { id: titleId }, void 0, [title]),
+      ...description === "" ? [] : [el("desc", { id: descId }, void 0, [description])],
+      defs,
+      el("g", { "data-layer": "groups" }, void 0, containers.map(nodeElement)),
+      el("g", { "data-layer": "edges" }, void 0, edges.map(edgeElement)),
+      el("g", { "data-layer": "nodes" }, void 0, others.map(nodeElement))
+    ]
+  );
+}
+function diagramToSvg(doc, options = {}) {
+  const svg = serializeSvg(diagramToSvgTree(doc, options));
+  return options.standalone ? `<?xml version="1.0" encoding="UTF-8"?>
+${svg}` : svg;
+}
+
+// src/io.ts
+var DiagramImportError = class extends Error {
+  code;
+  issues;
+  constructor(code, message, issues = []) {
+    super(message);
+    this.name = "DiagramImportError";
+    this.code = code;
+    this.issues = issues;
+  }
+};
+function exportDiagramJson(doc, options = {}) {
+  const { version, title, ...rest } = doc;
+  return JSON.stringify({ version, title, ...rest }, null, options.space ?? 2);
+}
+function exportDiagramSvg(doc, options = {}) {
+  return diagramToSvg(doc, { ...options, standalone: true });
+}
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function importDiagram(input, options = {}) {
+  let raw = input;
+  if (typeof input === "string") {
+    try {
+      raw = JSON.parse(input);
+    } catch (error) {
+      throw new DiagramImportError("invalid-json", `The diagram is not valid JSON: ${error.message}`);
+    }
+  }
+  if (!isRecord(raw)) throw new DiagramImportError("not-an-object", "A diagram must be a JSON object.");
+  let data = { ...raw };
+  let version = data.version;
+  if (version === void 0 && options.assumeVersion !== void 0) version = options.assumeVersion;
+  if (typeof version !== "number" || !Number.isInteger(version)) {
+    throw new DiagramImportError("missing-version", "The diagram has no numeric version field.");
+  }
+  if (version > DIAGRAM_VERSION) {
+    throw new DiagramImportError(
+      "unsupported-version",
+      `The diagram is version ${version}, but this library reads up to version ${DIAGRAM_VERSION}. Update @x12i/diagrams.`
+    );
+  }
+  const fromVersion = version;
+  for (let current = version; current < DIAGRAM_VERSION; current += 1) {
+    const step = options.migrations?.[current];
+    if (!step) {
+      throw new DiagramImportError("missing-migration", `No migration from diagram version ${current} to ${current + 1}.`);
+    }
+    data = { ...step(data), version: current + 1 };
+  }
+  data.version = DIAGRAM_VERSION;
+  if (options.migrate && fromVersion < DIAGRAM_VERSION) data = { ...options.migrate(data, fromVersion), version: DIAGRAM_VERSION };
+  if (!Array.isArray(data.nodes) || !Array.isArray(data.edges)) {
+    throw new DiagramImportError("invalid-structure", "A diagram needs `nodes` and `edges` arrays.");
+  }
+  for (const [i, node] of data.nodes.entries()) {
+    if (!isRecord(node) || typeof node.id !== "string") {
+      throw new DiagramImportError("invalid-structure", `Node ${i} needs a string id.`);
+    }
+  }
+  for (const [i, edge] of data.edges.entries()) {
+    if (!isRecord(edge) || typeof edge.id !== "string" || typeof edge.source !== "string" || typeof edge.target !== "string") {
+      throw new DiagramImportError("invalid-structure", `Edge ${i} needs string id, source and target fields.`);
+    }
+  }
+  const document = { ...data, title: typeof data.title === "string" ? data.title : "" };
+  const { issues, errors } = validateDiagram(document);
+  if (options.strict && errors.length > 0) {
+    throw new DiagramImportError("invalid-structure", `The diagram has ${errors.length} validation errors. First: ${errors[0]?.message}`, issues);
+  }
+  const result = { document, issues };
+  if (fromVersion < DIAGRAM_VERSION) result.migratedFrom = fromVersion;
+  return result;
+}
+
+// src/messages.ts
+function formatMessage(message, values = {}) {
+  if (typeof message === "function") return message(values);
+  return message.replace(/\{(\w+)\}/g, (match, name) => {
+    const value = values[name];
+    return value === void 0 ? match : String(value);
+  });
+}
+var defaultMessages = {
+  canvas: {
+    label: "Diagram: {title}",
+    instructions: "Press Tab to move between nodes. Arrow keys jump to the nearest node in that direction. Press Space to select a node, Enter to rename it, Delete to remove the selection, and C to start a connection. Hold Shift with an arrow key to nudge the selection. Press Escape to clear the selection. The diagram outline lists every node and connection.",
+    instructionsReadOnly: "Press Tab to move between nodes. Arrow keys jump to the nearest node in that direction. The diagram outline lists every node and connection.",
+    empty: "This diagram is empty."
+  },
+  kinds: {
+    start: "Start",
+    end: "End",
+    task: "Task",
+    decision: "Decision",
+    group: "Group",
+    note: "Note",
+    image: "Image",
+    entity: "Entity",
+    code: "Code",
+    chart: "Chart",
+    agent: "Agent",
+    subflow: "Subflow"
+  },
+  statuses: {
+    neutral: "Neutral",
+    success: "Success",
+    warning: "Warning",
+    danger: "Danger",
+    info: "Info"
+  },
+  node: {
+    label: "{label}, {kind}. Incoming connections: {incoming}. Outgoing connections: {outgoing}.",
+    status: "Status: {status}.",
+    roleDescription: "node",
+    editLabel: "Label for {label}",
+    collapse: "Collapse {label}",
+    expand: "Expand {label}",
+    port: "Connection point",
+    childCount: "{count} items"
+  },
+  edge: {
+    label: "Connection from {source} to {target}",
+    labelWithText: "{label}. Connection from {source} to {target}",
+    roleDescription: "connection",
+    editLabel: "Label for the connection from {source} to {target}"
+  },
+  toolbar: {
+    label: "Diagram tools",
+    addNode: "Add node",
+    palette: "Node types",
+    undo: "Undo",
+    redo: "Redo",
+    delete: "Delete selection",
+    duplicate: "Duplicate selection",
+    autoLayout: "Arrange automatically",
+    group: "Group selection",
+    ungroup: "Ungroup",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    fitView: "Fit diagram to view",
+    showMiniMap: "Show minimap",
+    hideMiniMap: "Hide minimap",
+    showGrid: "Show grid",
+    hideGrid: "Hide grid",
+    controlsLabel: "View controls"
+  },
+  minimap: "Minimap",
+  announce: {
+    nodeAdded: "Added {kind}: {label}.",
+    nodeRemoved: "Removed {label}.",
+    itemsRemoved: "Items removed: {count}.",
+    connected: "Connected {source} to {target}.",
+    disconnected: "Removed the connection from {source} to {target}.",
+    moved: "Moved {label} to x {x}, y {y}.",
+    resized: "Resized {label} to {width} by {height}.",
+    renamed: "Renamed to {label}.",
+    selected: "Selected {label}.",
+    selectedMany: "Selected items: {count}.",
+    selectionCleared: "Selection cleared.",
+    undone: "Undid the last change.",
+    redone: "Redid the change.",
+    nothingToUndo: "Nothing to undo.",
+    nothingToRedo: "Nothing to redo.",
+    layoutApplied: "Layout applied.",
+    grouped: "Grouped into {label}.",
+    ungrouped: "Ungrouped {label}.",
+    duplicated: "Duplicated items: {count}.",
+    copied: "Copied items: {count}.",
+    pasted: "Pasted items: {count}.",
+    connectStarted: "Connecting from {label}. Move to the target node and press Enter, or press Escape to cancel.",
+    connectCancelled: "Connection cancelled.",
+    locked: "{label} is locked."
+  },
+  connection: {
+    "unknown-source": "That node no longer exists.",
+    "unknown-target": "That node no longer exists.",
+    "self-loop": "A node cannot connect to itself in this diagram.",
+    duplicate: "These nodes are already connected.",
+    locked: "A locked node cannot be connected.",
+    "container-descendant": "A group cannot connect to a node inside it.",
+    "source-port-missing": "That connection point does not exist.",
+    "target-port-missing": "That connection point does not exist.",
+    "source-port-not-output": "That connection point only receives connections.",
+    "target-port-not-input": "That connection point only starts connections.",
+    "port-type-mismatch": "These connection points have different types and cannot be joined.",
+    cycle: "This connection would create a cycle, which this diagram does not allow.",
+    "multiple-parents": "This node already has a parent.",
+    custom: "This connection is not allowed."
+  },
+  outline: {
+    title: "Diagram outline",
+    nodes: "Nodes",
+    paths: "Paths",
+    connector: "to",
+    connectsTo: "Connects to",
+    receivesFrom: "Receives from",
+    noConnections: "No connections",
+    goToNode: "Show {label} in the diagram",
+    empty: "This diagram has no nodes.",
+    status: "Status: {status}",
+    contains: "Contains",
+    disconnect: "Remove the connection from {source} to {target}"
+  },
+  mermaid: {
+    loading: "Rendering diagram\u2026",
+    renderError: "The diagram could not be rendered.",
+    loadError: "Mermaid could not be loaded. Install the mermaid package and pass it with the loadMermaid prop.",
+    showSource: "Show source",
+    hideSource: "Hide source",
+    sourceLabel: "Diagram source"
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function merge(base, override) {
+  if (!isRecord2(override) || typeof base === "string" || typeof base === "function") {
+    return override === void 0 ? base : override;
+  }
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value !== void 0) result[key] = merge(base[key], value);
+  }
+  return result;
+}
+function resolveMessages(override) {
+  return override ? merge(defaultMessages, override) : defaultMessages;
+}
+
+export {
+  DIAGRAM_VERSION,
+  NODE_KINDS,
+  NODE_STATUSES,
+  EDGE_KINDS,
+  DIAGRAM_KINDS,
+  isContainerKind,
+  defineDiagram,
+  createDiagram,
+  generateId,
+  nextId,
+  createIdAllocator,
+  idStem,
+  buildIndex,
+  getAncestors,
+  getDescendants,
+  findCycle,
+  hasPath,
+  getRoots,
+  getNeighbors,
+  topologicalOrder,
+  resolveConnectionRules,
+  portTypesCompatible,
+  checkConnection,
+  validateDiagram,
+  GRID_SIZE,
+  DEFAULT_NODE_SIZE,
+  COLLAPSED_HEIGHT,
+  TEXT_METRICS,
+  estimateTextWidth,
+  wrapText,
+  getNodeSize,
+  getNodeBounds,
+  rectCenter,
+  unionRects,
+  rectsIntersect,
+  rectContainsPoint,
+  getAbsolutePositions,
+  getAbsolutePosition,
+  getAbsoluteBounds,
+  getDocumentBounds,
+  snapValue,
+  snapPoint,
+  directionSides,
+  mirrorDirection,
+  isHorizontal,
+  getPortPlacements,
+  sideAnchor,
+  sideVector,
+  computeEdgePath,
+  createGeometryContext,
+  getEdgeGeometry,
+  getReadingOrder,
+  findDirectionalNeighbor,
+  DiagramMutationError,
+  nextNodeId,
+  nextEdgeId,
+  createNode,
+  addNode,
+  updateNode,
+  removeNodes,
+  removeNode,
+  moveNodes,
+  translateNodes,
+  resizeNode,
+  setNodeParent,
+  connect,
+  disconnect,
+  removeEdges,
+  updateEdge,
+  groupNodes,
+  ungroupNode,
+  extractFragment,
+  pasteFragment,
+  duplicateNodes,
+  alignNodes,
+  distributeNodes,
+  layoutDiagram,
+  applyLayout,
+  layoutedDiagram,
+  createHistory,
+  canUndo,
+  canRedo,
+  historyReducer,
+  diagramToOutline,
+  diagramToOutlineTree,
+  summarizeNodes,
+  defaultPalette,
+  resolvePalette,
+  escapeXml,
+  serializeSvg,
+  isSafeImageUrl,
+  diagramToSvgTree,
+  diagramToSvg,
+  DiagramImportError,
+  exportDiagramJson,
+  exportDiagramSvg,
+  importDiagram,
+  formatMessage,
+  defaultMessages,
+  resolveMessages
+};
+//# sourceMappingURL=chunk-3DJFQRU3.js.map