dsh-model-everything 0.4.1 → 0.5.1

package/lib/client.js

@@ -0,0 +1,3494 @@
+// Generated by scripts/build-client.mjs - do not edit. Source: src/client.ts and src/render/*.ts.
+window.__ModuleLoader__.load({
+  id: "dsh-model-everything",
+  factory(require) {
+    const module = { exports: {} };
+    const exports = module.exports;
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    
+    // src/client.ts
+    var client_exports = {};
+    __export(client_exports, {
+      TOOL_NAMES: () => TOOL_NAMES,
+      WHITEBOARD_ID: () => WHITEBOARD_ID,
+      WHITEBOARD_SAMPLE: () => WHITEBOARD_SAMPLE,
+      default: () => factory,
+      mountWhiteboard: () => mountWhiteboard,
+      themeMode: () => themeMode,
+      viewFor: () => viewFor,
+      whiteboardFor: () => whiteboardFor
+    });
+    module.exports = __toCommonJS(client_exports);
+    
+    // src/render/components.ts
+    var PAGE_ASPECT = 1.6;
+    function weakComponents(nodes, edges) {
+      const known = new Set(nodes.map((node) => node.id));
+      const neighbours = /* @__PURE__ */ new Map();
+      const link = (from, to) => {
+        neighbours.set(from, [...neighbours.get(from) ?? [], to]);
+      };
+      for (const edge of edges) {
+        if (!known.has(edge.from) || !known.has(edge.to) || edge.from === edge.to) continue;
+        link(edge.from, edge.to);
+        link(edge.to, edge.from);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const components = [];
+      for (const node of nodes) {
+        if (seen.has(node.id)) continue;
+        const members = [];
+        const queue = [node.id];
+        seen.add(node.id);
+        for (let head = 0; head < queue.length; head += 1) {
+          const id = queue[head];
+          members.push(id);
+          for (const next of neighbours.get(id) ?? []) {
+            if (seen.has(next)) continue;
+            seen.add(next);
+            queue.push(next);
+          }
+        }
+        components.push(members);
+      }
+      return components;
+    }
+    function packRectangles(rectangles, options = {}) {
+      const gap = options.gap ?? 30;
+      const aspect = options.aspect ?? PAGE_ASPECT;
+      if (rectangles.length === 0) return { placements: [], width: 0, height: 0 };
+      const area = rectangles.reduce((total, rectangle) => total + (rectangle.width + gap) * (rectangle.height + gap), 0);
+      const targetWidth = Math.max(gap, Math.sqrt(area * aspect));
+      const order2 = rectangles.map((rectangle, index) => ({ rectangle, index })).sort((left, right) => right.rectangle.height - left.rectangle.height || right.rectangle.width - left.rectangle.width || left.index - right.index);
+      const placements = rectangles.map((rectangle) => ({ x: 0, y: 0, width: rectangle.width, height: rectangle.height }));
+      let x = 0;
+      let y = 0;
+      let shelfHeight = 0;
+      let width = 0;
+      for (const entry of order2) {
+        const rectangle = entry.rectangle;
+        if (x > 0 && x + rectangle.width > targetWidth) {
+          y += shelfHeight + gap;
+          x = 0;
+          shelfHeight = 0;
+        }
+        placements[entry.index] = { x, y, width: rectangle.width, height: rectangle.height };
+        x += rectangle.width + gap;
+        width = Math.max(width, x - gap);
+        shelfHeight = Math.max(shelfHeight, rectangle.height);
+      }
+      return { placements, width, height: y + shelfHeight };
+    }
+    
+    // src/render/channels.ts
+    var PORT_INSET = 10;
+    function spanOf(box) {
+      const lo = box.x + PORT_INSET;
+      const hi = box.x + box.width - PORT_INSET;
+      return hi > lo ? { lo, hi } : { lo: box.x + box.width / 2, hi: box.x + box.width / 2 };
+    }
+    function clamp(value, span) {
+      return Math.min(span.hi, Math.max(span.lo, value));
+    }
+    function inside(value, span) {
+      return value >= span.lo - 1e-3 && value <= span.hi + 1e-3;
+    }
+    function cut(free, blocked) {
+      const out = [];
+      for (const span of free) {
+        if (blocked.hi <= span.lo || blocked.lo >= span.hi) {
+          out.push(span);
+          continue;
+        }
+        if (blocked.lo > span.lo) out.push({ lo: span.lo, hi: blocked.lo });
+        if (blocked.hi < span.hi) out.push({ lo: blocked.hi, hi: span.hi });
+      }
+      return out;
+    }
+    function atOrAfter(value, free) {
+      let found = value;
+      for (const span of free) {
+        if (span.hi < value) continue;
+        found = Math.max(value, span.lo);
+        break;
+      }
+      return found;
+    }
+    function choose(entry) {
+      const candidates = [entry.proposal, entry.source.lo, entry.source.hi, entry.target.lo, entry.target.hi];
+      candidates.push((clamp(entry.proposal, entry.source) + clamp(entry.proposal, entry.target)) / 2);
+      let best = entry.proposal;
+      let bestBends = Infinity;
+      let bestFar = Infinity;
+      let bestReach = Infinity;
+      for (const span of entry.free) {
+        for (const value of candidates) {
+          const x = clamp(value, span);
+          const bends = (inside(x, entry.source) ? 0 : 1) + (inside(x, entry.target) ? 0 : 1);
+          const far = Math.abs(x - entry.proposal);
+          const reach = Math.abs(x - clamp(x, entry.source)) + Math.abs(x - clamp(x, entry.target));
+          const better = bends < bestBends || bends === bestBends && (far < bestFar - 1e-3 || Math.abs(far - bestFar) <= 1e-3 && reach < bestReach);
+          if (!better) continue;
+          best = x;
+          bestBends = bends;
+          bestFar = far;
+          bestReach = reach;
+        }
+      }
+      return best;
+    }
+    function adjacentPorts(source, target) {
+      const fromMiddle = source.x + source.width / 2;
+      const toMiddle = target.x + target.width / 2;
+      const fromSpan = spanOf(source);
+      const toSpan = spanOf(target);
+      const chosen = inside(fromMiddle, toSpan) ? fromMiddle : clamp(toMiddle, fromSpan);
+      return { from: clamp(chosen, fromSpan), to: clamp(chosen, toSpan) };
+    }
+    function assignChannels(input, options) {
+      const { layers, chains, chainOf, boxes, layerY, layerHeight, laneX } = input;
+      const rowOf = /* @__PURE__ */ new Map();
+      layers.forEach((row, depth) => {
+        for (const id of row) rowOf.set(id, depth);
+      });
+      const long = [];
+      for (const chain of chains) {
+        if (chain.path.length <= 2) continue;
+        const head = chain.path[0];
+        const tail = chain.path[chain.path.length - 1];
+        const from = rowOf.get(head);
+        const to = rowOf.get(tail);
+        if (from === void 0 || to === void 0 || to <= from) continue;
+        const lane = chainOf.get(chain.path[1]);
+        const source = boxes.get(head);
+        const target = boxes.get(tail);
+        if (lane === void 0 || source === void 0 || target === void 0) continue;
+        let free = [{ lo: -Infinity, hi: Infinity }];
+        for (let depth = from + 1; depth < to; depth += 1) {
+          for (const id of layers[depth]) {
+            const box = boxes.get(id);
+            if (box === void 0) continue;
+            free = cut(free, { lo: box.x - options.clearance, hi: box.x + box.width + options.clearance });
+          }
+        }
+        const centre = (source.x + source.width / 2 + target.x + target.width / 2) / 2;
+        long.push({
+          edge: chain.index,
+          lane,
+          path: chain.path,
+          from,
+          to,
+          free,
+          source: spanOf(source),
+          target: spanOf(target),
+          proposal: laneX.get(lane) ?? centre,
+          x: 0
+        });
+      }
+      for (const entry of long) entry.x = choose(entry);
+      const byGap = /* @__PURE__ */ new Map();
+      for (const entry of long) {
+        for (let gap = entry.from; gap < entry.to; gap += 1) {
+          const row = gap + 1 < entry.to ? gap + 1 : gap;
+          const id = entry.path[row - entry.from];
+          const index = layers[row].indexOf(id);
+          byGap.set(gap, [...byGap.get(gap) ?? [], { entry, index }]);
+        }
+      }
+      for (const [, list] of byGap) list.sort((left, right) => left.index - right.index);
+      for (let round = 0; round < 4; round += 1) {
+        let moved = false;
+        for (const [, list] of byGap) {
+          let previous = -Infinity;
+          for (const item of list) {
+            const x = item.entry.x < previous + options.spacing ? atOrAfter(previous + options.spacing, item.entry.free) : item.entry.x;
+            if (x !== item.entry.x) {
+              item.entry.x = x;
+              moved = true;
+            }
+            previous = item.entry.x;
+          }
+        }
+        if (!moved) break;
+      }
+      const stacks = /* @__PURE__ */ new Map();
+      const want = (gap, edge, left) => {
+        stacks.set(gap, [...stacks.get(gap) ?? [], { edge, gap, left }]);
+      };
+      for (const entry of long) {
+        const head = clamp(entry.x, entry.source);
+        const tail = clamp(entry.x, entry.target);
+        if (Math.abs(head - entry.x) > 0.5) want(entry.from, entry.edge, Math.min(head, entry.x));
+        if (Math.abs(tail - entry.x) > 0.5) want(entry.to - 1, entry.edge, Math.min(tail, entry.x));
+      }
+      for (const chain of chains) {
+        if (chain.path.length > 2) continue;
+        const head = chain.path[0];
+        const tail = chain.path[chain.path.length - 1];
+        const from = rowOf.get(head);
+        const to = rowOf.get(tail);
+        if (from === void 0 || to === void 0 || Math.abs(from - to) !== 1) continue;
+        const source = boxes.get(head);
+        const target = boxes.get(tail);
+        if (source === void 0 || target === void 0) continue;
+        const ports = adjacentPorts(source, target);
+        want(Math.min(from, to), chain.index, Math.min(ports.from, ports.to));
+      }
+      const midOf = (gap) => (layerY[gap] + layerHeight[gap] + layerY[gap + 1]) / 2;
+      const heightOf = /* @__PURE__ */ new Map();
+      for (const [gap, list] of stacks) {
+        const top = layerY[gap] + layerHeight[gap];
+        const bottom = layerY[gap + 1];
+        const pad = Math.min(8, Math.max(1, (bottom - top) / 3));
+        const lo = top + pad;
+        const hi = Math.max(lo, bottom - pad);
+        const sorted = [...list].sort((left, right) => left.left - right.left || left.edge - right.edge);
+        sorted.forEach((item, index) => {
+          const y = sorted.length === 1 ? (lo + hi) / 2 : lo + (hi - lo) * (index + 1) / (sorted.length + 1);
+          const heights = heightOf.get(item.edge) ?? /* @__PURE__ */ new Map();
+          heights.set(item.gap, y);
+          heightOf.set(item.edge, heights);
+        });
+      }
+      const lanes2 = /* @__PURE__ */ new Map();
+      for (const entry of long) {
+        const y = [];
+        for (let gap = entry.from; gap < entry.to; gap += 1) y.push(heightOf.get(entry.edge)?.get(gap) ?? midOf(gap));
+        lanes2.set(entry.edge, { x: entry.x, y });
+      }
+      const runs = /* @__PURE__ */ new Map();
+      for (const [edge, heights] of heightOf) {
+        if (lanes2.has(edge)) continue;
+        runs.set(edge, [...heights.values()][0]);
+      }
+      return { lanes: lanes2, runs };
+    }
+    
+    // src/render/coords.ts
+    function positions(rows) {
+      const at = /* @__PURE__ */ new Map();
+      for (const row of rows) row.forEach((id, index) => at.set(id, index));
+      return at;
+    }
+    function alignBlocks(frame, at) {
+      const root = /* @__PURE__ */ new Map();
+      const joined = /* @__PURE__ */ new Map();
+      for (const row of frame.rows) {
+        for (const id of row) {
+          root.set(id, id);
+          joined.set(id, id);
+        }
+      }
+      for (let depth = 1; depth < frame.rows.length; depth += 1) {
+        let previous = -1;
+        for (const id of frame.rows[depth]) {
+          const close = frame.near.get(id) ?? [];
+          if (close.length === 0) continue;
+          const sorted = [...close].sort((left, right) => at.get(left) - at.get(right));
+          const middle = (sorted.length - 1) / 2;
+          for (let cursor = Math.floor(middle); cursor <= Math.ceil(middle); cursor += 1) {
+            if (joined.get(id) !== id) break;
+            const target = sorted[cursor];
+            if (previous >= at.get(target)) continue;
+            joined.set(target, id);
+            root.set(id, root.get(target));
+            joined.set(id, root.get(id));
+            previous = at.get(target);
+          }
+        }
+      }
+      return root;
+    }
+    function compactBlocks(rows, root, widthOf, gap) {
+      const clears = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        for (let index = 1; index < row.length; index += 1) {
+          const left = row[index - 1];
+          const right = row[index];
+          const leftBlock = root.get(left);
+          const rightBlock = root.get(right);
+          const space = (widthOf(left) + widthOf(right)) / 2 + gap;
+          clears.set(rightBlock, [...clears.get(rightBlock) ?? [], { block: leftBlock, space }]);
+        }
+      }
+      const placed = /* @__PURE__ */ new Map();
+      const place2 = (block) => {
+        const known = placed.get(block);
+        if (known !== void 0) return known;
+        let value = 0;
+        for (const step of clears.get(block) ?? []) value = Math.max(value, place2(step.block) + step.space);
+        placed.set(block, value);
+        return value;
+      };
+      const x = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        for (const id of row) {
+          const block = root.get(id);
+          if (!placed.has(block)) place2(block);
+          x.set(id, placed.get(block));
+        }
+      }
+      return x;
+    }
+    function extentOf(x, rows, widthOf) {
+      let left = Infinity;
+      let right = -Infinity;
+      for (const row of rows) {
+        for (const id of row) {
+          const value = x.get(id);
+          left = Math.min(left, value - widthOf(id) / 2);
+          right = Math.max(right, value + widthOf(id) / 2);
+        }
+      }
+      return { left, right };
+    }
+    function onePass(frame, widthOf, gap) {
+      const at = positions(frame.rows);
+      const root = alignBlocks(frame, at);
+      const x = compactBlocks(frame.rows, root, widthOf, gap);
+      if (!frame.mirrored) return x;
+      const mirrored = /* @__PURE__ */ new Map();
+      for (const [id, value] of x) mirrored.set(id, -value);
+      return mirrored;
+    }
+    function frames(layers, above, below) {
+      const fromTop = layers;
+      const fromBottom = [...layers].reverse();
+      const flip = (rows) => rows.map((row) => [...row].reverse());
+      return [
+        { rows: fromTop, near: above, mirrored: false },
+        { rows: flip(fromTop), near: above, mirrored: true },
+        { rows: fromBottom, near: below, mirrored: false },
+        { rows: flip(fromBottom), near: below, mirrored: true }
+      ];
+    }
+    function assignCoordinates(input, options) {
+      const { layers, chains, sizeOf, chainOf } = input;
+      const gap = options.gap;
+      const laneIds = new Set(chainOf.values());
+      const isDummy = (id) => chainOf.has(id);
+      const isPoint = (id) => isDummy(id) || laneIds.has(id);
+      const widthOf = (id) => isPoint(id) ? 0 : sizeOf(id).width;
+      const heightOf = (id) => isPoint(id) ? 0 : sizeOf(id).height;
+      const laneOf = (id) => chainOf.get(id) ?? id;
+      const x = /* @__PURE__ */ new Map();
+      const read = (id) => x.get(laneOf(id));
+      const above = /* @__PURE__ */ new Map();
+      const below = /* @__PURE__ */ new Map();
+      const laneEnds = /* @__PURE__ */ new Map();
+      const link = (into, id, other) => {
+        into.set(id, [...into.get(id) ?? [], other]);
+      };
+      for (const chain of chains) {
+        for (let cursor = 0; cursor + 1 < chain.path.length; cursor += 1) {
+          const top2 = chain.path[cursor];
+          const bottom = chain.path[cursor + 1];
+          if (!isDummy(top2) && !isDummy(bottom)) {
+            link(below, top2, bottom);
+            link(above, bottom, top2);
+          }
+        }
+        if (chain.path.length > 2) {
+          const lane = chainOf.get(chain.path[1]);
+          if (lane !== void 0) laneEnds.set(lane, [chain.path[0], chain.path[chain.path.length - 1]]);
+        }
+      }
+      const candidates = frames(layers, above, below).map((frame) => onePass(frame, widthOf, gap));
+      const leftOrigin = extentOf(candidates[0], layers, widthOf).left;
+      const rightOrigin = extentOf(candidates[1], layers, widthOf).right;
+      for (const [index, candidate] of candidates.entries()) {
+        const extent = extentOf(candidate, layers, widthOf);
+        const shift = index % 2 === 0 ? leftOrigin - extent.left : rightOrigin - extent.right;
+        for (const [id, value] of candidate) candidate.set(id, value + shift);
+      }
+      for (const row of layers) {
+        for (const id of row) {
+          let total = 0;
+          for (const candidate of candidates) total += candidate.get(id);
+          x.set(id, total / candidates.length);
+        }
+      }
+      const reserved = layers.map((layer2) => {
+        let lowest = Infinity;
+        let highest = -Infinity;
+        for (const id of layer2) {
+          const value = x.get(id);
+          lowest = Math.min(lowest, value - widthOf(id) / 2);
+          highest = Math.max(highest, value + widthOf(id) / 2);
+        }
+        return { lowest, highest };
+      });
+      for (const [lane, ends] of laneEnds) x.set(lane, (x.get(ends[0]) + x.get(ends[1])) / 2);
+      for (const id of chainOf.keys()) x.delete(id);
+      for (const row of layers) {
+        let cursor = -Infinity;
+        for (const id of row) {
+          if (isDummy(id)) {
+            cursor = Math.max(cursor, read(id));
+            continue;
+          }
+          const width2 = widthOf(id);
+          const centre = Math.max(x.get(id), cursor + width2 / 2);
+          x.set(id, centre);
+          cursor = centre + width2 / 2 + gap;
+        }
+      }
+      let left = 0;
+      for (const [id, value] of x) left = Math.min(left, value - widthOf(id) / 2);
+      for (const [id, value] of x) x.set(id, value - left);
+      const layerHeight = layers.map((layer2) => Math.max(0, ...layer2.map((id) => heightOf(id))));
+      const layerWidth = layers.map((layer2, depth) => {
+        let lowest = reserved[depth].lowest - left;
+        let highest = reserved[depth].highest - left;
+        for (const id of layer2) {
+          const value = read(id);
+          lowest = Math.min(lowest, value - widthOf(id) / 2);
+          highest = Math.max(highest, value + widthOf(id) / 2);
+        }
+        return highest - lowest;
+      });
+      const layerY = [];
+      let top = 0;
+      for (const [depth, height] of layerHeight.entries()) {
+        layerY.push(top);
+        top += height + options.layerGap;
+      }
+      let width = 0;
+      for (const [id, value] of x) width = Math.max(width, value + widthOf(id) / 2);
+      return {
+        x,
+        layerY,
+        layerHeight,
+        layerWidth,
+        width,
+        height: layerY.length === 0 ? 0 : layerY[layerY.length - 1] + layerHeight[layerHeight.length - 1]
+      };
+    }
+    
+    // src/render/cycle-break.ts
+    function tarjan(nodes, outgoing) {
+      let counter = 0;
+      const index = /* @__PURE__ */ new Map();
+      const low = /* @__PURE__ */ new Map();
+      const stack = [];
+      const onStack = /* @__PURE__ */ new Set();
+      const found = [];
+      const visit = (node) => {
+        index.set(node, counter);
+        low.set(node, counter);
+        counter += 1;
+        stack.push(node);
+        onStack.add(node);
+        for (const next of outgoing.get(node) ?? []) {
+          if (!index.has(next)) {
+            visit(next);
+            low.set(node, Math.min(low.get(node), low.get(next)));
+            continue;
+          }
+          if (onStack.has(next)) low.set(node, Math.min(low.get(node), index.get(next)));
+        }
+        if (low.get(node) !== index.get(node)) return;
+        const component = [];
+        let member;
+        do {
+          member = stack.pop();
+          onStack.delete(member);
+          component.push(member);
+        } while (member !== node);
+        found.push(component);
+      };
+      for (const node of nodes) if (!index.has(node)) visit(node);
+      return found;
+    }
+    function breakCycles(graph) {
+      const known = new Set(graph.nodes.map((node) => node.id));
+      const position = new Map(graph.nodes.map((node, offset) => [node.id, offset]));
+      const edges = graph.edges.map((edge) => ({ ...edge }));
+      const reversed = /* @__PURE__ */ new Set();
+      const flip = (index) => {
+        const edge = edges[index];
+        const next = edge.from;
+        edge.from = edge.to;
+        edge.to = next;
+      };
+      if (graph.init !== void 0 && known.has(graph.init)) {
+        for (const [index, edge] of edges.entries()) {
+          if (edge.to === graph.init && edge.from !== graph.init) flip(index);
+        }
+      }
+      const outgoing = /* @__PURE__ */ new Map();
+      for (const edge of edges) {
+        if (!known.has(edge.from) || !known.has(edge.to) || edge.from === edge.to) continue;
+        outgoing.set(edge.from, [...outgoing.get(edge.from) ?? [], edge.to]);
+      }
+      const nodes = graph.nodes.map((node) => node.id);
+      const raw = tarjan(nodes, outgoing);
+      raw.reverse();
+      const componentOf = /* @__PURE__ */ new Map();
+      const components = raw.map((members, id) => {
+        for (const member of members) componentOf.set(member, id);
+        return { id, members };
+      });
+      const condensation = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const edge of edges) {
+        const from = componentOf.get(edge.from);
+        const to = componentOf.get(edge.to);
+        if (from === void 0 || to === void 0 || from === to) continue;
+        const key = String(from) + ">" + String(to);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        condensation.push({ from, to });
+      }
+      const rank = /* @__PURE__ */ new Map();
+      for (const component of components) {
+        if (component.members.length < 2) {
+          rank.set(component.members[0], 0);
+          continue;
+        }
+        const inside2 = new Set(component.members);
+        const score = /* @__PURE__ */ new Map();
+        for (const member of component.members) score.set(member, 0);
+        for (const edge of edges) {
+          if (!inside2.has(edge.from) || !inside2.has(edge.to) || edge.from === edge.to) continue;
+          score.set(edge.from, score.get(edge.from) + 1);
+          score.set(edge.to, score.get(edge.to) - 1);
+        }
+        const ordered = [...component.members].sort((left, right) => {
+          const difference = score.get(right) - score.get(left);
+          return difference !== 0 ? difference : position.get(left) - position.get(right);
+        });
+        ordered.forEach((member, offset) => rank.set(member, offset));
+      }
+      for (const [index, edge] of edges.entries()) {
+        const from = rank.get(edge.from);
+        const to = rank.get(edge.to);
+        if (from === void 0 || to === void 0 || edge.from === edge.to) continue;
+        if (componentOf.get(edge.from) !== componentOf.get(edge.to)) continue;
+        if (from > to) flip(index);
+      }
+      edges.forEach((edge, index) => {
+        if (graph.edges[index].from !== edge.from) reversed.add(edge.index);
+      });
+      return { edges, reversed, components, componentOf, rank, condensation };
+    }
+    
+    // src/render/dummy.ts
+    function addDummies(layering, edges) {
+      const layers = layering.layers.map((layer2) => [...layer2]);
+      const chains = [];
+      const chainOf = /* @__PURE__ */ new Map();
+      const laneOf = /* @__PURE__ */ new Map();
+      for (const edge of edges) {
+        if (edge.from === edge.to) {
+          chains.push({ index: edge.index, path: [edge.from, edge.to] });
+          continue;
+        }
+        const from = layering.layerOf.get(edge.from);
+        const to = layering.layerOf.get(edge.to);
+        if (from === void 0 || to === void 0 || to <= from) {
+          chains.push({ index: edge.index, path: [edge.from, edge.to] });
+          continue;
+        }
+        const path = [edge.from];
+        for (let cursor = from + 1; cursor < to; cursor += 1) {
+          const instance = "#d" + String(edge.index) + "_" + String(cursor);
+          const lane = "#e" + String(edge.index);
+          chainOf.set(instance, lane);
+          laneOf.set(edge.index, lane);
+          layers[cursor].push(instance);
+          path.push(instance);
+        }
+        path.push(edge.to);
+        chains.push({ index: edge.index, path });
+      }
+      return { layers, chains, chainOf, laneOf };
+    }
+    
+    // src/render/network-simplex.ts
+    function slackOf(edge, rank) {
+      return rank[edge.to] - rank[edge.from] - edge.minLength;
+    }
+    function componentsOf(count, edges) {
+      const neighbours = [];
+      for (let node = 0; node < count; node += 1) neighbours.push([]);
+      for (const edge of edges) {
+        neighbours[edge.from].push(edge.to);
+        neighbours[edge.to].push(edge.from);
+      }
+      const seen = new Array(count).fill(false);
+      const components = [];
+      for (let node = 0; node < count; node += 1) {
+        if (seen[node]) continue;
+        seen[node] = true;
+        const members = [node];
+        for (let head = 0; head < members.length; head += 1) {
+          for (const next of neighbours[members[head]]) {
+            if (seen[next]) continue;
+            seen[next] = true;
+            members.push(next);
+          }
+        }
+        members.sort((left, right) => left - right);
+        components.push(members);
+      }
+      return components;
+    }
+    function buildTightTree(members, edges, rank, tree) {
+      const inside2 = /* @__PURE__ */ new Set([members[0]]);
+      while (inside2.size < members.length) {
+        let tight = -1;
+        for (const [index, edge] of edges.entries()) {
+          if (tree.has(index)) continue;
+          if (inside2.has(edge.from) === inside2.has(edge.to)) continue;
+          if (slackOf(edge, rank) === 0) {
+            tight = index;
+            break;
+          }
+        }
+        if (tight >= 0) {
+          tree.add(tight);
+          inside2.add(edges[tight].from);
+          inside2.add(edges[tight].to);
+          continue;
+        }
+        let lowest = -Infinity;
+        let highest = Infinity;
+        for (const edge of edges) {
+          const from = inside2.has(edge.from);
+          const to = inside2.has(edge.to);
+          if (from === to) continue;
+          const slack = slackOf(edge, rank);
+          if (from) lowest = Math.max(lowest, -slack);
+          else highest = Math.min(highest, slack);
+        }
+        const step = lowest > -Infinity ? lowest : highest;
+        for (const node of members) if (!inside2.has(node)) rank[node] += step;
+      }
+    }
+    function walkTree(members, edges, tree) {
+      const adjacency = /* @__PURE__ */ new Map();
+      const link = (node, other) => {
+        adjacency.set(node, [...adjacency.get(node) ?? [], { node: other }]);
+      };
+      for (const index of tree) {
+        const edge = edges[index];
+        link(edge.from, edge.to);
+        link(edge.to, edge.from);
+      }
+      const parent = /* @__PURE__ */ new Map();
+      const first = /* @__PURE__ */ new Map();
+      const size = /* @__PURE__ */ new Map();
+      const order2 = [];
+      const seen = /* @__PURE__ */ new Set();
+      const root = members[0];
+      const stack = [root];
+      seen.add(root);
+      parent.set(root, -1);
+      while (stack.length > 0) {
+        const node = stack.pop();
+        first.set(node, order2.length);
+        order2.push(node);
+        for (const step of adjacency.get(node)) {
+          if (seen.has(step.node)) continue;
+          seen.add(step.node);
+          parent.set(step.node, node);
+          stack.push(step.node);
+        }
+      }
+      for (let index = order2.length - 1; index >= 0; index -= 1) {
+        const node = order2[index];
+        size.set(node, (size.get(node) ?? 0) + 1);
+        const above = parent.get(node);
+        if (above !== void 0 && above >= 0) size.set(above, (size.get(above) ?? 0) + size.get(node));
+      }
+      return { parent, first, size, order: order2 };
+    }
+    function solveComponent(size, members, edges, rank) {
+      if (members.length < 2) {
+        if (members.length === 1) rank[members[0]] = 0;
+        return;
+      }
+      const tree = /* @__PURE__ */ new Set();
+      buildTightTree(members, edges, rank, tree);
+      const spanning = tree.size === members.length - 1;
+      if (spanning) improve(size, members, edges, tree, rank);
+      let top = Infinity;
+      for (const node of members) top = Math.min(top, rank[node]);
+      for (const node of members) rank[node] -= top;
+    }
+    function improve(size, members, edges, tree, rank) {
+      const incoming = new Float64Array(size);
+      const outgoing = new Float64Array(size);
+      for (const edge of edges) {
+        outgoing[edge.from] += edge.weight;
+        incoming[edge.to] += edge.weight;
+      }
+      const cap = Math.max(50, 8 * members.length + 4 * edges.length);
+      for (let iteration = 0; iteration < cap; iteration += 1) {
+        const walk = walkTree(members, edges, tree);
+        const entering = /* @__PURE__ */ new Map();
+        const leaving = /* @__PURE__ */ new Map();
+        for (let index = walk.order.length - 1; index >= 0; index -= 1) {
+          const node = walk.order[index];
+          entering.set(node, incoming[node] + (entering.get(node) ?? 0));
+          leaving.set(node, outgoing[node] + (leaving.get(node) ?? 0));
+          const above = walk.parent.get(node);
+          if (above === void 0 || above < 0) continue;
+          entering.set(above, (entering.get(above) ?? 0) + entering.get(node));
+          leaving.set(above, (leaving.get(above) ?? 0) + leaving.get(node));
+        }
+        const holds = (node, child) => {
+          const start = walk.first.get(child);
+          const at = walk.first.get(node);
+          return at >= start && at < start + walk.size.get(child);
+        };
+        let worst = -1;
+        let worstEdge = -1;
+        let worstChild = -1;
+        for (const index of tree) {
+          const edge = edges[index];
+          const child = walk.parent.get(edge.from) === edge.to ? edge.from : edge.to;
+          const tailInside = holds(edge.from, child);
+          const value = tailInside ? leaving.get(child) - entering.get(child) : entering.get(child) - leaving.get(child);
+          if (value < 0 && (worstEdge < 0 || value < worst)) {
+            worst = value;
+            worstEdge = index;
+            worstChild = child;
+          }
+        }
+        if (worstEdge < 0) return;
+        const leavingEdge = edges[worstEdge];
+        const headInside = !holds(leavingEdge.from, worstChild);
+        const inHead = (node) => headInside ? holds(node, worstChild) : !holds(node, worstChild);
+        let enteringEdge = -1;
+        let step = Infinity;
+        for (const [index, edge] of edges.entries()) {
+          if (tree.has(index)) continue;
+          if (!inHead(edge.from) || inHead(edge.to)) continue;
+          const slack = slackOf(edge, rank);
+          if (slack < step || slack === step && (enteringEdge < 0 || index < enteringEdge)) {
+            step = slack;
+            enteringEdge = index;
+          }
+        }
+        if (enteringEdge < 0 || step === Infinity) return;
+        if (step !== 0) {
+          for (const node of members) if (inHead(node)) rank[node] += step;
+        }
+        tree.delete(worstEdge);
+        tree.add(enteringEdge);
+      }
+    }
+    function minimumLength(problem) {
+      const rank = problem.start.slice();
+      for (const members of componentsOf(problem.count, problem.edges)) {
+        const inside2 = new Set(members);
+        const local = problem.edges.filter((edge) => inside2.has(edge.from) && inside2.has(edge.to));
+        const pinned = problem.pinned !== void 0 && inside2.has(problem.pinned) ? problem.pinned : void 0;
+        const pinnedRank = pinned === void 0 ? void 0 : rank[pinned];
+        if (pinned !== void 0 && pinnedRank !== void 0 && members.every((node) => rank[node] >= pinnedRank)) {
+          for (const node of members) if (node !== pinned) local.push({ from: pinned, to: node, minLength: 0, weight: 0 });
+        }
+        solveComponent(problem.count, members, local, rank);
+      }
+      return rank;
+    }
+    
+    // src/render/layer.ts
+    function longestPath(ids, edges, index) {
+      const rank = new Array(ids.length).fill(0);
+      const pending = new Array(ids.length).fill(0);
+      const outgoing = ids.map(() => []);
+      for (const edge of edges) {
+        outgoing[index.get(edge.from)].push(index.get(edge.to));
+        pending[index.get(edge.to)] += 1;
+      }
+      const queue = [];
+      for (let node = 0; node < ids.length; node += 1) if (pending[node] === 0) queue.push(node);
+      for (let head = 0; head < queue.length; head += 1) {
+        const node = queue[head];
+        for (const target of outgoing[node]) {
+          rank[target] = Math.max(rank[target], rank[node] + 1);
+          pending[target] -= 1;
+          if (pending[target] === 0) queue.push(target);
+        }
+      }
+      return rank;
+    }
+    function layer(graph, edges) {
+      const ids = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const node of graph.nodes) {
+        if (seen.has(node.id)) continue;
+        seen.add(node.id);
+        ids.push(node.id);
+      }
+      const index = new Map(ids.map((id, offset) => [id, offset]));
+      const forward = edges.filter((edge) => index.has(edge.from) && index.has(edge.to) && edge.from !== edge.to);
+      const rankEdges = forward.map((edge) => ({
+        from: index.get(edge.from),
+        to: index.get(edge.to),
+        minLength: 1,
+        weight: 1
+      }));
+      let pinned;
+      if (graph.init !== void 0 && index.has(graph.init)) {
+        const start = index.get(graph.init);
+        const forced = forward.some((edge) => edge.to === graph.init);
+        if (!forced) pinned = start;
+      }
+      const rank = minimumLength({ count: ids.length, edges: rankEdges, start: longestPath(ids, forward, index), ...pinned === void 0 ? {} : { pinned } });
+      const layers = [];
+      for (const [offset, id] of ids.entries()) {
+        const depth = rank[offset];
+        while (layers.length <= depth) layers.push([]);
+        layers[depth].push(id);
+      }
+      const layerOf = new Map(ids.map((id, offset) => [id, rank[offset]]));
+      return { layers, layerOf };
+    }
+    
+    // src/render/layout.ts
+    function rankStates(nodes, edges, init) {
+      const ids = nodes.map((node) => node.id);
+      const known = new Set(ids);
+      const start = init !== void 0 && known.has(init) ? init : ids[0];
+      const outgoing = /* @__PURE__ */ new Map();
+      for (const edge of edges) {
+        if (!known.has(edge.from) || !known.has(edge.to)) continue;
+        outgoing.set(edge.from, [...outgoing.get(edge.from) ?? [], edge.to]);
+      }
+      const depth = /* @__PURE__ */ new Map();
+      if (start !== void 0) {
+        depth.set(start, 0);
+        const queue = [start];
+        while (queue.length > 0) {
+          const id = queue.shift();
+          const level = depth.get(id);
+          for (const target of outgoing.get(id) ?? []) {
+            if (depth.has(target)) continue;
+            depth.set(target, level + 1);
+            queue.push(target);
+          }
+        }
+      }
+      const rows = [];
+      for (const id of ids) {
+        const level = depth.get(id);
+        if (level === void 0) continue;
+        while (rows.length <= level) rows.push([]);
+        rows[level].push(id);
+      }
+      return { rows, unreachable: ids.filter((id) => !depth.has(id)) };
+    }
+    function seedOrder(graph) {
+      const ranked = rankStates(graph.nodes, graph.edges, graph.init);
+      const order2 = /* @__PURE__ */ new Map();
+      let index = 0;
+      for (const row of ranked.rows) for (const id of row) order2.set(id, index++);
+      for (const id of ranked.unreachable) order2.set(id, index++);
+      return order2;
+    }
+    
+    // src/render/order.ts
+    function locate(layers) {
+      const found = /* @__PURE__ */ new Map();
+      layers.forEach((layer2, depth) => layer2.forEach((id, index) => found.set(id, { layer: depth, index })));
+      return found;
+    }
+    function medianOf(id, neighbours, reference2, positions2) {
+      const found = (neighbours.get(id) ?? []).filter((other) => positions2.get(other)?.layer === reference2).map((other) => positions2.get(other).index).sort((left, right) => left - right);
+      if (found.length === 0) return positions2.get(id).index;
+      const middle = Math.floor(found.length / 2);
+      return found.length % 2 === 1 ? found[middle] : (found[middle - 1] + found[middle]) / 2;
+    }
+    function countCrossings(layers, chains) {
+      const positions2 = locate(layers);
+      const segments = /* @__PURE__ */ new Map();
+      for (const chain of chains) {
+        for (let cursor = 0; cursor + 1 < chain.path.length; cursor += 1) {
+          const top = positions2.get(chain.path[cursor]);
+          const bottom = positions2.get(chain.path[cursor + 1]);
+          if (top === void 0 || bottom === void 0 || bottom.layer !== top.layer + 1) continue;
+          const list = segments.get(top.layer) ?? [];
+          list.push({ top: top.index, bottom: bottom.index });
+          segments.set(top.layer, list);
+        }
+      }
+      let crossings = 0;
+      for (const list of segments.values()) {
+        for (let left = 0; left < list.length; left += 1) {
+          for (let right = left + 1; right < list.length; right += 1) {
+            if ((list[left].top - list[right].top) * (list[left].bottom - list[right].bottom) < 0) crossings += 1;
+          }
+        }
+      }
+      return crossings;
+    }
+    function order(seedLayers, chains, seed) {
+      const layers = seedLayers.map(
+        (layer2) => layer2.map((id, index) => ({ id, index })).sort((left, right) => (seed?.get(left.id) ?? Infinity) - (seed?.get(right.id) ?? Infinity) || left.index - right.index).map((entry) => entry.id)
+      );
+      const down = /* @__PURE__ */ new Map();
+      const up = /* @__PURE__ */ new Map();
+      for (const chain of chains) {
+        for (let cursor = 0; cursor + 1 < chain.path.length; cursor += 1) {
+          const top = chain.path[cursor];
+          const bottom = chain.path[cursor + 1];
+          down.set(top, [...down.get(top) ?? [], bottom]);
+          up.set(bottom, [...up.get(bottom) ?? [], top]);
+        }
+      }
+      let positions2 = locate(layers);
+      for (let round = 0; round < 4; round += 1) {
+        for (let depth = 1; depth < layers.length; depth += 1) {
+          const layer2 = layers[depth];
+          const sorted = layer2.map((id, index) => ({ id, index, median: medianOf(id, up, depth - 1, positions2) })).sort((left, right) => left.median - right.median || left.index - right.index).map((entry) => entry.id);
+          layers[depth] = sorted;
+          positions2 = locate(layers);
+        }
+        for (let depth = layers.length - 2; depth >= 0; depth -= 1) {
+          const layer2 = layers[depth];
+          const sorted = layer2.map((id, index) => ({ id, index, median: medianOf(id, down, depth + 1, positions2) })).sort((left, right) => left.median - right.median || left.index - right.index).map((entry) => entry.id);
+          layers[depth] = sorted;
+          positions2 = locate(layers);
+        }
+      }
+      let crossings = countCrossings(layers, chains);
+      for (let pass = 0; pass < 4; pass += 1) {
+        let improved = false;
+        for (const layer2 of layers) {
+          for (let index = 0; index + 1 < layer2.length; index += 1) {
+            const before = layer2[index];
+            layer2[index] = layer2[index + 1];
+            layer2[index + 1] = before;
+            const next = countCrossings(layers, chains);
+            if (next < crossings) {
+              crossings = next;
+              improved = true;
+            } else {
+              layer2[index + 1] = layer2[index];
+              layer2[index] = before;
+            }
+          }
+        }
+        if (!improved) break;
+      }
+      return { layers, crossings };
+    }
+    
+    // src/render/text.ts
+    var CHAR_WIDTH = 6.6;
+    var MAX_LINE_CHARS = 30;
+    var LINE_HEIGHT = 15;
+    var TEXT_PADDING = 12;
+    var MIN_NODE_WIDTH = 88;
+    var MAX_NODE_WIDTH = 260;
+    var BREAK = /<br\s*\/?>|\r?\n/gi;
+    function explicitLines(label) {
+      return label.split(BREAK).map((line) => line.trim());
+    }
+    function wrapLine(line, limit = MAX_LINE_CHARS) {
+      if (line === "") return [""];
+      const out = [];
+      let current = "";
+      for (const word of line.split(/\s+/).filter((part) => part !== "")) {
+        const candidate = current === "" ? word : current + " " + word;
+        if (candidate.length <= limit) {
+          current = candidate;
+          continue;
+        }
+        if (current !== "") out.push(current);
+        if (word.length <= limit) {
+          current = word;
+          continue;
+        }
+        let rest = word;
+        while (rest.length > limit) {
+          out.push(rest.slice(0, limit));
+          rest = rest.slice(limit);
+        }
+        current = rest;
+      }
+      if (current !== "") out.push(current);
+      return out.length === 0 ? [""] : out;
+    }
+    function measure(label) {
+      const lines = explicitLines(label).flatMap((line) => wrapLine(line));
+      const longest = lines.reduce((max, line) => Math.max(max, line.length), 0);
+      const width = Math.min(MAX_NODE_WIDTH, Math.max(MIN_NODE_WIDTH, longest * CHAR_WIDTH + TEXT_PADDING * 2));
+      const height = lines.length * LINE_HEIGHT + TEXT_PADDING;
+      return { lines, width, height };
+    }
+    function textWidth(text2) {
+      return text2.length * CHAR_WIDTH;
+    }
+    
+    // src/render/wrap.ts
+    var PAGE_ASPECT2 = 1.6;
+    var MIN_LAYERS_TO_WRAP = 4;
+    var STRIP_RATIO = 2;
+    function runHeight(layerHeight, first, last, gap) {
+      let total = 0;
+      for (let index = first; index <= last; index += 1) {
+        total += layerHeight[index];
+        if (index < last) total += gap;
+      }
+      return total;
+    }
+    function runWidth(layerWidth, first, last) {
+      let widest = 0;
+      for (let index = first; index <= last; index += 1) widest = Math.max(widest, layerWidth[index]);
+      return widest;
+    }
+    function shapeError(width, height, aspect) {
+      if (width <= 0 || height <= 0) return Infinity;
+      const ratio = Math.max(width, height) / Math.min(width, height);
+      return Math.abs(Math.log(ratio / aspect));
+    }
+    function planBands(layerWidth, layerHeight, gap, aspect = PAGE_ASPECT2) {
+      const count = layerWidth.length;
+      if (count === 0) return { bands: [], width: 0, height: 0 };
+      const single = {
+        bands: [{ first: 0, last: count - 1, offsetX: 0 }],
+        width: runWidth(layerWidth, 0, count - 1),
+        height: runHeight(layerHeight, 0, count - 1, gap)
+      };
+      if (count < MIN_LAYERS_TO_WRAP || single.height <= single.width * STRIP_RATIO) return single;
+      const columnGap = gap * 2;
+      let best = single;
+      let bestError = shapeError(single.width, single.height, aspect);
+      for (let bands = 2; bands < count; bands += 1) {
+        const base = Math.floor(count / bands);
+        const extra = count % bands;
+        const ranges = [];
+        let cursor = 0;
+        for (let band = 0; band < bands; band += 1) {
+          const size = base + (band < extra ? 1 : 0);
+          ranges.push({ first: cursor, last: cursor + size - 1 });
+          cursor += size;
+        }
+        let width = columnGap * (bands - 1);
+        let height = 0;
+        for (const range of ranges) {
+          width += runWidth(layerWidth, range.first, range.last);
+          height = Math.max(height, runHeight(layerHeight, range.first, range.last, gap));
+        }
+        if (shapeError(width, height, aspect) >= bestError) continue;
+        const planned = [];
+        let offsetX = 0;
+        for (const range of ranges) {
+          planned.push({ first: range.first, last: range.last, offsetX });
+          offsetX += runWidth(layerWidth, range.first, range.last) + columnGap;
+        }
+        best = { bands: planned, width, height };
+        bestError = shapeError(width, height, aspect);
+      }
+      return best;
+    }
+    
+    // src/render/place.ts
+    var MARGIN = 20;
+    var LAYER_GAP = 44;
+    var LABELLED_LAYER_GAP = 54;
+    var NODE_GAP = 30;
+    var LANE_CLEARANCE = 12;
+    var LANE_SPACING = 14;
+    var COMPONENT_GAP = 30;
+    var GROUP_PADDING = 10;
+    var GROUP_HEADER = 16;
+    function textOf(node) {
+      return measure(node.label !== void 0 && node.label !== "" ? node.label : node.id);
+    }
+    function groupTree(groups) {
+      const byId = new Map(groups.map((group) => [group.id, group]));
+      const owner = /* @__PURE__ */ new Map();
+      const bySize = [...groups].sort((left, right) => left.members.length - right.members.length);
+      for (const group of bySize) {
+        for (const member of group.members) if (!owner.has(member)) owner.set(member, group.id);
+      }
+      const declared = (group) => {
+        const parent = group.parent;
+        if (parent === void 0 || parent === group.id) return void 0;
+        return byId.has(parent) ? parent : void 0;
+      };
+      const members = new Map(groups.map((group) => [group.id, new Set(group.members)]));
+      const infer = (group) => {
+        let best;
+        for (const other of groups) {
+          if (other.id === group.id) continue;
+          const outer = members.get(other.id);
+          const inner = members.get(group.id);
+          if (inner.size === 0 || inner.size >= outer.size) continue;
+          let contained = true;
+          for (const member of inner) {
+            if (!outer.has(member)) {
+              contained = false;
+              break;
+            }
+          }
+          if (contained && (best === void 0 || outer.size < best.size)) best = { id: other.id, size: outer.size };
+        }
+        return best?.id;
+      };
+      const parentOf = /* @__PURE__ */ new Map();
+      for (const group of groups) {
+        const parent = declared(group) ?? infer(group);
+        if (parent !== void 0) parentOf.set(group.id, parent);
+      }
+      for (const group of groups) {
+        const seen = /* @__PURE__ */ new Set([group.id]);
+        let cursor = parentOf.get(group.id);
+        while (cursor !== void 0) {
+          if (seen.has(cursor)) {
+            parentOf.delete(cursor);
+            break;
+          }
+          seen.add(cursor);
+          cursor = parentOf.get(cursor);
+        }
+      }
+      const children = /* @__PURE__ */ new Map();
+      const roots = [];
+      for (const group of groups) {
+        const parent = parentOf.get(group.id);
+        if (parent === void 0) roots.push(group.id);
+        else children.set(parent, [...children.get(parent) ?? [], group.id]);
+      }
+      return { owner, parentOf, children, roots };
+    }
+    function place(diagram, top) {
+      const groups = diagram.groups ?? [];
+      const nodes = [];
+      const seenNode = /* @__PURE__ */ new Set();
+      for (const node of diagram.nodes) {
+        if (seenNode.has(node.id)) continue;
+        seenNode.add(node.id);
+        nodes.push(node);
+      }
+      const nodeById = new Map(nodes.map((node) => [node.id, node]));
+      const groupById = new Map(groups.map((group) => [group.id, group]));
+      const tree = groupTree(groups);
+      const appearance = /* @__PURE__ */ new Map();
+      for (const node of nodes) if (!appearance.has(node.id)) appearance.set(node.id, appearance.size);
+      for (const group of groups) if (!appearance.has(group.id)) appearance.set(group.id, appearance.size);
+      const visible = /* @__PURE__ */ new Set();
+      const asked = /* @__PURE__ */ new Map();
+      const isVisible = (id) => {
+        const known = asked.get(id);
+        if (known !== void 0) return known;
+        const group = groupById.get(id);
+        let found = false;
+        for (const member of group.members) {
+          if (tree.owner.get(member) === id && nodeById.has(member)) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          for (const child of tree.children.get(id) ?? []) {
+            if (isVisible(child)) {
+              found = true;
+              break;
+            }
+          }
+        }
+        asked.set(id, found);
+        if (found) visible.add(id);
+        return found;
+      };
+      for (const group of groups) isVisible(group.id);
+      const directNodes = (scope) => nodes.filter((node) => tree.owner.get(node.id) === scope).map((node) => node.id);
+      const directGroups = (scope) => (tree.children.get(scope) ?? []).filter((child) => visible.has(child));
+      const firstIndexCache = /* @__PURE__ */ new Map();
+      const firstIndexOf = (id) => {
+        const cached = firstIndexCache.get(id);
+        if (cached !== void 0) return cached;
+        if (nodeById.has(id)) return appearance.get(id);
+        const members = groupById.get(id).members.filter((member) => tree.owner.get(member) === id && nodeById.has(member)).map((member) => appearance.get(member));
+        const children = directGroups(id).map(firstIndexOf);
+        const all = [...members, ...children];
+        const found = Math.min(...all);
+        firstIndexCache.set(id, found);
+        return found;
+      };
+      const entityAt = (scope, id) => {
+        const boundary = groupById.get(id);
+        if (boundary !== void 0) {
+          if (!visible.has(id)) return void 0;
+          if (scope === void 0) {
+            let cursor = id;
+            while (tree.parentOf.has(cursor)) cursor = tree.parentOf.get(cursor);
+            return cursor;
+          }
+          return tree.parentOf.get(id) === scope ? id : void 0;
+        }
+        if (!nodeById.has(id)) return void 0;
+        const group = tree.owner.get(id);
+        if (scope === void 0) {
+          if (group === void 0 || !visible.has(group)) return id;
+          let cursor = group;
+          while (tree.parentOf.has(cursor)) cursor = tree.parentOf.get(cursor);
+          return cursor;
+        }
+        if (group === scope) return id;
+        if (group === void 0) return void 0;
+        return tree.parentOf.get(group) === scope && visible.has(group) ? group : void 0;
+      };
+      const groupLayouts = /* @__PURE__ */ new Map();
+      const measureGroup = (id) => {
+        const inside2 = buildLevel(id);
+        const size = {
+          width: Math.max(MIN_NODE_WIDTH, inside2.width) + GROUP_PADDING * 2,
+          height: inside2.height + GROUP_HEADER + GROUP_PADDING * 2
+        };
+        groupLayouts.set(id, inside2);
+        return size;
+      };
+      const entityOf = (id) => {
+        const node = nodeById.get(id);
+        if (node !== void 0) {
+          const text2 = textOf(node);
+          return { id, group: false, width: text2.width, height: text2.height };
+        }
+        const size = measureGroup(id);
+        return { id, group: true, width: size.width, height: size.height };
+      };
+      const entitiesIn = (scope) => {
+        const found = [];
+        if (scope === void 0) {
+          for (const node of nodes) {
+            const group = tree.owner.get(node.id);
+            if (group === void 0 || !visible.has(group)) found.push(entityOf(node.id));
+          }
+          for (const root2 of tree.roots) if (visible.has(root2)) found.push(entityOf(root2));
+        } else {
+          for (const id of directNodes(scope)) found.push(entityOf(id));
+          for (const id of directGroups(scope)) found.push(entityOf(id));
+        }
+        return found.sort((left, right2) => firstIndexOf(left.id) - firstIndexOf(right2.id));
+      };
+      const edgesIn = (scope) => {
+        const found = [];
+        diagram.edges.forEach((edge, index) => {
+          if (edge.from === edge.to) return;
+          const from = entityAt(scope, edge.from);
+          const to = entityAt(scope, edge.to);
+          if (from === void 0 || to === void 0 || from === to) return;
+          found.push({ index, from, to });
+        });
+        return found;
+      };
+      const pinnedAt = (scope) => {
+        if (diagram.init === void 0) return void 0;
+        const entity = entityAt(scope, diagram.init);
+        return entity === diagram.init || entity !== void 0 && groupById.has(entity) ? entity : void 0;
+      };
+      const layoutPiece = (entities, edges, pinned, seed) => {
+        const byId = new Map(entities.map((entity) => [entity.id, entity]));
+        const graph = {
+          nodes: entities.map((entity) => ({ id: entity.id, width: entity.width, height: entity.height })),
+          edges,
+          ...pinned === void 0 ? {} : { init: pinned }
+        };
+        const broken = breakCycles(graph);
+        const layered = layer(graph, broken.edges);
+        const augmented = addDummies(layered, broken.edges);
+        const ordered = order(augmented.layers, augmented.chains, seed);
+        const gap = edges.some((edge) => diagram.edges[edge.index].label !== "") ? LABELLED_LAYER_GAP : LAYER_GAP;
+        const coordinates = assignCoordinates(
+          {
+            layers: ordered.layers,
+            chains: augmented.chains,
+            sizeOf: (id) => {
+              const entity = byId.get(id);
+              return { width: entity.width, height: entity.height };
+            },
+            chainOf: augmented.chainOf
+          },
+          { gap: NODE_GAP, layerGap: gap }
+        );
+        const bands = planBands(coordinates.layerWidth, coordinates.layerHeight, gap);
+        const bandOfLayer = new Array(coordinates.layerHeight.length).fill(0);
+        bands.bands.forEach((band, index) => {
+          for (let depth = band.first; depth <= band.last; depth += 1) bandOfLayer[depth] = index;
+        });
+        const layerTop = [];
+        for (const band of bands.bands) {
+          let y = 0;
+          for (let depth = band.first; depth <= band.last; depth += 1) {
+            layerTop[depth] = y;
+            y += coordinates.layerHeight[depth] + gap;
+          }
+        }
+        const items = /* @__PURE__ */ new Map();
+        ordered.layers.forEach((row, depth) => {
+          const shift = bands.bands[bandOfLayer[depth]].offsetX;
+          const top2 = layerTop[depth];
+          const rowHeight = coordinates.layerHeight[depth];
+          for (const id of row) {
+            const entity = byId.get(id);
+            if (entity === void 0) continue;
+            const centre = coordinates.x.get(id);
+            items.set(id, {
+              box: {
+                x: centre + shift - entity.width / 2,
+                y: top2 + (rowHeight - entity.height) / 2,
+                width: entity.width,
+                height: entity.height
+              },
+              group: entity.group
+            });
+          }
+        });
+        const across2 = /* @__PURE__ */ new Set();
+        for (const edge of edges) {
+          const from = layered.layerOf.get(edge.from);
+          const to = layered.layerOf.get(edge.to);
+          if (bandOfLayer[from] !== bandOfLayer[to]) across2.add(edge.index);
+        }
+        const laneProposal = /* @__PURE__ */ new Map();
+        for (const chain of augmented.chains) {
+          if (chain.path.length <= 2) continue;
+          const lane = augmented.chainOf.get(chain.path[1]);
+          const fromLayer = layered.layerOf.get(chain.path[0]);
+          const proposed = coordinates.x.get(lane);
+          laneProposal.set(lane, proposed + bands.bands[bandOfLayer[fromLayer]].offsetX);
+        }
+        const itemBoxes = /* @__PURE__ */ new Map();
+        for (const [id, item] of items) itemBoxes.set(id, item.box);
+        const channels = assignChannels(
+          {
+            layers: ordered.layers,
+            chains: augmented.chains,
+            chainOf: augmented.chainOf,
+            boxes: itemBoxes,
+            layerY: layerTop,
+            layerHeight: coordinates.layerHeight,
+            laneX: laneProposal
+          },
+          { clearance: LANE_CLEARANCE, spacing: LANE_SPACING }
+        );
+        const lanes3 = /* @__PURE__ */ new Map();
+        for (const chain of augmented.chains) {
+          if (chain.path.length <= 2) continue;
+          const start = byId.get(chain.path[0]);
+          const end = byId.get(chain.path[chain.path.length - 1]);
+          if (start.group || end.group) continue;
+          const fromLayer = layered.layerOf.get(chain.path[0]);
+          const toLayer = layered.layerOf.get(chain.path[chain.path.length - 1]);
+          if (bandOfLayer[fromLayer] !== bandOfLayer[toLayer]) continue;
+          const channel = channels.lanes.get(chain.index);
+          lanes3.set(chain.index, {
+            points: channel.y.map((y) => ({ x: channel.x, y })),
+            reversed: broken.reversed.has(chain.index)
+          });
+        }
+        const runs2 = /* @__PURE__ */ new Map();
+        for (const [edgeIndex, y] of channels.runs) if (!across2.has(edgeIndex)) runs2.set(edgeIndex, y);
+        let right2 = 0;
+        let bottom = 0;
+        for (const entry of items.values()) {
+          right2 = Math.max(right2, entry.box.x + entry.box.width);
+          bottom = Math.max(bottom, entry.box.y + entry.box.height);
+        }
+        return { width: right2, height: bottom, items, lanes: lanes3, runs: runs2, across: across2 };
+      };
+      function buildLevel(scope) {
+        const entities = entitiesIn(scope);
+        if (entities.length === 0) {
+          return { width: 0, height: 0, items: /* @__PURE__ */ new Map(), lanes: /* @__PURE__ */ new Map(), runs: /* @__PURE__ */ new Map(), across: /* @__PURE__ */ new Set() };
+        }
+        const edges = edgesIn(scope);
+        const pinned = pinnedAt(scope);
+        const seed = seedOrder({ nodes: entities.map((entity) => ({ id: entity.id, width: entity.width, height: entity.height })), edges, ...pinned === void 0 ? {} : { init: pinned } });
+        const components = weakComponents(entities, edges);
+        const pieces = [];
+        for (const members of components) {
+          const inside2 = new Set(members);
+          const pieceEntities = entities.filter((entity) => inside2.has(entity.id));
+          const pieceEdges = edges.filter((edge) => inside2.has(edge.from) && inside2.has(edge.to));
+          const pin = pinned !== void 0 && inside2.has(pinned) ? pinned : void 0;
+          pieces.push(layoutPiece(pieceEntities, pieceEdges, pin, seed));
+        }
+        const packed = packRectangles(pieces.map((piece) => ({ width: piece.width, height: piece.height })), { gap: COMPONENT_GAP });
+        const layout = { width: packed.width, height: packed.height, items: /* @__PURE__ */ new Map(), lanes: /* @__PURE__ */ new Map(), runs: /* @__PURE__ */ new Map(), across: /* @__PURE__ */ new Set() };
+        pieces.forEach((piece, index) => {
+          for (const edgeIndex of piece.across) layout.across.add(edgeIndex);
+          const at = packed.placements[index];
+          for (const [id, item] of piece.items) {
+            layout.items.set(id, { box: { x: item.box.x + at.x, y: item.box.y + at.y, width: item.box.width, height: item.box.height }, group: item.group });
+          }
+          for (const [edgeIndex, lane] of piece.lanes) {
+            layout.lanes.set(edgeIndex, { points: lane.points.map((point) => ({ x: point.x + at.x, y: point.y + at.y })), reversed: lane.reversed });
+          }
+          for (const [edgeIndex, y] of piece.runs) layout.runs.set(edgeIndex, y + at.y);
+        });
+        return layout;
+      }
+      const root = buildLevel(void 0);
+      const boxes = /* @__PURE__ */ new Map();
+      const groupRects = /* @__PURE__ */ new Map();
+      const lanes2 = /* @__PURE__ */ new Map();
+      const runs = /* @__PURE__ */ new Map();
+      const across = /* @__PURE__ */ new Set();
+      const placeLevel = (layout, originX, originY) => {
+        for (const edgeIndex of layout.across) across.add(edgeIndex);
+        for (const [id, item] of layout.items) {
+          const box = { x: originX + item.box.x, y: originY + item.box.y, width: item.box.width, height: item.box.height };
+          if (item.group) {
+            groupRects.set(id, box);
+            const inside2 = groupLayouts.get(id);
+            placeLevel(inside2, box.x + (box.width - inside2.width) / 2, box.y + GROUP_HEADER + GROUP_PADDING);
+            continue;
+          }
+          boxes.set(id, box);
+        }
+        for (const [edgeIndex, lane] of layout.lanes) {
+          lanes2.set(edgeIndex, { points: lane.points.map((point) => ({ x: point.x + originX, y: point.y + originY })), reversed: lane.reversed });
+        }
+        for (const [edgeIndex, y] of layout.runs) runs.set(edgeIndex, y + originY);
+      };
+      placeLevel(root, MARGIN, top);
+      let right = MARGIN;
+      for (const box of boxes.values()) right = Math.max(right, box.x + box.width);
+      for (const box of groupRects.values()) right = Math.max(right, box.x + box.width);
+      return { boxes, groupRects, width: right + MARGIN, lanes: lanes2, runs, across };
+    }
+    
+    // src/render/route.ts
+    var LANE_GAP = 10;
+    var ROUTE_STUB = 16;
+    function normalOf(side) {
+      switch (side) {
+        case "top":
+          return { x: 0, y: -1 };
+        case "bottom":
+          return { x: 0, y: 1 };
+        case "left":
+          return { x: -1, y: 0 };
+        case "right":
+          return { x: 1, y: 0 };
+      }
+    }
+    var BEND_COST = 24;
+    function crossesBox(x1, y1, x2, y2, box) {
+      const minX = box.x + 0.5;
+      const maxX = box.x + box.width - 0.5;
+      const minY = box.y + 0.5;
+      const maxY = box.y + box.height - 0.5;
+      if (Math.abs(y1 - y2) < 1e-3) {
+        const y = y1;
+        if (y <= minY || y >= maxY) return false;
+        return Math.max(x1, x2) > minX && Math.min(x1, x2) < maxX;
+      }
+      if (Math.abs(x1 - x2) < 1e-3) {
+        const x = x1;
+        if (x <= minX || x >= maxX) return false;
+        return Math.max(y1, y2) > minY && Math.min(y1, y2) < maxY;
+      }
+      const steps = Math.max(8, Math.round(Math.hypot(x2 - x1, y2 - y1)));
+      for (let index = 0; index <= steps; index += 1) {
+        const x = x1 + (x2 - x1) * index / steps;
+        const y = y1 + (y2 - y1) * index / steps;
+        if (x > minX && x < maxX && y > minY && y < maxY) return true;
+      }
+      return false;
+    }
+    function anchor(box, side) {
+      switch (side) {
+        case "top":
+          return { x: box.x + box.width / 2, y: box.y };
+        case "bottom":
+          return { x: box.x + box.width / 2, y: box.y + box.height };
+        case "left":
+          return { x: box.x, y: box.y + box.height / 2 };
+        case "right":
+          return { x: box.x + box.width, y: box.y + box.height / 2 };
+      }
+    }
+    function approachSides(from, to) {
+      const fromCy = from.y + from.height / 2;
+      const toCy = to.y + to.height / 2;
+      if (Math.abs(toCy - fromCy) > 0.5) return toCy > fromCy ? { exit: "bottom", entry: "top" } : { exit: "top", entry: "bottom" };
+      const fromCx = from.x + from.width / 2;
+      const toCx = to.x + to.width / 2;
+      return toCx >= fromCx ? { exit: "right", entry: "left" } : { exit: "left", entry: "right" };
+    }
+    function lanes(obstacles, extra) {
+      const values = new Set(extra);
+      for (const box of obstacles) {
+        values.add(box.x - LANE_GAP);
+        values.add(box.x + box.width + LANE_GAP);
+        values.add(box.y - LANE_GAP);
+        values.add(box.y + box.height + LANE_GAP);
+      }
+      return [...values].sort((left, right) => left - right);
+    }
+    function facesAway(side, port, other) {
+      const normal = normalOf(side);
+      return normal.x * (other.x + other.width / 2 - port.x) + normal.y * (other.y + other.height / 2 - port.y) < 0;
+    }
+    function routeEdge(from, to, obstacles, anchors) {
+      const sides = approachSides(from, to);
+      const exitSide = anchors?.exitSide ?? sides.exit;
+      const entrySide = anchors?.entrySide ?? sides.entry;
+      const exit = anchors?.exit ?? anchor(from, exitSide);
+      const entry = anchors?.entry ?? anchor(to, entrySide);
+      const others = obstacles.filter((box) => box !== from && box !== to);
+      const own = [];
+      if (facesAway(exitSide, exit, to)) own.push(from);
+      if (facesAway(entrySide, entry, from)) own.push(to);
+      const blockers = own.length === 0 ? others : [...others, ...own];
+      const blockedStub = (point) => blockers.some((box) => point.x > box.x && point.x < box.x + box.width && point.y > box.y && point.y < box.y + box.height);
+      const outNormal = normalOf(exitSide);
+      const inNormal = normalOf(entrySide);
+      let exitStub = { x: exit.x + outNormal.x * ROUTE_STUB, y: exit.y + outNormal.y * ROUTE_STUB };
+      let entryStub = { x: entry.x + inNormal.x * ROUTE_STUB, y: entry.y + inNormal.y * ROUTE_STUB };
+      if (blockedStub(exitStub) || blockedStub(entryStub)) {
+        exitStub = exit;
+        entryStub = entry;
+      }
+      const straight = [exit, exitStub, entryStub, entry];
+      const axisAligned = Math.abs(exitStub.x - entryStub.x) < 0.5 || Math.abs(exitStub.y - entryStub.y) < 0.5;
+      if (axisAligned && !blockers.some((box) => crossesBox(exitStub.x, exitStub.y, entryStub.x, entryStub.y, box))) {
+        return { points: simplify(straight), routed: false };
+      }
+      const xs = lanes(blockers, [exitStub.x, entryStub.x]);
+      const ys = lanes(blockers, [exitStub.y, entryStub.y]);
+      const blocked = (x1, y1, x2, y2) => blockers.some((box) => crossesBox(x1, y1, x2, y2, box));
+      const start = { point: exitStub, axis: -1, cost: 0, bends: 0, path: exitStub === exit ? [exit] : [exit, exitStub] };
+      const queue = [start];
+      const best = /* @__PURE__ */ new Map();
+      const key = (point) => String(Math.round(point.x)) + "," + String(Math.round(point.y));
+      while (queue.length > 0) {
+        let index = 0;
+        for (let cursor = 1; cursor < queue.length; cursor += 1) if (queue[cursor].cost < queue[index].cost) index = cursor;
+        const current = queue.splice(index, 1)[0];
+        if (current.cost > (best.get(key(current.point)) ?? Infinity)) continue;
+        if (Math.abs(current.point.x - entryStub.x) < 0.5 && Math.abs(current.point.y - entryStub.y) < 0.5) {
+          return { points: simplify([...current.path, entryStub, entry]), routed: true };
+        }
+        const options = [];
+        for (const x of xs) if (Math.abs(x - current.point.x) > 0.5) options.push({ x, y: current.point.y });
+        for (const y of ys) if (Math.abs(y - current.point.y) > 0.5) options.push({ x: current.point.x, y });
+        for (const next of options) {
+          if (blocked(current.point.x, current.point.y, next.x, next.y)) continue;
+          const axis = Math.abs(next.y - current.point.y) < 0.5 ? 0 : 1;
+          const bend = current.axis === -1 || current.axis === axis ? 0 : 1;
+          const cost = current.cost + Math.abs(next.x - current.point.x) + Math.abs(next.y - current.point.y) + bend * BEND_COST;
+          const state = key(next);
+          if (cost >= (best.get(state) ?? Infinity)) continue;
+          best.set(state, cost);
+          queue.push({ point: next, axis, cost, bends: current.bends + bend, path: [...current.path, next] });
+        }
+      }
+      return { points: simplify(straight), routed: false };
+    }
+    function simplify(points) {
+      if (points.length <= 2) return points;
+      const out = [points[0]];
+      for (let index = 1; index < points.length - 1; index += 1) {
+        const previous = out[out.length - 1];
+        const current = points[index];
+        const next = points[index + 1];
+        const collinear = Math.abs(previous.x - current.x) < 0.5 && Math.abs(current.x - next.x) < 0.5 || Math.abs(previous.y - current.y) < 0.5 && Math.abs(current.y - next.y) < 0.5;
+        if (!collinear) out.push(current);
+      }
+      out.push(points[points.length - 1]);
+      return out;
+    }
+    
+    // src/render/symbol.ts
+    function cubicPoint(curve, t) {
+      const u = 1 - t;
+      const a = u * u * u;
+      const b = 3 * u * u * t;
+      const c = 3 * u * t * t;
+      const d = t * t * t;
+      return {
+        x: a * curve.from.x + b * curve.c1.x + c * curve.c2.x + d * curve.to.x,
+        y: a * curve.from.y + b * curve.c1.y + c * curve.c2.y + d * curve.to.y
+      };
+    }
+    function diamondPoints(box) {
+      return [
+        { x: box.x + box.width / 2, y: box.y },
+        { x: box.x + box.width, y: box.y + box.height / 2 },
+        { x: box.x + box.width / 2, y: box.y + box.height },
+        { x: box.x, y: box.y + box.height / 2 }
+      ];
+    }
+    function hasDiscretePorts(shape) {
+      return shape === "diamond" || shape === "circle";
+    }
+    function hexagonCut(width) {
+      return Math.min(12, width / 4);
+    }
+    function hexagonPoints(box) {
+      const cut2 = hexagonCut(box.width);
+      return [
+        { x: box.x + cut2, y: box.y },
+        { x: box.x + box.width - cut2, y: box.y },
+        { x: box.x + box.width, y: box.y + box.height / 2 },
+        { x: box.x + box.width - cut2, y: box.y + box.height },
+        { x: box.x + cut2, y: box.y + box.height },
+        { x: box.x, y: box.y + box.height / 2 }
+      ];
+    }
+    function stadiumRadius(box) {
+      return Math.min(box.height / 2, box.width / 2);
+    }
+    function cylinderCaps(box) {
+      const cap = Math.min(10, box.height / 3);
+      return {
+        cap,
+        top: {
+          from: { x: box.x, y: box.y + cap },
+          c1: { x: box.x, y: box.y },
+          c2: { x: box.x + box.width, y: box.y },
+          to: { x: box.x + box.width, y: box.y + cap }
+        },
+        bottom: {
+          from: { x: box.x + box.width, y: box.y + box.height - cap },
+          c1: { x: box.x + box.width, y: box.y + box.height },
+          c2: { x: box.x, y: box.y + box.height },
+          to: { x: box.x, y: box.y + box.height - cap }
+        }
+      };
+    }
+    function cylinderApex(box, side) {
+      const caps = cylinderCaps(box);
+      return cubicPoint(side === "top" ? caps.top : caps.bottom, 0.5);
+    }
+    
+    // src/render/palette.ts
+    var NEUTRAL_LIGHT = {
+      pass: "#2f8f5b",
+      findings: "#b7791f",
+      fail: "#c0392b",
+      undecided: "#6b7280",
+      muted: "#9aa3ad",
+      text: "#1f2933",
+      edge: "#6b7280",
+      surface: "transparent",
+      background: "#ffffff"
+    };
+    var NEUTRAL_DARK = {
+      pass: "#4ac486",
+      findings: "#e0b050",
+      fail: "#f2705f",
+      undecided: "#9aa3ad",
+      muted: "#7d8794",
+      text: "#e6e8eb",
+      edge: "#8b949e",
+      surface: "transparent",
+      background: "#0d1117"
+    };
+    var GITHUB_LIGHT = {
+      pass: "#1a7f37",
+      findings: "#9a6700",
+      fail: "#cf222e",
+      undecided: "#656d76",
+      muted: "#8c959f",
+      text: "#1f2328",
+      edge: "#656d76",
+      surface: "transparent",
+      background: "#ffffff"
+    };
+    var GITHUB_DARK = {
+      pass: "#3fb950",
+      findings: "#d29922",
+      fail: "#f85149",
+      undecided: "#7d8590",
+      muted: "#6e7681",
+      text: "#e6edf3",
+      edge: "#7d8590",
+      surface: "transparent",
+      background: "#0d1117"
+    };
+    var HIGH_CONTRAST = {
+      pass: "#0a5c35",
+      findings: "#7a4300",
+      fail: "#a30000",
+      undecided: "#333333",
+      muted: "#444444",
+      text: "#000000",
+      edge: "#000000",
+      surface: "transparent",
+      background: "#ffffff"
+    };
+    var PRINT = {
+      pass: "#333333",
+      findings: "#555555",
+      fail: "#000000",
+      undecided: "#666666",
+      muted: "#777777",
+      text: "#000000",
+      edge: "#333333",
+      surface: "transparent",
+      background: "#ffffff"
+    };
+    var SCHEMES = {
+      default: { light: NEUTRAL_LIGHT, dark: NEUTRAL_DARK },
+      github: { light: GITHUB_LIGHT, dark: GITHUB_DARK },
+      "high-contrast": { light: HIGH_CONTRAST },
+      print: { light: PRINT }
+    };
+    function palette(overrides = {}, options = {}) {
+      const scheme = options.scheme ?? "default";
+      const mode = options.mode ?? "light";
+      const chosen = SCHEMES[scheme] ?? SCHEMES.default;
+      const base = mode === "dark" ? chosen.dark ?? chosen.light : chosen.light;
+      return { ...base, ...overrides };
+    }
+    function roleForVerdict(verdict) {
+      if (verdict === "pass") return "pass";
+      if (verdict === "pass_with_findings") return "findings";
+      if (verdict === "fail") return "fail";
+      return "undecided";
+    }
+    function schemeNames() {
+      return Object.keys(SCHEMES);
+    }
+    
+    // src/render/model.ts
+    function emptyDiagram(title, caption) {
+      return { kind: "none", title, nodes: [], edges: [], caption };
+    }
+    function labelOf(node) {
+      return node.label !== void 0 && node.label !== "" ? node.label : node.id;
+    }
+    
+    // src/render/paint.ts
+    var TITLE_HEIGHT = 26;
+    var CAPTION_CHARS = 78;
+    var CAPTION_LINE = 15;
+    var CAPTION_GAP = 16;
+    var CAPTION_CHAR_WIDTH = 6.2;
+    var PORT_SEPARATION = 14;
+    var PORT_SIDES = ["top", "right", "bottom", "left"];
+    var isVerticalSide = (side) => side === "top" || side === "bottom";
+    var MULTI_EDGE_SPACING = 20;
+    function packPorts(wanted, low, high) {
+      const placed = [];
+      let previous = low - PORT_SEPARATION;
+      for (const value of wanted) {
+        previous = Math.min(high, Math.max(value, previous + PORT_SEPARATION));
+        placed.push(previous);
+      }
+      let next = high + PORT_SEPARATION;
+      for (let index = placed.length - 1; index >= 0; index -= 1) {
+        next = Math.max(low, Math.min(placed[index], next - PORT_SEPARATION));
+        placed[index] = next;
+      }
+      return placed;
+    }
+    function roleOfNode(node) {
+      if (node.role === "error") return "fail";
+      if (node.role === "warning") return "findings";
+      if (node.role === "muted") return "muted";
+      return "edge";
+    }
+    function wrap(text2, limit) {
+      const lines = [];
+      let line = "";
+      for (const word of text2.split(/\s+/).filter((part) => part !== "")) {
+        const candidate = line === "" ? word : line + " " + word;
+        if (candidate.length <= limit) {
+          line = candidate;
+          continue;
+        }
+        if (line !== "") lines.push(line);
+        line = "";
+        let rest = word;
+        while (rest.length > limit) {
+          lines.push(rest.slice(0, limit));
+          rest = rest.slice(limit);
+        }
+        line = rest;
+      }
+      if (line !== "") lines.push(line);
+      return lines.length === 0 ? [""] : lines;
+    }
+    function captionRole(caption) {
+      return roleForVerdict(caption.split(" \u2014 ")[0]);
+    }
+    var LABEL_HEIGHT = 12;
+    var LABEL_PAD = 2;
+    var LABEL_STEP = 3;
+    function placeLabel(label, from, to, boxes, placed, segments) {
+      const width = textWidth(label);
+      const height = LABEL_HEIGHT;
+      const spotAt = (x, y) => ({ x, y, width, height });
+      const hitsBox = (spot, box) => spot.x - spot.width / 2 < box.x + box.width + LABEL_PAD && spot.x + spot.width / 2 > box.x - LABEL_PAD && spot.y - spot.height / 2 < box.y + box.height + LABEL_PAD && spot.y + spot.height / 2 > box.y - LABEL_PAD;
+      const hitsSpot = (spot, other) => spot.x - spot.width / 2 < other.x + other.width / 2 + LABEL_PAD && spot.x + spot.width / 2 > other.x - other.width / 2 - LABEL_PAD && spot.y - spot.height / 2 < other.y + other.height / 2 + LABEL_PAD && spot.y + spot.height / 2 > other.y - other.height / 2 - LABEL_PAD;
+      const hitsSegment = (spot, segment) => spot.x + spot.width / 2 > Math.min(segment.x1, segment.x2) - LABEL_PAD && spot.x - spot.width / 2 < Math.max(segment.x1, segment.x2) + LABEL_PAD && spot.y + spot.height / 2 > Math.min(segment.y1, segment.y2) - LABEL_PAD && spot.y - spot.height / 2 < Math.max(segment.y1, segment.y2) + LABEL_PAD;
+      const clearOfBoxes = (spot) => {
+        for (const box of boxes) if (hitsBox(spot, box)) return false;
+        for (const earlier of placed) if (hitsSpot(spot, earlier)) return false;
+        return true;
+      };
+      const clearOfEdges = (spot) => {
+        for (const segment of segments) if (hitsSegment(spot, segment)) return false;
+        return true;
+      };
+      const middle = { x: (from.x + to.x) / 2, y: (from.y + to.y) / 2 };
+      const dx = to.x - from.x;
+      const dy = to.y - from.y;
+      const length = Math.abs(dx) + Math.abs(dy);
+      const ux = dx / length;
+      const uy = dy / length;
+      const along = Math.abs(ux) * width / 2 + Math.abs(uy) * height / 2;
+      const bound = Math.max(0, length / 2 - along);
+      const walk = [0];
+      for (let step = LABEL_STEP; step <= bound + 1e-3; step += LABEL_STEP) walk.push(step, -step);
+      const at = (offset) => spotAt(middle.x + ux * offset, middle.y + uy * offset);
+      for (const offset of walk) {
+        const spot = at(offset);
+        if (clearOfBoxes(spot) && clearOfEdges(spot)) return spot;
+      }
+      for (const offset of walk) {
+        const spot = at(offset);
+        if (clearOfBoxes(spot)) return spot;
+      }
+      return at(0);
+    }
+    function drawnExtent(shapes) {
+      let width = 0;
+      let height = 0;
+      const consider = (x, y) => {
+        if (x > width) width = x;
+        if (y > height) height = y;
+      };
+      for (const shape of shapes) {
+        switch (shape.kind) {
+          case "box":
+          case "group":
+            consider(shape.x + shape.width, shape.y + shape.height);
+            break;
+          case "link":
+            consider(Math.max(shape.x1, shape.x2), Math.max(shape.y1, shape.y2));
+            if (shape.label !== "") consider(shape.labelX + textWidth(shape.label) / 2, shape.labelY + LABEL_HEIGHT / 2);
+            break;
+          case "path": {
+            for (const point of shape.points) consider(point.x, point.y);
+            if (shape.label !== "") consider(shape.labelX + textWidth(shape.label) / 2, shape.labelY + LABEL_HEIGHT / 2);
+            break;
+          }
+          case "caption":
+          case "title":
+            consider(textWidth(shape.lines?.[0] ?? "") + shape.x, shape.y + 12);
+            break;
+        }
+      }
+      return { width, height };
+    }
+    function paintWith(diagram, overrides = {}, options = {}) {
+      const colours = palette(overrides, options);
+      const shapes = [];
+      const groups = diagram.groups ?? [];
+      const topOffset = MARGIN + TITLE_HEIGHT;
+      const placement = place(diagram, topOffset);
+      const { boxes, groupRects } = placement;
+      const endBox = (id) => boxes.get(id) ?? groupRects.get(id);
+      const shapeById = /* @__PURE__ */ new Map();
+      for (const node of diagram.nodes) if (node.shape !== void 0 && !shapeById.has(node.id)) shapeById.set(node.id, node.shape);
+      const shapeOf = (id) => shapeById.get(id) ?? "rect";
+      for (const group of groups) {
+        const rect = groupRects.get(group.id);
+        if (rect === void 0) continue;
+        shapes.push({ kind: "group", id: group.id, x: rect.x, y: rect.y, width: rect.width, height: rect.height, label: group.label, colour: "muted" });
+      }
+      const drawn = /* @__PURE__ */ new Set();
+      const boxList = Array.from(boxes.values());
+      const routes = [];
+      for (const node of diagram.nodes) {
+        if (drawn.has(node.id)) continue;
+        const box = boxes.get(node.id);
+        drawn.add(node.id);
+        const text2 = textOf(node);
+        shapes.push({
+          kind: "box",
+          x: box.x,
+          y: box.y,
+          width: box.width,
+          height: box.height,
+          label: labelOf(node),
+          lines: text2.lines,
+          ...node.shape === void 0 ? {} : { shape: node.shape },
+          colour: roleOfNode(node),
+          initial: diagram.init === node.id
+        });
+      }
+      const roleById = new Map(diagram.nodes.map((node) => [node.id, roleOfNode(node)]));
+      const multiEdgeSets = /* @__PURE__ */ new Map();
+      diagram.edges.forEach((edge, index) => {
+        if (edge.from === edge.to) return;
+        if (endBox(edge.from) === void 0 || endBox(edge.to) === void 0) return;
+        const key = edge.from < edge.to ? edge.from + "\0" + edge.to : edge.to + "\0" + edge.from;
+        const list = multiEdgeSets.get(key);
+        if (list === void 0) multiEdgeSets.set(key, [index]);
+        else list.push(index);
+      });
+      const fanOf = /* @__PURE__ */ new Map();
+      for (const list of multiEdgeSets.values()) {
+        if (list.length < 2) continue;
+        list.forEach((index, position) => {
+          if (position === 0) return;
+          fanOf.set(index, (position % 2 === 1 ? 1 : -1) * Math.ceil(position / 2) * MULTI_EDGE_SPACING);
+        });
+      }
+      const endKey = (index, end) => String(index) + ":" + end;
+      const endsAt = /* @__PURE__ */ new Map();
+      for (const edge of diagram.edges) {
+        if (edge.from === edge.to) continue;
+        if (endBox(edge.from) === void 0 || endBox(edge.to) === void 0) continue;
+        endsAt.set(edge.from, (endsAt.get(edge.from) ?? 0) + 1);
+        endsAt.set(edge.to, (endsAt.get(edge.to) ?? 0) + 1);
+      }
+      const claimed = /* @__PURE__ */ new Map();
+      const claimedAt = /* @__PURE__ */ new Map();
+      const claim = (id, index, end, side) => {
+        claimed.set(endKey(index, end), side);
+        claimedAt.set(id, [...claimedAt.get(id) ?? [], side]);
+      };
+      const bestSide = (id, other) => {
+        const box = endBox(id);
+        const centre = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+        const toward = { x: other.x + other.width / 2 - centre.x, y: other.y + other.height / 2 - centre.y };
+        const reach = Math.hypot(toward.x, toward.y);
+        const taken = claimedAt.get(id) ?? [];
+        let best;
+        for (const side of PORT_SIDES) {
+          if (taken.includes(side)) continue;
+          const normal = normalOf(side);
+          const score = reach === 0 ? 0 : (normal.x * toward.x + normal.y * toward.y) / reach;
+          const point = anchor(box, side);
+          const near = Math.hypot(
+            Math.max(other.x - point.x, 0, point.x - (other.x + other.width)),
+            Math.max(other.y - point.y, 0, point.y - (other.y + other.height))
+          );
+          const better = best === void 0 || score > best.score + 1e-9 || Math.abs(score - best.score) <= 1e-9 && near < best.near - 1e-9;
+          if (better) best = { side, score, near };
+        }
+        return best?.side;
+      };
+      diagram.edges.forEach((edge, index) => {
+        if (edge.from === edge.to) return;
+        const source = endBox(edge.from);
+        const target = endBox(edge.to);
+        if (source === void 0 || target === void 0) return;
+        if (placement.across.has(index)) {
+          claim(edge.from, index, "exit", "right");
+          claim(edge.to, index, "entry", "left");
+          return;
+        }
+        const lane = placement.lanes.get(index);
+        if (lane === void 0 || lane.points.length === 0) return;
+        const down = target.y > source.y;
+        claim(edge.from, index, "exit", down ? "bottom" : "top");
+        claim(edge.to, index, "entry", down ? "top" : "bottom");
+      });
+      diagram.edges.forEach((edge, index) => {
+        if (edge.from === edge.to) return;
+        const source = endBox(edge.from);
+        const target = endBox(edge.to);
+        if (source === void 0 || target === void 0) return;
+        for (const end of ["exit", "entry"]) {
+          if (claimed.has(endKey(index, end))) continue;
+          const id = end === "exit" ? edge.from : edge.to;
+          if ((endsAt.get(id) ?? 0) < 2) continue;
+          if (!hasDiscretePorts(shapeOf(id))) continue;
+          const side = bestSide(id, end === "exit" ? target : source);
+          if (side === void 0) continue;
+          claim(id, index, end, side);
+        }
+      });
+      const facing = diagram.edges.map((edge, index) => {
+        const source = endBox(edge.from);
+        const target = endBox(edge.to);
+        if (source === void 0 || target === void 0 || edge.from === edge.to) return void 0;
+        const sides2 = placement.across.has(index) ? { exit: "right", entry: "left" } : approachSides(source, target);
+        const lane = placement.lanes.get(index);
+        if (lane === void 0 || lane.points.length === 0) {
+          return {
+            exit: claimed.get(endKey(index, "exit")) ?? sides2.exit,
+            entry: claimed.get(endKey(index, "entry")) ?? sides2.entry
+          };
+        }
+        const down = target.y > source.y;
+        return {
+          exit: claimed.get(endKey(index, "exit")) ?? (down ? "bottom" : "top"),
+          entry: claimed.get(endKey(index, "entry")) ?? (down ? "top" : "bottom"),
+          at: lane.points[0].x
+        };
+      });
+      const laneClear = (points, x, from, to) => {
+        for (let at = 0; at + 1 < points.length; at += 1) {
+          for (const box of boxList) {
+            if (box === from || box === to) continue;
+            if (crossesBox(x, points[at].y, x, points[at + 1].y, box)) return false;
+          }
+        }
+        return true;
+      };
+      const laneShift = /* @__PURE__ */ new Map();
+      for (const list of multiEdgeSets.values()) {
+        if (list.length < 2) continue;
+        const lead = placement.lanes.get(list[0]);
+        if (lead === void 0 || lead.points.length === 0) continue;
+        const base = lead.points[0].x;
+        const taken = /* @__PURE__ */ new Set();
+        for (const index of list) {
+          const lane = placement.lanes.get(index);
+          const own = lane.points[0].x;
+          const offset = fanOf.get(index) ?? 0;
+          const edge = diagram.edges[index];
+          const from = endBox(edge.from);
+          const to = endBox(edge.to);
+          let target = own;
+          if (offset !== 0) {
+            for (const candidate of [base + offset, own + offset]) {
+              if (taken.has(candidate) || !laneClear(lane.points, candidate, from, to)) continue;
+              target = candidate;
+              break;
+            }
+          }
+          taken.add(target);
+          if (target !== own) laneShift.set(index, target - own);
+        }
+      }
+      const wanted = /* @__PURE__ */ new Map();
+      const slotKey = (boxId, side, index) => boxId + ":" + side + ":" + String(index);
+      const spanOf2 = (boxId, side, corner) => {
+        const box = endBox(boxId);
+        const vertical = side === "top" || side === "bottom";
+        const middle = vertical ? box.x + box.width / 2 : box.y + box.height / 2;
+        const within = (low, high) => ({ low, high: Math.max(low, high) });
+        switch (shapeOf(boxId)) {
+          // The four vertices of a diamond, and the four cardinal points of an ellipse, are the middles of its sides.
+          case "diamond":
+          case "circle":
+            return within(middle, middle);
+          case "hexagon":
+            return vertical ? within(box.x + hexagonCut(box.width), box.x + box.width - hexagonCut(box.width)) : within(middle, middle);
+          case "stadium": {
+            const radius = stadiumRadius(box);
+            return vertical ? within(box.x + radius, box.x + box.width - radius) : within(middle, middle);
+          }
+          case "cylinder": {
+            if (vertical) return within(middle, middle);
+            const cap = cylinderCaps(box).cap;
+            return within(box.y + cap, box.y + box.height - cap);
+          }
+          default: {
+            const inset = corner ? 2 : vertical ? PORT_INSET : 8;
+            return vertical ? within(box.x + inset, box.x + box.width - inset) : within(box.y + inset, box.y + box.height - inset);
+          }
+        }
+      };
+      const clampTo = (boxId, side, value, corner) => {
+        const span = spanOf2(boxId, side, corner);
+        return Math.min(span.high, Math.max(span.low, value));
+      };
+      const pointOn = (boxId, side, along) => {
+        const box = endBox(boxId);
+        if (side === "left") return { x: box.x, y: along };
+        if (side === "right") return { x: box.x + box.width, y: along };
+        if (side === "top") return { x: along, y: shapeOf(boxId) === "cylinder" ? cylinderApex(box, "top").y : box.y };
+        return { x: along, y: shapeOf(boxId) === "cylinder" ? cylinderApex(box, "bottom").y : box.y + box.height };
+      };
+      for (const [index, entry] of facing.entries()) {
+        if (entry === void 0) continue;
+        const edge = diagram.edges[index];
+        const from = endBox(edge.from);
+        const to = endBox(edge.to);
+        const middle = (box, side) => isVerticalSide(side) ? box.x + box.width / 2 : box.y + box.height / 2;
+        const fromMiddle = middle(from, entry.exit);
+        const toMiddle = middle(to, entry.entry);
+        const corner = entry.at !== void 0;
+        const offset = fanOf.get(index) ?? 0;
+        let exitWanted;
+        let entryWanted;
+        if (entry.at !== void 0) {
+          const chosen = entry.at + (laneShift.get(index) ?? 0);
+          exitWanted = clampTo(edge.from, entry.exit, chosen, corner);
+          entryWanted = clampTo(edge.to, entry.entry, chosen, corner);
+        } else if (isVerticalSide(entry.exit) === isVerticalSide(entry.entry)) {
+          const target = spanOf2(edge.to, entry.entry, false);
+          const chosen = (fromMiddle >= target.low && fromMiddle <= target.high ? fromMiddle : clampTo(edge.from, entry.exit, toMiddle, false)) + offset;
+          exitWanted = clampTo(edge.from, entry.exit, chosen, corner);
+          entryWanted = clampTo(edge.to, entry.entry, chosen, corner);
+        } else {
+          exitWanted = hasDiscretePorts(shapeOf(edge.from)) ? fromMiddle : clampTo(edge.from, entry.exit, anchor(to, entry.entry).x + normalOf(entry.entry).x * ROUTE_STUB, false) + offset;
+          entryWanted = hasDiscretePorts(shapeOf(edge.to)) ? toMiddle : clampTo(edge.to, entry.entry, anchor(from, entry.exit).x + normalOf(entry.exit).x * ROUTE_STUB, false) + offset;
+        }
+        wanted.set(slotKey(edge.from, entry.exit, index), exitWanted);
+        wanted.set(slotKey(edge.to, entry.entry, index), entryWanted);
+      }
+      const sides = /* @__PURE__ */ new Map();
+      for (const [index, entry] of facing.entries()) {
+        if (entry === void 0) continue;
+        const edge = diagram.edges[index];
+        sides.set(edge.from + ":" + entry.exit, [
+          ...sides.get(edge.from + ":" + entry.exit) ?? [],
+          { index, wanted: wanted.get(slotKey(edge.from, entry.exit, index)) }
+        ]);
+        sides.set(edge.to + ":" + entry.entry, [
+          ...sides.get(edge.to + ":" + entry.entry) ?? [],
+          { index, wanted: wanted.get(slotKey(edge.to, entry.entry, index)) }
+        ]);
+      }
+      let placedPort = /* @__PURE__ */ new Map();
+      for (let round = 0; round < 3; round += 1) {
+        placedPort = /* @__PURE__ */ new Map();
+        for (const [key, list] of sides) {
+          const [boxId, side] = key.split(":");
+          const span = spanOf2(boxId, side, true);
+          const order2 = [...list].sort((left, right) => left.wanted - right.wanted || left.index - right.index);
+          const packed = packPorts(
+            order2.map((entry) => clampTo(boxId, side, entry.wanted, true)),
+            span.low,
+            span.high
+          );
+          order2.forEach((entry, at) => placedPort.set(slotKey(boxId, side, entry.index), packed[at]));
+        }
+        let moved = false;
+        for (const [index, entry] of facing.entries()) {
+          if (entry === void 0) continue;
+          const edge = diagram.edges[index];
+          const vertical = entry.exit === "bottom" || entry.exit === "top";
+          if (!vertical) continue;
+          const exit = placedPort.get(slotKey(edge.from, entry.exit, index));
+          if (Math.abs(exit - placedPort.get(slotKey(edge.to, entry.entry, index))) < 0.01) continue;
+          if (Math.abs(clampTo(edge.to, entry.entry, exit, true) - exit) > 0.01) continue;
+          for (const slot of sides.get(edge.to + ":" + entry.entry)) {
+            if (slot.index !== index) continue;
+            slot.wanted = exit;
+            moved = true;
+          }
+        }
+        if (!moved) break;
+      }
+      const portOf = (boxId, side, edgeIndex) => {
+        const coordinate = placedPort.get(slotKey(boxId, side, edgeIndex));
+        return pointOn(boxId, side, coordinate);
+      };
+      const anchorsFor = /* @__PURE__ */ new Map();
+      for (const [index, entry] of facing.entries()) {
+        if (entry === void 0) continue;
+        const edge = diagram.edges[index];
+        anchorsFor.set(index, {
+          exit: portOf(edge.from, entry.exit, index),
+          entry: portOf(edge.to, entry.entry, index),
+          exitSide: entry.exit,
+          entrySide: entry.entry
+        });
+      }
+      const longestRun = (points) => {
+        let best = { from: points[0], to: points[points.length - 1], length: -1 };
+        for (let index = 0; index + 1 < points.length; index += 1) {
+          const from = points[index];
+          const to = points[index + 1];
+          const length = Math.abs(to.x - from.x) + Math.abs(to.y - from.y);
+          if (length > best.length) best = { from, to, length };
+        }
+        return best;
+      };
+      const pointsOfRoute = (shape) => shape.kind === "path" ? shape.points : [{ x: shape.x1, y: shape.y1 }, { x: shape.x2, y: shape.y2 }];
+      const segmentsOfRoute = (shape) => {
+        const points = pointsOfRoute(shape);
+        const out = [];
+        for (let index = 0; index + 1 < points.length; index += 1) {
+          const from = points[index];
+          const to = points[index + 1];
+          out.push({ x1: from.x, y1: from.y, x2: to.x, y2: to.y });
+        }
+        return out;
+      };
+      const paintPath = (edge, points, colour) => {
+        const shape = {
+          kind: "path",
+          points,
+          label: edge.label,
+          labelX: 0,
+          labelY: 0,
+          colour,
+          ...edge.dashed === void 0 ? {} : { dashed: edge.dashed },
+          ...edge.arrow === void 0 ? {} : { arrow: edge.arrow }
+        };
+        shapes.push(shape);
+        routes.push(shape);
+      };
+      const paintRoute = (edge, points, colour) => {
+        if (points.length > 2) {
+          paintPath(edge, points, colour);
+          return;
+        }
+        const exit = points[0];
+        const entry = points[points.length - 1];
+        const shape = {
+          kind: "link",
+          x1: exit.x,
+          y1: exit.y,
+          x2: entry.x,
+          y2: entry.y,
+          label: edge.label,
+          labelX: 0,
+          labelY: 0,
+          colour,
+          ...edge.dashed === void 0 ? {} : { dashed: edge.dashed },
+          ...edge.arrow === void 0 ? {} : { arrow: edge.arrow }
+        };
+        shapes.push(shape);
+        routes.push(shape);
+      };
+      const runRoute = (ports, runY) => {
+        const out = isVerticalSide(ports.exitSide) ? 0 : normalOf(ports.exitSide).x * ROUTE_STUB;
+        const into = isVerticalSide(ports.entrySide) ? 0 : normalOf(ports.entrySide).x * ROUTE_STUB;
+        const points = [ports.exit];
+        if (out !== 0) points.push({ x: ports.exit.x + out, y: ports.exit.y });
+        points.push({ x: ports.exit.x + out, y: runY }, { x: ports.entry.x + into, y: runY });
+        if (into !== 0) points.push({ x: ports.entry.x + into, y: ports.entry.y });
+        points.push(ports.entry);
+        return simplify(points);
+      };
+      const runFits = (ports, runY) => {
+        if (isVerticalSide(ports.exitSide) && Math.abs(runY - ports.exit.y) > 0.5) {
+          if (Math.sign(runY - ports.exit.y) !== Math.sign(normalOf(ports.exitSide).y)) return false;
+        }
+        if (isVerticalSide(ports.entrySide) && Math.abs(ports.entry.y - runY) > 0.5) {
+          if (Math.sign(ports.entry.y - runY) !== -Math.sign(normalOf(ports.entrySide).y)) return false;
+        }
+        return true;
+      };
+      const clearsBoxes = (points, from, to) => {
+        for (let at = 0; at + 1 < points.length; at += 1) {
+          const a = points[at];
+          const b = points[at + 1];
+          for (const box of boxList) {
+            if (box === from || box === to) continue;
+            if (crossesBox(a.x, a.y, b.x, b.y, box)) return false;
+          }
+        }
+        return true;
+      };
+      for (const [edgeIndex, edge] of diagram.edges.entries()) {
+        const source = endBox(edge.from);
+        const target = endBox(edge.to);
+        if (source === void 0 || target === void 0) continue;
+        const colour = roleById.get(edge.from) ?? "muted";
+        if (edge.from === edge.to) {
+          const x = source.x + source.width;
+          const y = source.y + source.height / 2;
+          shapes.push({
+            kind: "path",
+            points: [
+              { x, y: y - 9 },
+              { x: x + 14, y: y - 9 },
+              { x: x + 14, y: y + 9 },
+              { x, y: y + 9 }
+            ],
+            label: edge.label,
+            // The one label that is not on its own edge: a self loop's longest run is eighteen points, and its name
+            // does not fit on that. It sits beside the loop, where it belongs to the edge and touches nothing.
+            labelX: x + 20 + textWidth(edge.label) / 2,
+            labelY: y,
+            colour,
+            ...edge.dashed === void 0 ? {} : { dashed: edge.dashed },
+            ...edge.arrow === void 0 ? {} : { arrow: edge.arrow }
+          });
+          continue;
+        }
+        const anchors = anchorsFor.get(edgeIndex);
+        const lane = placement.lanes.get(edgeIndex);
+        if (lane !== void 0 && lane.points.length > 0 && anchors !== void 0) {
+          const shift = laneShift.get(edgeIndex) ?? 0;
+          const ordered = lane.reversed ? [...lane.points].reverse() : lane.points;
+          const waypoints = shift === 0 ? ordered : ordered.map((point) => ({ x: point.x + shift, y: point.y }));
+          const points = [anchors.exit];
+          let previous = anchors.exit;
+          for (const waypoint of waypoints) {
+            if (Math.abs(previous.x - waypoint.x) > 0.5 && Math.abs(previous.y - waypoint.y) > 0.5) points.push({ x: previous.x, y: waypoint.y });
+            points.push(waypoint);
+            previous = waypoint;
+          }
+          if (Math.abs(previous.x - anchors.entry.x) > 0.5 && Math.abs(previous.y - anchors.entry.y) > 0.5) points.push({ x: anchors.entry.x, y: previous.y });
+          points.push(anchors.entry);
+          paintPath(edge, simplify(points), colour);
+          continue;
+        }
+        const runY = placement.runs.get(edgeIndex);
+        if (runY !== void 0 && anchors !== void 0 && runFits(anchors, runY)) {
+          const points = runRoute(anchors, runY);
+          const mixed = isVerticalSide(anchors.exitSide) !== isVerticalSide(anchors.entrySide);
+          if (!mixed || clearsBoxes(points, source, target)) {
+            paintRoute(edge, points, colour);
+            continue;
+          }
+        }
+        paintRoute(edge, routeEdge(source, target, boxList, anchors).points, colour);
+      }
+      const routeSegments = routes.map((shape) => segmentsOfRoute(shape));
+      const placedLabels = [];
+      routes.forEach((shape, index) => {
+        const run = longestRun(pointsOfRoute(shape));
+        let spot = { x: (run.from.x + run.to.x) / 2, y: (run.from.y + run.to.y) / 2, width: textWidth(shape.label), height: LABEL_HEIGHT };
+        if (shape.label !== "") {
+          spot = placeLabel(shape.label, run.from, run.to, boxList, placedLabels, routeSegments.flatMap((list, at) => at === index ? [] : list));
+          placedLabels.push(spot);
+        }
+        shape.labelX = spot.x;
+        shape.labelY = spot.y;
+      });
+      shapes.push({ kind: "title", x: MARGIN, y: MARGIN + 12, text: diagram.title, colour: "text" });
+      const contentRight = Math.max(
+        MARGIN,
+        ...Array.from(boxes.values(), (box) => box.x + box.width),
+        ...Array.from(groupRects.values(), (rect) => rect.x + rect.width)
+      );
+      const captionLines = wrap(diagram.caption, CAPTION_CHARS);
+      const captionWidth = Math.max(...captionLines.map((line) => line.length * CAPTION_CHAR_WIDTH)) + MARGIN * 2;
+      const width = Math.max(contentRight + MARGIN, captionWidth, 240);
+      const contentBottom = Math.max(
+        topOffset,
+        ...Array.from(boxes.values(), (box) => box.y + box.height),
+        ...Array.from(groupRects.values(), (rect) => rect.y + rect.height)
+      );
+      const captionTop = contentBottom + CAPTION_GAP;
+      shapes.push({ kind: "caption", x: MARGIN, y: captionTop, lines: captionLines, colour: captionRole(diagram.caption) });
+      const height = captionTop + captionLines.length * CAPTION_LINE + MARGIN / 2;
+      const extent = drawnExtent(shapes);
+      const canvasWidth = Math.max(width, extent.width + MARGIN);
+      const canvasHeight = Math.max(height, extent.height + MARGIN);
+      return { canvas: { width: Math.round(canvasWidth), height: Math.round(canvasHeight), shapes }, colours };
+    }
+    
+    // src/render/from-mermaid.ts
+    var CURVED_EDGE = /^(.+?)\s*(-->|---|-\.->|==>)\s*(?:\|([^|]*)\|\s*)?(.+)$/;
+    var LABELLED_EDGE = /^(.+?)\s*--\s*([^->]+?)\s*-->\s*(.+)$/;
+    var NODE = /^([A-Za-z_][\w-]*)\s*(?:\[\((.*)\)\]|\[\[(.*)\]\]|\[(.*)\]|\((.*)\)|\{(.*)\}|<<(.*)>>)?$/;
+    var TRANSITION = /^([A-Za-z_][\w-]*|\[\*\])\s*-->\s*([A-Za-z_][\w-]*|\[\*\])\s*(?::\s*(.*))?$/;
+    var STATE_ALIAS = /^state\s+["'](.+?)["']\s+as\s+([A-Za-z_][\w-]*)$/;
+    var DIRECTIVE = /^(click|style|classDef|class|linkStyle|accTitle|accDescr)\b/;
+    var UNSUPPORTED = /* @__PURE__ */ new Set([
+      "sequencediagram",
+      "classdiagram",
+      "erdiagram",
+      "gantt",
+      "pie",
+      "journey",
+      "mindmap",
+      "timeline",
+      "quadrantchart",
+      "gitgraph",
+      "c4context",
+      "requirementdiagram",
+      "sankey-beta"
+    ]);
+    function ensure(builder, id, label, shape) {
+      const existing = builder.nodes.get(id);
+      if (existing === void 0) {
+        builder.nodes.set(id, {
+          id,
+          role: "normal",
+          ...label === void 0 ? {} : { label },
+          ...shape === void 0 ? {} : { shape }
+        });
+        const innermost = builder.open[builder.open.length - 1];
+        if (innermost !== void 0 && !innermost.members.includes(id)) innermost.members.push(id);
+        return;
+      }
+      if (label !== void 0 && (existing.label === void 0 || existing.label === "")) existing.label = label;
+    }
+    function nodeFrom(token) {
+      const match = NODE.exec(token.trim());
+      if (match === null) return void 0;
+      const id = match[1];
+      const label = [match[2], match[3], match[4], match[5], match[6], match[7]].find((value) => value !== void 0 && value.trim() !== "");
+      const shape = match[2] !== void 0 ? "cylinder" : match[3] !== void 0 ? "subroutine" : match[4] !== void 0 ? "rect" : match[5] !== void 0 ? "stadium" : match[6] !== void 0 ? "diamond" : match[7] !== void 0 ? "hexagon" : void 0;
+      return {
+        id,
+        ...label === void 0 ? {} : { label: label.trim().replace(/^["']|["']$/g, "") },
+        ...shape === void 0 ? {} : { shape }
+      };
+    }
+    function fromMermaid(source, title = "mermaid") {
+      const lines = source.split(/\r?\n/);
+      const refused = [];
+      const builder = { nodes: /* @__PURE__ */ new Map(), edges: [], groups: [], open: [] };
+      let mode = "none";
+      let startId;
+      let endCount = 0;
+      const push = (edge) => {
+        builder.edges.push(edge);
+      };
+      lines.forEach((raw, index) => {
+        const line = raw.replace(/%%(.*)$/, "").trim();
+        if (line === "") return;
+        const where = "line " + String(index + 1) + ": ";
+        const lower = line.toLowerCase();
+        const keyword = lower.split(/[\s{}]/)[0];
+        if (UNSUPPORTED.has(keyword)) {
+          refused.push(where + "`" + keyword + "` is not a diagram this renderer draws");
+          return;
+        }
+        if (DIRECTIVE.test(line)) {
+          refused.push(where + "`" + line.split(/\s/)[0] + "` is a directive this renderer ignores");
+          return;
+        }
+        if (/^(graph|flowchart)\b/.test(lower)) {
+          mode = "graph";
+          return;
+        }
+        if (/^statediagram(-v2)?\b/.test(lower)) {
+          mode = "state";
+          return;
+        }
+        if (/^subgraph\b/.test(lower)) {
+          const label = line.replace(/^subgraph\b/i, "").trim().replace(/^["']|["']$/g, "");
+          const id = "subgraph-" + String(++endCount);
+          builder.open.push({ id, label: label === "" ? id : label, members: [] });
+          return;
+        }
+        if (lower === "end") {
+          const closed = builder.open.pop();
+          if (closed !== void 0) {
+            const container = builder.open[builder.open.length - 1];
+            if (container !== void 0) closed.parent = container.id;
+            builder.groups.push(closed);
+          }
+          return;
+        }
+        if (mode === "state") {
+          const alias = STATE_ALIAS.exec(line);
+          if (alias !== null) {
+            ensure(builder, alias[2], alias[1]);
+            return;
+          }
+          const transition = TRANSITION.exec(line);
+          if (transition === null) {
+            const bare = /^state\s+([A-Za-z_][\w-]*)$/.exec(line);
+            if (bare !== null) {
+              ensure(builder, bare[1]);
+              return;
+            }
+            if (/^[A-Za-z_][\w-]*$/.test(line)) {
+              ensure(builder, line);
+              return;
+            }
+            refused.push(where + "`" + line + "` is not a state transition this renderer draws");
+            return;
+          }
+          const from = transition[1];
+          const to = transition[2];
+          const label = (transition[3] ?? "").trim();
+          if (from === "[*]") {
+            ensure(builder, to);
+            if (startId === void 0) startId = to;
+            return;
+          }
+          if (to === "[*]") {
+            ensure(builder, from);
+            push({ from, to: from, label: label === "" ? "end" : label, dashed: true });
+            return;
+          }
+          ensure(builder, from);
+          ensure(builder, to);
+          push({ from, to, label });
+          return;
+        }
+        const labelled = LABELLED_EDGE.exec(line);
+        if (labelled !== null) {
+          const left = nodeFrom(labelled[1]);
+          const right = nodeFrom(labelled[3]);
+          if (left === void 0 || right === void 0) {
+            refused.push(where + "`" + line + "` does not name two nodes");
+            return;
+          }
+          ensure(builder, left.id, left.label, left.shape);
+          ensure(builder, right.id, right.label, right.shape);
+          push({ from: left.id, to: right.id, label: labelled[2].trim() });
+          return;
+        }
+        const edge = CURVED_EDGE.exec(line);
+        if (edge !== null) {
+          const left = nodeFrom(edge[1]);
+          const right = nodeFrom(edge[4]);
+          if (left === void 0 || right === void 0) {
+            refused.push(where + "`" + line + "` does not name two nodes");
+            return;
+          }
+          ensure(builder, left.id, left.label, left.shape);
+          ensure(builder, right.id, right.label, right.shape);
+          push({
+            from: left.id,
+            to: right.id,
+            label: (edge[3] ?? "").trim(),
+            ...edge[2] === "-.->" || edge[2] === "==>" ? { dashed: true } : {}
+          });
+          return;
+        }
+        const single = nodeFrom(line);
+        if (single !== void 0) {
+          ensure(builder, single.id, single.label, single.shape);
+          return;
+        }
+        refused.push(where + "`" + line + "` is not something this renderer draws");
+      });
+      if (mode === "none") {
+        return { diagram: emptyDiagram(title, "no mermaid diagram found"), refused };
+      }
+      if (builder.nodes.size === 0) {
+        return { diagram: emptyDiagram(title, "no nodes found"), refused };
+      }
+      const diagram = {
+        kind: mode === "state" ? "machine" : "graph",
+        title,
+        ...startId === void 0 ? {} : { init: startId },
+        nodes: [...builder.nodes.values()],
+        edges: builder.edges,
+        ...builder.groups.length === 0 ? {} : { groups: builder.groups },
+        caption: mode + ", " + String(builder.nodes.size) + " box" + (builder.nodes.size === 1 ? "" : "es") + ", " + String(builder.edges.length) + " arrow" + (builder.edges.length === 1 ? "" : "s") + (refused.length === 0 ? "" : ", " + String(refused.length) + " line(s) refused")
+      };
+      return { diagram, refused };
+    }
+    
+    // src/render/collapse.ts
+    function subtreeSize(groups, groupId, seen) {
+      if (seen.has(groupId)) return 0;
+      seen.add(groupId);
+      const group = groups.find((entry) => entry.id === groupId);
+      const children = groups.filter((entry) => entry.parent === groupId);
+      return group.members.length + children.reduce((total, child) => total + subtreeSize(groups, child.id, seen), 0);
+    }
+    function ownerOf(groups, nodeId) {
+      return groups.find((group) => group.members.includes(nodeId))?.id;
+    }
+    function collapse(diagram, folded) {
+      const asked = new Set(folded);
+      const groups = diagram.groups ?? [];
+      if (asked.size === 0 || groups.length === 0) return diagram;
+      const byId = new Map(groups.map((group) => [group.id, group]));
+      const targets = /* @__PURE__ */ new Set();
+      for (const id of asked) {
+        const group = byId.get(id);
+        if (group !== void 0 && subtreeSize(groups, id, /* @__PURE__ */ new Set()) > 0) targets.add(id);
+      }
+      if (targets.size === 0) return diagram;
+      for (const id of [...targets]) {
+        let cursor = byId.get(id)?.parent;
+        const seen = /* @__PURE__ */ new Set();
+        while (cursor !== void 0 && !seen.has(cursor)) {
+          seen.add(cursor);
+          if (targets.has(cursor)) {
+            targets.delete(id);
+            break;
+          }
+          cursor = byId.get(cursor)?.parent;
+        }
+      }
+      const removedNodes = /* @__PURE__ */ new Set();
+      const removedGroups = /* @__PURE__ */ new Set();
+      const descend = (groupId) => {
+        removedGroups.add(groupId);
+        const group = byId.get(groupId);
+        for (const member of group.members) removedNodes.add(member);
+        for (const child of groups.filter((entry) => entry.parent === groupId)) descend(child.id);
+      };
+      for (const id of targets) descend(id);
+      const foldOf = (id) => {
+        for (const target of targets) {
+          const inSubtree = (groupId, seen) => {
+            if (seen.has(groupId)) return false;
+            seen.add(groupId);
+            if (groupId === target) return true;
+            return groups.filter((entry) => entry.parent === groupId).some((child) => inSubtree(child.id, seen));
+          };
+          const group = byId.get(target);
+          if (group.members.includes(id) || inSubtree(ownerOf(groups, id), /* @__PURE__ */ new Set())) return target;
+        }
+        return void 0;
+      };
+      const nodes = [];
+      const emitted = /* @__PURE__ */ new Set();
+      for (const node of diagram.nodes) {
+        if (!removedNodes.has(node.id)) {
+          nodes.push(node);
+          continue;
+        }
+        const fold = foldOf(node.id);
+        if (fold === void 0 || emitted.has(fold)) continue;
+        emitted.add(fold);
+        const group = byId.get(fold);
+        nodes.push({ id: fold, label: group.label + " (" + String(subtreeSize(groups, fold, /* @__PURE__ */ new Set())) + ")", role: "normal" });
+      }
+      for (const id of targets) {
+        if (emitted.has(id)) continue;
+        const group = byId.get(id);
+        nodes.push({ id, label: group.label + " (" + String(subtreeSize(groups, id, /* @__PURE__ */ new Set())) + ")", role: "normal" });
+      }
+      const edges = [];
+      const seenEdges = /* @__PURE__ */ new Set();
+      for (const edge of diagram.edges) {
+        const from = removedNodes.has(edge.from) ? foldOf(edge.from) : edge.from;
+        const to = removedNodes.has(edge.to) ? foldOf(edge.to) : edge.to;
+        if (from === void 0 || to === void 0) continue;
+        if (from === to) continue;
+        const key = from + ">" + to + ":" + edge.label;
+        if (seenEdges.has(key)) continue;
+        seenEdges.add(key);
+        edges.push({ ...edge, from, to });
+      }
+      const adopted = /* @__PURE__ */ new Map();
+      for (const id of targets) {
+        const parent = byId.get(id)?.parent;
+        if (parent === void 0) continue;
+        adopted.set(parent, [...adopted.get(parent) ?? [], id]);
+      }
+      const remaining = groups.filter((group) => !removedGroups.has(group.id) && targets.has(group.id) === false).map((group) => {
+        const extra = adopted.get(group.id);
+        if (extra === void 0) return group;
+        return { ...group, members: [...group.members.filter((member) => !removedNodes.has(member)), ...extra] };
+      });
+      const caption = diagram.caption + (targets.size === 1 ? ", 1 group folded" : ", " + String(targets.size) + " groups folded");
+      return {
+        ...diagram,
+        nodes,
+        edges,
+        ...remaining.length === 0 ? { groups: void 0 } : { groups: remaining },
+        caption
+      };
+    }
+    
+    // src/render/from-plantuml.ts
+    var SHAPES = {
+      component: "rect",
+      node: "rect",
+      rectangle: "rect",
+      artifact: "rect",
+      state: "rect",
+      database: "cylinder",
+      // PlantUML draws an entity as a cylinder in a component diagram; `entity` in an ER diagram is a different
+      // symbol, and that diagram family is not one this renderer accepts.
+      entity: "cylinder",
+      // A use case is an ellipse. The `circle` symbol is written as an ellipse whose radii follow the box, so it
+      // reads as the familiar use-case oval; `stadium` is the pill a terminal state is drawn as.
+      usecase: "circle"
+    };
+    var BOUNDARY = /* @__PURE__ */ new Set(["package", "folder", "node", "component", "rectangle", "artifact"]);
+    var NOT_DRAWN = {
+      actor: "an actor is a stick figure, not one of the shapes this renderer draws",
+      participant: "a participant is a lifeline, not one of the shapes this renderer draws",
+      class: "a class box has compartments this renderer does not draw",
+      object: "an object box has compartments this renderer does not draw",
+      interface: "an interface is a circle or a boxed stereotype, neither of which this renderer draws",
+      enum: "an enum box has compartments this renderer does not draw",
+      annotation: "an annotation is not one of the shapes this renderer draws",
+      cloud: "a cloud outline is not one of the shapes this renderer draws",
+      frame: "a frame tab is not one of the shapes this renderer draws",
+      card: "a card is not one of the shapes this renderer draws",
+      file: "a file outline is not one of the shapes this renderer draws",
+      agent: "an agent is not one of the shapes this renderer draws",
+      boundary: "the boundary symbol is not one of the shapes this renderer draws",
+      control: "the control symbol is not one of the shapes this renderer draws",
+      collections: "a collections symbol is not one of the shapes this renderer draws",
+      queue: "a queue is not one of the shapes this renderer draws",
+      stack: "a stack is not one of the shapes this renderer draws",
+      storage: "a storage symbol is not one of the shapes this renderer draws",
+      note: "a note is not one of the shapes this renderer draws",
+      legend: "a legend is not one of the shapes this renderer draws"
+    };
+    var FRAGMENT = /* @__PURE__ */ new Set(["sequence", "alt", "opt", "loop", "par", "group", "ref", "break", "critical", "activate", "deactivate", "destroy", "create", "newpage", "autonumber"]);
+    var ARROW = /^(.+?)\s*(<\|?|[*o])?(-{2,}|\.{2,})(\|?>|[*o])?\s*(.+?)(?:\s*:\s*(.+))?$/;
+    var SHAPE_KEYWORDS = Object.keys(SHAPES);
+    var DECLARED = new RegExp("^(" + SHAPE_KEYWORDS.join("|") + ")\\s+(.+)$");
+    var QUOTED_ALIAS = /^["'](.+?)["']\s+as\s+([A-Za-z_][\w-]*)$/;
+    var BRACKET_ALIAS = /^\[(.+?)\]\s+as\s+([A-Za-z_][\w-]*)$/;
+    var PLAIN_ALIAS = /^([A-Za-z_][\w.-]*)\s+as\s+([A-Za-z_][\w-]*)$/;
+    var BRACKET = /^\[(.+?)\]$/;
+    var IGNORED = /^(skinparam|!theme|!define|!include|!pragma|hide|show|scale|left to right direction|top to bottom direction|together|allowmixing)\b/;
+    function ensure2(builder, id, label, shape, implicit = false) {
+      const existing = builder.nodes.get(id);
+      if (existing === void 0) {
+        builder.nodes.set(id, {
+          id,
+          role: "normal",
+          ...label === void 0 ? {} : { label },
+          ...shape === void 0 ? {} : { shape }
+        });
+        if (implicit) builder.implicit.add(id);
+        const innermost = builder.open[builder.open.length - 1];
+        if (innermost !== void 0 && !innermost.members.includes(id)) innermost.members.push(id);
+        return;
+      }
+      if (!implicit) builder.implicit.delete(id);
+      if (label !== void 0 && (existing.label === void 0 || existing.label === "")) existing.label = label;
+      if (shape !== void 0 && existing.shape === void 0) existing.shape = shape;
+    }
+    function reference(token) {
+      const text2 = token.trim();
+      const bracket = BRACKET.exec(text2);
+      if (bracket !== null) {
+        const label = bracket[1].trim();
+        return { id: label, label, shape: "rect" };
+      }
+      const quoted = /^["'](.+?)["']$/.exec(text2);
+      if (quoted !== null) return { id: quoted[1], label: quoted[1] };
+      return { id: text2 };
+    }
+    function keywordOf(line) {
+      return line.split(/[\s{]/)[0].toLowerCase();
+    }
+    function boundaryOf(declaration, keyword, ordinal) {
+      const rest = declaration.slice(keyword.length).trim();
+      const alias = QUOTED_ALIAS.exec(rest) ?? BRACKET_ALIAS.exec(rest) ?? PLAIN_ALIAS.exec(rest);
+      if (alias !== null) return { id: alias[2], label: alias[1] };
+      const label = rest.replace(/^["']|["']$/g, "");
+      return { id: "group-" + String(ordinal), label: label === "" ? keyword : label };
+    }
+    function readArrow(line) {
+      const match = ARROW.exec(line);
+      if (match === null) return void 0;
+      const left = reference(match[1]);
+      const right = reference(match[5]);
+      const leftMark = match[2];
+      const rightMark = match[4];
+      const dotted = match[3].startsWith(".");
+      const label = (match[6] ?? "").trim();
+      if (leftMark !== void 0 && rightMark !== void 0) {
+        return "an edge marked at both ends is not one this renderer draws";
+      }
+      if (leftMark === "*" || leftMark === "o" || rightMark === "*" || rightMark === "o") {
+        if (dotted) return "a dotted composition or aggregation is not one this renderer draws";
+        const atRight = rightMark === "*" || rightMark === "o";
+        const mark = atRight ? rightMark : leftMark;
+        return {
+          from: atRight ? right : left,
+          to: atRight ? left : right,
+          label,
+          dashed: false,
+          arrow: mark === "*" ? "composition" : "aggregation"
+        };
+      }
+      if (leftMark !== void 0) {
+        return {
+          from: right,
+          to: left,
+          label,
+          dashed: dotted,
+          arrow: leftMark === "<|" ? dotted ? "realization" : "generalization" : dotted ? "dependency" : "association"
+        };
+      }
+      if (rightMark !== void 0) {
+        return {
+          from: left,
+          to: right,
+          label,
+          dashed: dotted,
+          arrow: rightMark === "|>" ? dotted ? "realization" : "generalization" : dotted ? "dependency" : "association"
+        };
+      }
+      return "a line with no arrow end is not one this renderer draws; name the end it points at";
+    }
+    function fromPlantUml(source, title = "plantuml") {
+      const lines = source.split(/\r?\n/);
+      const refused = [];
+      const builder = { nodes: /* @__PURE__ */ new Map(), edges: [], edgeLines: [], edgeScopes: [], groups: [], open: [], implicit: /* @__PURE__ */ new Set() };
+      let startId;
+      let seenAny = false;
+      let groupCount = 0;
+      lines.forEach((raw, index) => {
+        const line = raw.replace(/'.*$/, "").trim();
+        if (line === "") return;
+        const where = "line " + String(index + 1) + ": ";
+        if (/^@(start|end)uml\b/.test(line)) return;
+        seenAny = true;
+        if (/^title\b/.test(line)) return;
+        if (IGNORED.test(line)) return;
+        const keyword = keywordOf(line);
+        const notDrawn = NOT_DRAWN[keyword];
+        if (notDrawn !== void 0) {
+          refused.push(where + "`" + keyword + "`: " + notDrawn);
+          return;
+        }
+        if (FRAGMENT.has(keyword)) {
+          refused.push(where + "`" + keyword + "`: a sequence statement is not part of a drawing this renderer makes");
+          return;
+        }
+        if (line === "}") {
+          const closing = builder.open.pop();
+          if (closing !== void 0) {
+            const container = builder.open[builder.open.length - 1];
+            if (container !== void 0) closing.parent = container.id;
+            builder.groups.push(closing);
+          }
+          return;
+        }
+        if (line.endsWith("{")) {
+          const declaration = line.slice(0, -1).trim();
+          const opener = keywordOf(declaration);
+          if (!BOUNDARY.has(opener)) {
+            const reason = SHAPES[opener] === void 0 ? "`" + declaration + "` is not a boundary this renderer draws" : "a `" + opener + "` block is not a boundary this renderer draws";
+            refused.push(where + reason);
+            return;
+          }
+          groupCount += 1;
+          const boundary = boundaryOf(declaration, opener, groupCount);
+          builder.open.push({ id: boundary.id, label: boundary.label, members: [] });
+          return;
+        }
+        if (line === "[*] --> [*]") return;
+        const startMarker = /^\[\*\]\s*-->\s*(.+)$/.exec(line);
+        if (startMarker !== null) {
+          const target = reference(startMarker[1]);
+          ensure2(builder, target.id, target.label, target.shape);
+          if (startId === void 0) startId = target.id;
+          return;
+        }
+        const declared = DECLARED.exec(line);
+        if (declared !== null) {
+          const shape = SHAPES[declared[1]];
+          const rest = declared[2].trim();
+          const quoted = QUOTED_ALIAS.exec(rest);
+          if (quoted !== null) {
+            ensure2(builder, quoted[2], quoted[1], shape);
+            return;
+          }
+          const bracketed = BRACKET_ALIAS.exec(rest);
+          if (bracketed !== null) {
+            ensure2(builder, bracketed[2], bracketed[1], shape);
+            return;
+          }
+          const plain = PLAIN_ALIAS.exec(rest);
+          if (plain !== null) {
+            ensure2(builder, plain[2], plain[1], shape);
+            return;
+          }
+          const written = reference(rest);
+          ensure2(builder, written.id, written.label, shape);
+          return;
+        }
+        const arrow = readArrow(line);
+        if (arrow !== void 0) {
+          if (typeof arrow === "string") {
+            refused.push(where + arrow);
+            return;
+          }
+          ensure2(builder, arrow.from.id, arrow.from.label, arrow.from.shape, true);
+          ensure2(builder, arrow.to.id, arrow.to.label, arrow.to.shape, true);
+          builder.edges.push({
+            from: arrow.from.id,
+            to: arrow.to.id,
+            label: arrow.label,
+            ...arrow.dashed ? { dashed: true } : {},
+            arrow: arrow.arrow
+          });
+          builder.edgeLines.push(index + 1);
+          builder.edgeScopes.push(builder.open[builder.open.length - 1]?.id);
+          return;
+        }
+        const single = BRACKET.exec(line);
+        if (single !== null) {
+          ensure2(builder, single[1].trim(), single[1].trim(), "rect");
+          return;
+        }
+        refused.push(where + "`" + line + "` is not something this renderer draws");
+      });
+      const boundaryNames = /* @__PURE__ */ new Map();
+      const disputedNames = /* @__PURE__ */ new Set();
+      for (const group of builder.groups) {
+        for (const name of [group.id, group.label]) {
+          const existing = boundaryNames.get(name);
+          if (existing !== void 0 && existing !== group.id) disputedNames.add(name);
+          else boundaryNames.set(name, group.id);
+        }
+      }
+      for (const name of disputedNames) boundaryNames.delete(name);
+      const boundaryAt = /* @__PURE__ */ new Map();
+      const ambiguousAt = /* @__PURE__ */ new Set();
+      for (const id of builder.implicit) {
+        if (disputedNames.has(id)) {
+          ambiguousAt.add(id);
+          builder.nodes.delete(id);
+        } else {
+          const groupId = boundaryNames.get(id);
+          if (groupId === void 0) continue;
+          boundaryAt.set(id, groupId);
+          builder.nodes.delete(id);
+        }
+        for (const group of builder.groups) {
+          const at = group.members.indexOf(id);
+          if (at >= 0) group.members.splice(at, 1);
+        }
+      }
+      const groupById = new Map(builder.groups.map((group) => [group.id, group]));
+      const childrenOf = /* @__PURE__ */ new Map();
+      for (const group of builder.groups) {
+        if (group.parent === void 0) continue;
+        childrenOf.set(group.parent, [...childrenOf.get(group.parent) ?? [], group.id]);
+      }
+      const drawable = /* @__PURE__ */ new Map();
+      const hasContents = (id) => {
+        const known = drawable.get(id);
+        if (known !== void 0) return known;
+        const group = groupById.get(id);
+        let found = false;
+        for (const member of group.members) {
+          if (builder.nodes.has(member)) {
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          for (const child of childrenOf.get(id) ?? []) {
+            if (hasContents(child)) {
+              found = true;
+              break;
+            }
+          }
+        }
+        drawable.set(id, found);
+        return found;
+      };
+      const boundaryLabel = (id) => groupById.get(id).label;
+      const within = (scope, boundary) => {
+        let cursor = scope;
+        while (cursor !== void 0) {
+          if (cursor === boundary) return true;
+          cursor = groupById.get(cursor).parent;
+        }
+        return false;
+      };
+      const keptEdges = [];
+      builder.edges.forEach((edge, index) => {
+        const where = "line " + String(builder.edgeLines[index]) + ": ";
+        const fromBoundary = boundaryAt.get(edge.from);
+        const toBoundary = boundaryAt.get(edge.to);
+        if (ambiguousAt.has(edge.from) || ambiguousAt.has(edge.to)) {
+          const name = ambiguousAt.has(edge.from) ? edge.from : edge.to;
+          refused.push(where + "`" + name + "` is the name of more than one block; an edge cannot say which boundary it means");
+          return;
+        }
+        if (fromBoundary !== void 0 && toBoundary !== void 0) {
+          refused.push(where + "`" + boundaryLabel(fromBoundary) + "` and `" + boundaryLabel(toBoundary) + "` are boundaries, not elements; an edge between two boundaries is not one this renderer draws");
+          return;
+        }
+        const boundary = fromBoundary ?? toBoundary;
+        if (boundary !== void 0) {
+          const group = groupById.get(boundary);
+          if (group.parent !== void 0) {
+            refused.push(where + "`" + group.label + "` is a block inside `" + boundaryLabel(group.parent) + "`, not an element; an edge to a nested boundary would have to enter another boundary");
+            return;
+          }
+          if (within(builder.edgeScopes[index], boundary)) {
+            refused.push(where + "`" + group.label + "` is the block this edge is written inside, not an element; an edge cannot leave a boundary and arrive at the same boundary");
+            return;
+          }
+          if (!hasContents(boundary)) {
+            refused.push(where + "`" + group.label + "` is a block with nothing drawn inside it, so there is no rectangle to attach the edge to");
+            return;
+          }
+        }
+        keptEdges.push({
+          ...edge,
+          ...fromBoundary === void 0 ? {} : { from: fromBoundary },
+          ...toBoundary === void 0 ? {} : { to: toBoundary }
+        });
+      });
+      builder.edges = keptEdges;
+      if (!seenAny || builder.nodes.size === 0) {
+        return { diagram: emptyDiagram(title, "no nodes found"), refused };
+      }
+      const diagram = {
+        kind: startId === void 0 ? "graph" : "machine",
+        title,
+        ...startId === void 0 ? {} : { init: startId },
+        nodes: [...builder.nodes.values()],
+        edges: builder.edges,
+        ...builder.groups.length === 0 ? {} : { groups: builder.groups },
+        caption: "plantuml, " + String(builder.nodes.size) + " box" + (builder.nodes.size === 1 ? "" : "es") + ", " + String(builder.edges.length) + " arrow" + (builder.edges.length === 1 ? "" : "s") + (refused.length === 0 ? "" : ", " + String(refused.length) + " line(s) refused")
+      };
+      return { diagram, refused };
+    }
+    
+    // src/render/svg.ts
+    function boxText(shape, stroke) {
+      const lines = shape.lines === void 0 || shape.lines.length === 0 ? [shape.label] : shape.lines;
+      const lineHeight = 15;
+      const first = shape.y + shape.height / 2 - (lines.length - 1) * lineHeight / 2 + 4;
+      const spans = lines.map((line, index) => '<tspan x="' + n(shape.x + shape.width / 2) + '" y="' + n(first + index * lineHeight) + '">' + escape(line) + "</tspan>").join("");
+      return '<text font-size="11" text-anchor="middle" fill="' + stroke + '">' + spans + "</text>";
+    }
+    var n = (value) => {
+      const rounded = Math.round(value * 10) / 10;
+      return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+    };
+    var escape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+    var writers = {
+      // A boundary is a dashed rectangle with its name in the top-left corner, drawn under everything else.
+      group: (shape, colours) => {
+        const stroke = colours[shape.colour];
+        return '<g data-group-id="' + escape(shape.id) + '" style="cursor:pointer"><rect x="' + n(shape.x) + '" y="' + n(shape.y) + '" width="' + n(shape.width) + '" height="' + n(shape.height) + '" rx="8" fill="none" stroke="' + stroke + '" stroke-width="1" stroke-dasharray="4 3" /><text x="' + n(shape.x + 6) + '" y="' + n(shape.y + 12) + '" font-size="10" fill="' + stroke + '">' + escape(shape.label) + "</text></g>";
+      },
+      box: (shape, colours) => {
+        const stroke = colours[shape.colour];
+        const width = shape.initial ? 2.5 : 1;
+        const tail = '" fill="' + colours.surface + '" stroke="' + stroke + '" stroke-width="' + n(width) + '" />';
+        const x = shape.x;
+        const y = shape.y;
+        const w = shape.width;
+        const h = shape.height;
+        const at = (point) => n(point.x) + " " + n(point.y);
+        const points = (list) => list.map((point) => n(point.x) + "," + n(point.y)).join(",");
+        const curve = (segment) => " C" + at(segment.c1) + " " + at(segment.c2) + " " + at(segment.to);
+        switch (shape.shape) {
+          // A decision: the notation wrote `{…}`, and a rounded rectangle would say "step".
+          case "diamond":
+            return '<polygon points="' + points(diamondPoints(shape)) + tail + boxText(shape, stroke);
+          case "hexagon":
+            return '<polygon points="' + points(hexagonPoints(shape)) + tail + boxText(shape, stroke);
+          // A datastore: the cylinder UML draws for a stored collection.
+          case "cylinder": {
+            const caps = cylinderCaps(shape);
+            const path = "M" + at(caps.top.from) + curve(caps.top) + " L" + at(caps.bottom.from) + curve(caps.bottom) + " Z";
+            return '<path d="' + path + tail + boxText(shape, stroke);
+          }
+          // A start or end state: the stadium a terminal node is drawn as.
+          case "stadium":
+            return '<rect x="' + n(x) + '" y="' + n(y) + '" width="' + n(w) + '" height="' + n(h) + '" rx="' + n(stadiumRadius(shape)) + tail + boxText(shape, stroke);
+          case "circle":
+            return '<ellipse cx="' + n(x + w / 2) + '" cy="' + n(y + h / 2) + '" rx="' + n(w / 2) + '" ry="' + n(h / 2) + tail + boxText(shape, stroke);
+          // A subroutine carries its double side lines.
+          case "subroutine":
+            return '<rect x="' + n(x) + '" y="' + n(y) + '" width="' + n(w) + '" height="' + n(h) + tail + '<line x1="' + n(x + 6) + '" y1="' + n(y) + '" x2="' + n(x + 6) + '" y2="' + n(y + h) + '" stroke="' + stroke + '" stroke-width="1" /><line x1="' + n(x + w - 6) + '" y1="' + n(y) + '" x2="' + n(x + w - 6) + '" y2="' + n(y + h) + '" stroke="' + stroke + '" stroke-width="1" />' + boxText(shape, stroke);
+          default:
+            return '<rect x="' + n(x) + '" y="' + n(y) + '" width="' + n(w) + '" height="' + n(h) + '" rx="6' + tail + boxText(shape, stroke);
+        }
+      },
+      link: (shape, colours) => {
+        const stroke = colours[shape.colour];
+        const marks = edgeMarks(
+          { x: shape.x1, y: shape.y1 },
+          { x: shape.x2, y: shape.y2 },
+          { x: shape.x1, y: shape.y1 },
+          { x: shape.x2, y: shape.y2 },
+          shape.arrow,
+          stroke,
+          colours.background
+        );
+        return '<line x1="' + n(shape.x1) + '" y1="' + n(shape.y1) + '" x2="' + n(shape.x2) + '" y2="' + n(shape.y2) + '" stroke="' + stroke + '" stroke-width="1"' + dash(shape) + " />" + marks + edgeLabel(shape.label, shape.labelX, shape.labelY, colours);
+      },
+      path: (shape, colours) => {
+        const stroke = colours[shape.colour];
+        const points = shape.points.map((point) => n(point.x) + "," + n(point.y)).join(" ");
+        const last = shape.points[shape.points.length - 1];
+        const before = shape.points[shape.points.length - 2] ?? last;
+        const first = shape.points[0];
+        const after = shape.points[1] ?? first;
+        return '<polyline points="' + points + '" fill="none" stroke="' + stroke + '" stroke-width="1" stroke-linejoin="round"' + dash(shape) + " />" + edgeMarks(first, after, before, last, shape.arrow, stroke, colours.background) + edgeLabel(shape.label, shape.labelX, shape.labelY, colours);
+      },
+      title: (shape, colours) => {
+        return '<text x="' + n(shape.x) + '" y="' + n(shape.y) + '" font-size="12" fill="' + colours[shape.colour] + '">' + escape(shape.text) + "</text>";
+      },
+      caption: (shape, colours) => {
+        const colour = colours[shape.colour];
+        const lines = shape.lines.map((line, index) => '<tspan x="' + n(shape.x) + '" dy="' + (index === 0 ? 0 : 15) + '">' + escape(line) + "</tspan>").join("");
+        return '<text x="' + n(shape.x) + '" y="' + n(shape.y + 11) + '" font-size="10" text-anchor="middle" fill="' + colour + '">' + lines + "</text>";
+      }
+    };
+    function dash(shape) {
+      return shape.dashed === true ? ' stroke-dasharray="4 3"' : "";
+    }
+    function edgeMarks(source, sourceNext, targetPrev, target, arrow, stroke, background) {
+      if (arrow === "composition" || arrow === "aggregation") {
+        return diamond(source, sourceNext, stroke, arrow === "composition" ? stroke : background);
+      }
+      if (arrow === "generalization" || arrow === "realization") {
+        return hollowTriangle(targetPrev, target, stroke, background);
+      }
+      return arrowHead(targetPrev.x, targetPrev.y, target.x, target.y, stroke);
+    }
+    function tipAndBase(from, to) {
+      const length = Math.hypot(to.x - from.x, to.y - from.y);
+      if (length < 1) return void 0;
+      const ux = (to.x - from.x) / length;
+      const uy = (to.y - from.y) / length;
+      const size = 7;
+      const half = 3.2;
+      const baseX = to.x - ux * size;
+      const baseY = to.y - uy * size;
+      return {
+        tip: n(to.x) + "," + n(to.y),
+        left: n(baseX - uy * half) + "," + n(baseY + ux * half),
+        right: n(baseX + uy * half) + "," + n(baseY - ux * half)
+      };
+    }
+    function arrowHead(x1, y1, x2, y2, stroke) {
+      const points = tipAndBase({ x: x1, y: y1 }, { x: x2, y: y2 });
+      if (points === void 0) return "";
+      return '<polygon points="' + points.tip + " " + points.left + " " + points.right + '" fill="' + stroke + '" />';
+    }
+    function hollowTriangle(from, to, stroke, background) {
+      const points = tipAndBase(from, to);
+      if (points === void 0) return "";
+      return '<polygon points="' + points.tip + " " + points.left + " " + points.right + '" fill="' + background + '" stroke="' + stroke + '" stroke-width="1" />';
+    }
+    function diamond(at, next, stroke, fill) {
+      const length = Math.hypot(next.x - at.x, next.y - at.y);
+      if (length < 1) return "";
+      const ux = (next.x - at.x) / length;
+      const uy = (next.y - at.y) / length;
+      const size = 12;
+      const half = 4;
+      const back = { x: at.x + ux * size, y: at.y + uy * size };
+      const middle = { x: at.x + ux * size / 2, y: at.y + uy * size / 2 };
+      const left = { x: middle.x - uy * half, y: middle.y + ux * half };
+      const right = { x: middle.x + uy * half, y: middle.y - ux * half };
+      const points = [at, left, back, right].map((point) => n(point.x) + "," + n(point.y)).join(" ");
+      return '<polygon points="' + points + '" fill="' + fill + '" stroke="' + stroke + '" stroke-width="1" />';
+    }
+    function edgeLabel(label, x, y, colours) {
+      if (typeof label !== "string" || label === "") return "";
+      const width = textWidth(label);
+      const left = x - width / 2;
+      const top = y - LABEL_HEIGHT / 2;
+      const baseline = y + 3.5;
+      return '<rect x="' + n(left) + '" y="' + n(top) + '" width="' + n(width) + '" height="' + n(LABEL_HEIGHT) + '" fill="' + colours.background + '" /><text x="' + n(x) + '" y="' + n(baseline) + '" font-size="10" text-anchor="middle" fill="' + colours.muted + '">' + escape(label) + "</text>";
+    }
+    function toSvg(canvas, colours, label) {
+      let dropped = 0;
+      const body = [];
+      for (const shape of canvas.shapes) {
+        const writer = writers[shape.kind];
+        if (writer === void 0) {
+          dropped += 1;
+          continue;
+        }
+        body.push(writer(shape, colours));
+      }
+      const header = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ' + n(canvas.width) + " " + n(canvas.height) + '" width="' + n(canvas.width) + '" height="' + n(canvas.height) + '" role="img"' + (label === void 0 ? "" : ' aria-label="' + escape(label) + '"') + ' font-family="system-ui, -apple-system, Segoe UI, sans-serif">';
+      const background = '<rect x="0" y="0" width="' + n(canvas.width) + '" height="' + n(canvas.height) + '" fill="' + colours.background + '" />';
+      return { markup: header + background + body.join("") + "</svg>", dropped };
+    }
+    
+    // src/render/index.ts
+    function detectNotation(source) {
+      const head = source.split(/\r?\n/).map((line) => line.trim()).find((line) => line !== "" && !line.startsWith("'") && !line.startsWith("//"));
+      if (head === void 0) return "mermaid";
+      return /^@start/.test(head) ? "plantuml" : "mermaid";
+    }
+    function render(input, overrides = {}, options = {}) {
+      const notation = input.notation === void 0 || input.notation === "auto" ? detectNotation(input.source) : input.notation;
+      const parsed = notation === "plantuml" ? fromPlantUml(input.source, input.title ?? "plantuml") : fromMermaid(input.source, input.title ?? "mermaid");
+      const diagram = input.folded === void 0 ? parsed.diagram : collapse(parsed.diagram, input.folded);
+      const { canvas, colours } = paintWith(diagram, overrides, options);
+      const written = toSvg(canvas, colours, diagram.title + ": " + diagram.caption);
+      return {
+        diagram,
+        canvas,
+        colours,
+        markup: written.markup,
+        notation,
+        refused: parsed.refused,
+        dropped: written.dropped
+      };
+    }
+    
+    // src/render/viewmodel.ts
+    var record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+    var array = (value) => Array.isArray(value) ? value : [];
+    var text = (value) => typeof value === "string" && value !== "" ? value : void 0;
+    function reportText(content) {
+      const parts = [];
+      for (const entry of array(content)) {
+        const block = record(entry);
+        const body = text(block?.text);
+        if (body !== void 0) parts.push(body);
+      }
+      return parts.join(String.fromCharCode(10));
+    }
+    function readReport(content) {
+      const body = reportText(content);
+      if (body === "") return {};
+      const verdict = /verdict=(\w+)/.exec(body)?.[1];
+      const named = /\[error\/([A-Z0-9_]+)\]\s*(.*)/.exec(body);
+      if (named !== null) return { verdict, code: named[1], message: named[2] };
+      const first = /first error:\s*([A-Z0-9_]+)/.exec(body);
+      return first === null ? { verdict } : { verdict, code: first[1] };
+    }
+    function readModel(args) {
+      const view = record(args);
+      if (view === void 0) return void 0;
+      const read = view.value;
+      if (typeof read === "function") return record(read("model"));
+      return record(view.model);
+    }
+    function machineOf(model) {
+      if (model === void 0) return void 0;
+      const states = array(model.states).map(record).filter((entry) => entry !== void 0 && typeof entry.id === "string");
+      if (states.length === 0) return void 0;
+      const edges = array(model.transitions).map(record).filter((entry) => entry !== void 0 && typeof entry.from === "string" && typeof entry.to === "string").map((entry) => ({ from: String(entry.from), to: String(entry.to), label: text(entry.event) ?? "" }));
+      return {
+        nodes: states.map((state) => ({ id: String(state.id), role: "normal" })),
+        edges,
+        ...typeof model.init === "string" ? { init: model.init } : {}
+      };
+    }
+    function captionOf(report) {
+      const verdict = report.verdict ?? "no report yet";
+      if (report.code === void 0) return verdict;
+      const message = report.message ?? "";
+      return verdict + " \u2014 " + report.code + (message === "" ? "" : ": " + message);
+    }
+    function blame(nodes, report) {
+      if (report.message === void 0) return nodes;
+      const message = report.message;
+      const named = nodes.filter((node) => {
+        const escaped = node.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp("(?<![A-Za-z0-9_])" + escaped + "(?![A-Za-z0-9_])").test(message);
+      }).map((node) => node.id);
+      if (named.length === 0) return nodes;
+      return nodes.map((node) => named.includes(node.id) ? { ...node, role: "error" } : node);
+    }
+    function viewModel(input) {
+      const block = record(input.block);
+      const title = text(block?.name) ?? text(input.toolName) ?? "tool";
+      const report = readReport(block?.content);
+      const parsed = record(block?.result);
+      const findings = array(parsed?.findings).map(record);
+      const firstError = findings.find((finding) => finding?.severity === "error");
+      const merged = {
+        verdict: text(parsed?.verdict) ?? report.verdict,
+        ...report.code === void 0 && typeof firstError?.code === "string" ? { code: firstError.code } : { code: report.code },
+        ...report.message === void 0 && typeof firstError?.message === "string" ? { message: firstError.message } : { message: report.message }
+      };
+      const caption = captionOf(merged);
+      const machine = machineOf(readModel(block?.args));
+      if (machine === void 0) {
+        return { kind: "none", title, nodes: [], edges: [], caption };
+      }
+      return {
+        kind: "machine",
+        title,
+        ...machine.init === void 0 ? {} : { init: machine.init },
+        nodes: blame(machine.nodes, merged),
+        edges: machine.edges,
+        caption
+      };
+    }
+    
+    // src/client.ts
+    var TOOL_NAMES = ["model_verify"];
+    function themeMode() {
+      try {
+        const scope = globalThis;
+        const body = scope.document?.body;
+        const computed = typeof scope.getComputedStyle === "function" && body !== void 0 ? scope.getComputedStyle(body) : void 0;
+        const colour = computed?.backgroundColor ?? "";
+        const rgb = /rgba?\((\d+),\s*(\d+),\s*(\d+)/.exec(colour);
+        if (rgb !== null) {
+          const [r, g, b] = [Number(rgb[1]), Number(rgb[2]), Number(rgb[3])];
+          return (0.299 * r + 0.587 * g + 0.114 * b) / 255 < 0.5 ? "dark" : "light";
+        }
+      } catch {
+      }
+      return "light";
+    }
+    function surfaceStyle(colours) {
+      return { background: colours.background, color: colours.text, padding: "4px 0", overflowX: "auto" };
+    }
+    var WHITEBOARD_ID = "model-everything-diagram";
+    var WHITEBOARD_SAMPLE = ["graph TD", "  a[Idea] --> b{Feasible?}", "  b -->|yes| c[Build]", "  b -->|no| d[Revise]", "  d --> a"].join("\n");
+    function viewFor(React, overrides = {}) {
+      return (props) => {
+        const diagram = viewModel({ phase: props.phase, toolName: props.toolName, block: props.block });
+        const { canvas, colours } = paintWith(diagram, overrides, { mode: themeMode() });
+        const written = toSvg(canvas, colours, diagram.kind === "none" ? diagram.caption : diagram.title + ": " + diagram.caption);
+        return React.createElement("div", {
+          style: surfaceStyle(colours),
+          dangerouslySetInnerHTML: { __html: written.markup }
+        });
+      };
+    }
+    function whiteboardFor(React, overrides = {}) {
+      const h = (type, props, ...children) => React.createElement(type, props, ...children);
+      return function Whiteboard() {
+        const useState = React.useState;
+        if (useState === void 0) {
+          return h(
+            "div",
+            { style: { padding: "8px" } },
+            h("textarea", {
+              value: WHITEBOARD_SAMPLE,
+              readOnly: true,
+              spellcheck: false,
+              rows: WHITEBOARD_SAMPLE.split("\n").length,
+              style: { width: "100%", font: "12px ui-monospace, SFMono-Regular, Menlo, monospace" }
+            }),
+            // The picker is present but inert: a host without hooks cannot hold the choice, and hiding the
+            // option would make the board look like it has none.
+            h(
+              "select",
+              { disabled: true, style: { margin: "4px 0", fontSize: "12px" } },
+              ...schemeNames().map((name) => h("option", { value: name, selected: name === "default" }, name))
+            ),
+            whiteboardBody(React, overrides, WHITEBOARD_SAMPLE, 1)
+          );
+        }
+        const [source, setSource] = useState(WHITEBOARD_SAMPLE);
+        const [zoom, setZoom] = useState(1);
+        const [scheme, setScheme] = useState("default");
+        const [fit, setFit] = useState(true);
+        const [folded, setFolded] = useState([]);
+        const drawn = drawSample(React, overrides, source, fit ? 0 : zoom, scheme, folded);
+        const textarea = h("textarea", {
+          value: source,
+          spellcheck: false,
+          rows: Math.min(12, Math.max(4, String(source).split("\n").length)),
+          style: { width: "100%", font: "12px ui-monospace, SFMono-Regular, Menlo, monospace", padding: "6px", resize: "vertical" },
+          onInput: (event) => setSource(String(event?.target?.value ?? ""))
+        });
+        const controls = h(
+          "div",
+          { style: { display: "flex", gap: "6px", alignItems: "center", padding: "4px 0", flexWrap: "wrap" } },
+          h("button", { type: "button", onClick: () => {
+            setFit(false);
+            setZoom(Math.max(0.5, Math.round((Number(zoom) - 0.25) * 100) / 100));
+          } }, "\u2212"),
+          h("span", { style: { fontSize: "12px", opacity: 0.7 } }, fit ? "fit" : String(Math.round(Number(zoom) * 100)) + "%"),
+          h("button", { type: "button", onClick: () => {
+            setFit(false);
+            setZoom(Math.min(3, Math.round((Number(zoom) + 0.25) * 100) / 100));
+          } }, "+"),
+          h("button", { type: "button", onClick: () => {
+            setFit(false);
+            setZoom(1);
+          } }, "reset"),
+          h("button", { type: "button", title: "Scale to the pane width", onClick: () => setFit(!fit) }, fit ? "fit: on" : "fit: off"),
+          folded.length === 0 ? null : h("button", { type: "button", title: "Unfold every group", onClick: () => setFolded([]) }, "unfold " + String(folded.length)),
+          h(
+            "select",
+            {
+              value: scheme,
+              title: "Colour scheme",
+              style: { marginLeft: "auto", fontSize: "12px" },
+              onChange: (event) => setScheme(String(event?.target?.value ?? "default"))
+            },
+            ...schemeNames().map((name) => h("option", { value: name, selected: name === scheme }, name))
+          )
+        );
+        return h(
+          "div",
+          { style: { display: "flex", flexDirection: "column", gap: "4px", height: "100%", boxSizing: "border-box", padding: "8px" } },
+          textarea,
+          controls,
+          // The drawing takes the rest of the pane and scrolls inside it, so an expanded tab uses its room.
+          h(
+            "div",
+            {
+              style: { flex: "1 1 auto", minHeight: "0", overflow: "auto" },
+              // A boundary carries its id in the markup, so one listener on the container is enough: no per-rect
+              // handler, and the handling survives a re-render that replaced the whole SVG.
+              onClick: (event) => {
+                const hit = event?.target?.closest?.("[data-group-id]");
+                const id = hit?.getAttribute?.("data-group-id");
+                if (typeof id !== "string" || id === "") return;
+                setFolded(folded.includes(id) ? folded.filter((entry) => entry !== id) : [...folded, id]);
+              }
+            },
+            drawn
+          )
+        );
+      };
+    }
+    function drawSample(React, overrides, source, zoom, scheme, folded = []) {
+      return whiteboardBody(React, overrides, source, zoom, scheme, folded);
+    }
+    function whiteboardBody(React, overrides, source, zoom, scheme = "default", folded = []) {
+      if (String(source).trim() === "") {
+        return React.createElement("p", { style: { fontSize: "12px", opacity: 0.7 } }, "Paste Mermaid or PlantUML above.");
+      }
+      const drawn = render({ source: String(source), folded }, overrides, { mode: themeMode(), scheme });
+      const zoomed = zoom === 0 ? drawn.markup.replace("<svg ", '<svg style="width: 100%; height: auto; display: block" ') : drawn.markup.replace("<svg ", '<svg style="zoom: ' + String(zoom) + '; display: block" ');
+      const refused = drawn.refused.length === 0 ? null : React.createElement("pre", {
+        style: { fontSize: "11px", color: "#b7791f", whiteSpace: "pre-wrap", margin: "6px 0" }
+      }, drawn.refused.join("\n"));
+      return React.createElement(
+        "div",
+        { style: { background: drawn.colours.background, color: drawn.colours.text, borderRadius: "6px" } },
+        React.createElement("div", { dangerouslySetInnerHTML: { __html: zoomed } }),
+        refused
+      );
+    }
+    var SIDEBAR_POLL_MS = 250;
+    var SIDEBAR_POLL_ATTEMPTS = 40;
+    function mountWhiteboard(React, ctx, options = {}) {
+      const schedule = options.schedule ?? ((run, delay) => {
+        const timer = globalThis.setTimeout;
+        return typeof timer === "function" ? timer(run, delay) : void 0;
+      });
+      let attempts = 0;
+      const attempt = () => {
+        attempts += 1;
+        const tabs = typeof ctx.get === "function" ? ctx.get("sidebarRightTabs") : void 0;
+        if (tabs === void 0 || typeof tabs.register !== "function") {
+          if (attempts < SIDEBAR_POLL_ATTEMPTS) schedule(attempt, SIDEBAR_POLL_MS);
+          return void 0;
+        }
+        tabs.register({
+          id: WHITEBOARD_ID,
+          kind: "panel",
+          keepMounted: true,
+          title: () => "Diagram",
+          guide: [
+            {
+              id: "diagram-whiteboard",
+              order: 120,
+              title: () => "Diagram",
+              description: () => "Paste Mermaid or PlantUML and read the drawing"
+            }
+          ]
+        });
+        return ctx.slots.register({ name: "sidebar.right.pane.tab", key: WHITEBOARD_ID }, whiteboardFor(React));
+      };
+      return attempt();
+    }
+    function factory(require2) {
+      const hostRequire = require2;
+      const React = hostRequire("react");
+      return {
+        inject: ["slots"],
+        mount: (ctx, options = {}) => mountWhiteboard(React, ctx, options),
+        apply(ctx) {
+          for (const name of TOOL_NAMES) {
+            ctx.slots.inject("tool.call.toolview", () => ctx.slots.register({ name: "tool.call.toolview", key: name }, viewFor(React)));
+          }
+          ctx.slots.inject("sidebar.right.pane.tab", () => mountWhiteboard(React, ctx));
+        }
+      };
+    }
+    
+    const create = module.exports.default ?? module.exports;
+    return create(require);
+  },
+});