@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/base/render/index.cjs

@@ -0,0 +1,1120 @@
+"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/base/render/index.ts
+var render_exports = {};
+__export(render_exports, {
+  graphSpecToAscii: () => graphSpecToAscii,
+  graphSpecToD2: () => graphSpecToD2,
+  graphSpecToJson: () => graphSpecToJson,
+  graphSpecToMermaid: () => graphSpecToMermaid,
+  graphSpecToMermaidUrl: () => graphSpecToMermaidUrl,
+  graphSpecToPretty: () => graphSpecToPretty,
+  layoutFrameToSvg: () => layoutFrameToSvg,
+  mermaidLiveUrl: () => mermaidLiveUrl
+});
+module.exports = __toCommonJS(render_exports);
+
+// src/base/render/_ascii-width.ts
+function cellWidth(code) {
+  if (code >= 768 && code <= 879 || // Combining Diacritical Marks
+  code >= 1155 && code <= 1161 || // Cyrillic combining marks
+  code >= 1425 && code <= 1469 || // Hebrew combining marks
+  code >= 1552 && code <= 1562 || // Arabic combining marks
+  code >= 1611 && code <= 1631 || // Arabic combining marks
+  code >= 1648 && code === 1648 || // Arabic superscript alef
+  code >= 1750 && code <= 1756 || // Arabic combining marks
+  code >= 1759 && code <= 1764 || // Arabic combining marks
+  code >= 1767 && code <= 1768 || // Arabic combining marks
+  code >= 1770 && code <= 1773 || // Arabic combining marks
+  code >= 1840 && code <= 1866 || // Syriac combining marks
+  code >= 1958 && code <= 1968 || // Thaana combining marks
+  code >= 2304 && code <= 2307 || // Devanagari combining marks
+  code >= 2362 && code <= 2383 || // Devanagari combining marks
+  code >= 2385 && code <= 2391 || // Devanagari combining marks
+  code >= 2402 && code <= 2403 || // Devanagari combining marks
+  code >= 2433 && code <= 2435 || // Bengali combining marks
+  code >= 2492 && code <= 2509 || // Bengali combining marks
+  code >= 2561 && code <= 2563 || // Gurmukhi combining marks
+  code >= 2620 && code <= 2641 || // Gurmukhi combining marks
+  code >= 2672 && code <= 2673 || // Gurmukhi combining marks
+  code >= 2677 && code === 2677 || // Gurmukhi combining mark
+  code >= 3633 && code === 3633 || // Thai combining mark
+  code >= 3636 && code <= 3642 || // Thai combining marks
+  code >= 3655 && code <= 3662 || // Thai combining marks
+  code >= 3761 && code === 3761 || // Lao combining mark
+  code >= 3764 && code <= 3772 || // Lao combining marks
+  code >= 3784 && code <= 3790 || // Lao combining marks
+  code >= 7616 && code <= 7679 || // Combining Diacritical Marks Supplement
+  code >= 8400 && code <= 8447 || // Combining Diacritical Marks for Symbols
+  code >= 65024 && code <= 65039 || // Variation Selectors
+  code >= 65056 && code <= 65071 || // Combining Half Marks
+  code === 8205) {
+    return 0;
+  }
+  if (code >= 4352 && code <= 4447 || // Hangul Jamo
+  code >= 8986 && code <= 8987 || // Watch, Hourglass
+  code >= 9001 && code <= 9002 || // Angle brackets
+  code >= 9193 && code <= 9203 || // Media control symbols
+  code >= 9208 && code <= 9210 || // Media control symbols
+  code >= 9725 && code <= 9726 || // Medium squares
+  code >= 9748 && code <= 9749 || // Umbrella, Hot Beverage
+  code >= 9800 && code <= 9811 || // Zodiac symbols
+  code === 9855 || // Wheelchair
+  code === 9875 || // Anchor
+  code === 9889 || // High Voltage
+  code >= 9898 && code <= 9899 || // Medium circles
+  code >= 9917 && code <= 9918 || // Soccer, Baseball
+  code >= 9924 && code <= 9925 || // Snowman, Sun behind cloud
+  code === 9934 || // Ophiuchus
+  code === 9940 || // No Entry
+  code === 9962 || // Church
+  code >= 9970 && code <= 9971 || // Fountain, Golf
+  code === 9973 || // Sailboat
+  code === 9978 || // Tent
+  code === 9981 || // Fuel Pump
+  code === 9986 || // Scissors
+  code === 9989 || // Check Mark
+  code >= 9992 && code <= 9997 || // Airplane...Writing Hand
+  code === 9999 || // Pencil
+  code >= 10067 && code <= 10069 || // Question marks
+  code === 10071 || // Exclamation
+  code >= 10133 && code <= 10135 || // Plus, Minus, Divide
+  code === 10160 || // Curly Loop
+  code === 10175 || // Double Curly Loop
+  code >= 10548 && code <= 10549 || // Arrows
+  code >= 11013 && code <= 11015 || // Arrows
+  code >= 11035 && code <= 11036 || // Squares
+  code === 11088 || // Star
+  code === 11093 || // Circle
+  code >= 11904 && code <= 12350 || // CJK Radicals, Symbols, Punctuation
+  code >= 12352 && code <= 12447 || // Hiragana
+  code >= 12448 && code <= 12543 || // Katakana
+  code >= 12549 && code <= 12591 || // Bopomofo
+  code >= 12593 && code <= 12686 || // Hangul Compatibility Jamo
+  code >= 12688 && code <= 12771 || // Kanbun, CJK Strokes
+  code >= 12784 && code <= 12830 || // Katakana Phonetic Extensions
+  code >= 12832 && code <= 12871 || // Enclosed CJK
+  code >= 12880 && code <= 19903 || // CJK Extensions + Unified block
+  code >= 19968 && code <= 40959 || // CJK Unified Ideographs
+  code >= 43360 && code <= 43388 || // Hangul Jamo Extended-A
+  code >= 44032 && code <= 55203 || // Hangul Syllables
+  code >= 63744 && code <= 64255 || // CJK Compatibility Ideographs
+  code >= 65040 && code <= 65049 || // Vertical forms
+  code >= 65072 && code <= 65131 || // CJK Compatibility Forms
+  code >= 65281 && code <= 65376 || // Fullwidth Forms (excl. halfwidth)
+  code >= 65504 && code <= 65510 || // Fullwidth Signs
+  code >= 126980 && code === 126980 || // Mahjong Red Dragon
+  code === 127183 || // Joker
+  code >= 127344 && code <= 127345 || // A/B buttons
+  code === 127358 || // O button
+  code === 127359 || // P button
+  code === 127374 || // AB button
+  code >= 127377 && code <= 127386 || // Squared symbols
+  code >= 127456 && code <= 127487 || // Regional Indicator Symbols
+  code >= 127488 && code <= 127490 || // Enclosed ideographic
+  code === 127514 || // Squared CJK
+  code === 127535 || // Squared CJK
+  code >= 127538 && code <= 127546 || // Squared CJK
+  code >= 127568 && code <= 127569 || // Circled ideographic
+  code >= 127744 && code <= 129535 || // Misc Symbols / Emoticons / Emoji
+  code >= 129536 && code <= 129791 || // Chess, Symbols Extended-A
+  code >= 129792 && code <= 130047 || // Symbols for Legacy Computing
+  code >= 131072 && code <= 196605 || // CJK Extension B-F (excl. nonchars)
+  code >= 196608 && code <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+function countCells(text) {
+  let cells = 0;
+  for (const ch of text) {
+    cells += cellWidth(ch.codePointAt(0));
+  }
+  return cells;
+}
+function truncateToCells(text, maxCells) {
+  if (maxCells <= 0) return "";
+  let cells = 0;
+  let out = "";
+  for (const ch of text) {
+    const w = cellWidth(ch.codePointAt(0));
+    if (cells + w > maxCells) {
+      if (maxCells <= 1) return "\u2026";
+      while (cells + 1 > maxCells && out.length > 0) {
+        const last = [...out].pop();
+        out = out.slice(0, -last.length);
+        cells -= cellWidth(last.codePointAt(0));
+      }
+      return `${out}\u2026`;
+    }
+    out += ch;
+    cells += w;
+  }
+  return out;
+}
+
+// src/base/render/_ascii-grid.ts
+var UNICODE = {
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  cornerTL: "\u250C",
+  cornerTR: "\u2510",
+  cornerBL: "\u2514",
+  cornerBR: "\u2518",
+  tDown: "\u252C",
+  tUp: "\u2534",
+  tRight: "\u251C",
+  tLeft: "\u2524",
+  cross: "\u253C",
+  arrowRight: "\u25B6",
+  arrowDown: "\u25BC",
+  arrowLeft: "\u25C0",
+  arrowUp: "\u25B2",
+  boxTL: "\u250C",
+  boxTR: "\u2510",
+  boxBL: "\u2514",
+  boxBR: "\u2518",
+  boxH: "\u2500",
+  boxV: "\u2502"
+};
+var ASCII = {
+  horizontal: "-",
+  vertical: "|",
+  cornerTL: "+",
+  cornerTR: "+",
+  cornerBL: "+",
+  cornerBR: "+",
+  tDown: "+",
+  tUp: "+",
+  tRight: "+",
+  tLeft: "+",
+  cross: "+",
+  arrowRight: ">",
+  arrowDown: "v",
+  arrowLeft: "<",
+  arrowUp: "^",
+  boxTL: "+",
+  boxTR: "+",
+  boxBL: "+",
+  boxBR: "+",
+  boxH: "-",
+  boxV: "|"
+};
+function renderGrid(layout, options) {
+  const glyphs = options.charset === "ascii" ? ASCII : UNICODE;
+  const width = layout.width;
+  const height = layout.height;
+  const grid = Array.from(
+    { length: height },
+    () => Array.from({ length: width }, () => " ")
+  );
+  const kind = Array.from(
+    { length: height },
+    () => Array.from({ length: width }, () => "empty")
+  );
+  for (const edge of layout.edges) {
+    drawEdge(grid, kind, glyphs, edge);
+  }
+  for (const box of layout.boxes) {
+    drawBox(grid, kind, glyphs, box, options.labelOf(box.id));
+  }
+  return grid.map((row) => stripTrailing(row.join(""))).join("\n");
+}
+function drawBox(grid, kind, glyphs, box, label) {
+  const { x, y, w, h } = box;
+  if (w < 2 || h < 2) {
+    if (h > 0) writeLabel(grid, kind, x, y, w, label);
+    return;
+  }
+  putBoxCell(grid, kind, x, y, glyphs.boxTL);
+  for (let cx = x + 1; cx < x + w - 1; cx += 1) putBoxCell(grid, kind, cx, y, glyphs.boxH);
+  putBoxCell(grid, kind, x + w - 1, y, glyphs.boxTR);
+  for (let cy = y + 1; cy < y + h - 1; cy += 1) {
+    putBoxCell(grid, kind, x, cy, glyphs.boxV);
+    for (let cx = x + 1; cx < x + w - 1; cx += 1) {
+      putBoxCellAs(grid, kind, cx, cy, " ", "empty");
+    }
+    putBoxCell(grid, kind, x + w - 1, cy, glyphs.boxV);
+  }
+  putBoxCell(grid, kind, x, y + h - 1, glyphs.boxBL);
+  for (let cx = x + 1; cx < x + w - 1; cx += 1) putBoxCell(grid, kind, cx, y + h - 1, glyphs.boxH);
+  putBoxCell(grid, kind, x + w - 1, y + h - 1, glyphs.boxBR);
+  const midY = y + Math.floor(h / 2);
+  writeLabel(grid, kind, x + 1, midY, w - 2, label);
+}
+function putBoxCell(grid, kind, x, y, glyph) {
+  const k = glyph === " " ? "empty" : glyph === "\u2500" || glyph === "-" ? "boxH" : glyph === "\u2502" || glyph === "|" ? "boxV" : "boxCorner";
+  putBoxCellAs(grid, kind, x, y, glyph, k);
+}
+function putBoxCellAs(grid, kind, x, y, glyph, k) {
+  if (y < 0 || y >= grid.length) return;
+  const row = grid[y];
+  if (x < 0 || x >= row.length) return;
+  row[x] = glyph;
+  kind[y][x] = k;
+}
+function writeLabel(grid, kind, x, y, maxWidthCells, label) {
+  if (y < 0 || y >= grid.length) return;
+  let cursor = x;
+  let cellsLeft = maxWidthCells;
+  for (const ch of label) {
+    const cw = countCells(ch);
+    if (cw === 0) continue;
+    if (cellsLeft < cw) break;
+    if (cursor >= 0 && cursor < grid[y].length) {
+      grid[y][cursor] = ch;
+      kind[y][cursor] = "label";
+      if (cw === 2 && cursor + 1 < grid[y].length) {
+        grid[y][cursor + 1] = "";
+        kind[y][cursor + 1] = "label";
+      }
+    }
+    cursor += cw;
+    cellsLeft -= cw;
+  }
+  while (cellsLeft > 0) {
+    if (cursor >= 0 && cursor < grid[y].length) {
+      grid[y][cursor] = " ";
+      kind[y][cursor] = "empty";
+    }
+    cursor += 1;
+    cellsLeft -= 1;
+  }
+}
+function drawEdge(grid, kind, glyphs, edge) {
+  const pts = edge.points;
+  if (pts.length < 2) return;
+  for (let i = 0; i + 1 < pts.length; i += 1) {
+    drawSegment(grid, kind, glyphs, pts[i], pts[i + 1]);
+  }
+  for (let i = 1; i + 1 < pts.length; i += 1) {
+    const a = pts[i - 1];
+    const b = pts[i];
+    const c = pts[i + 1];
+    const corner = cornerGlyph(a, b, c, glyphs);
+    if (corner) putEdgeCell(grid, kind, b.x, b.y, corner, "edgeCorner");
+  }
+  const tip = pts[pts.length - 1];
+  const prev = pts[pts.length - 2];
+  const arrow = arrowGlyph(prev, tip, glyphs);
+  if (arrow) putEdgeCell(grid, kind, tip.x, tip.y, arrow, "arrow");
+}
+function drawSegment(grid, kind, glyphs, a, b) {
+  if (a.x === b.x && a.y === b.y) return;
+  if (a.y === b.y) {
+    const y = a.y;
+    const x0 = Math.min(a.x, b.x);
+    const x1 = Math.max(a.x, b.x);
+    for (let x = x0; x <= x1; x += 1) {
+      putEdgeLine(grid, kind, x, y, glyphs, "h");
+    }
+  } else if (a.x === b.x) {
+    const x = a.x;
+    const y0 = Math.min(a.y, b.y);
+    const y1 = Math.max(a.y, b.y);
+    for (let y = y0; y <= y1; y += 1) {
+      putEdgeLine(grid, kind, x, y, glyphs, "v");
+    }
+  }
+}
+function putEdgeLine(grid, kind, x, y, glyphs, orientation) {
+  if (y < 0 || y >= grid.length) return;
+  const row = grid[y];
+  if (x < 0 || x >= row.length) return;
+  const existing = kind[y][x];
+  if (existing === "boxH" || existing === "boxV" || existing === "boxCorner" || existing === "label") {
+    return;
+  }
+  if (existing === "empty") {
+    row[x] = orientation === "h" ? glyphs.horizontal : glyphs.vertical;
+    kind[y][x] = orientation === "h" ? "edgeH" : "edgeV";
+    return;
+  }
+  if (existing === "edgeH" && orientation === "v") {
+    row[x] = glyphs.cross;
+    kind[y][x] = "edgeCorner";
+    return;
+  }
+  if (existing === "edgeV" && orientation === "h") {
+    row[x] = glyphs.cross;
+    kind[y][x] = "edgeCorner";
+    return;
+  }
+}
+function putEdgeCell(grid, kind, x, y, glyph, k) {
+  if (y < 0 || y >= grid.length) return;
+  const row = grid[y];
+  if (x < 0 || x >= row.length) return;
+  const existing = kind[y][x];
+  if (existing === "boxH" || existing === "boxV" || existing === "boxCorner" || existing === "label")
+    return;
+  row[x] = glyph;
+  kind[y][x] = k;
+}
+function cornerGlyph(a, b, c, glyphs) {
+  const inHoriz = a.y === b.y;
+  const outHoriz = b.y === c.y;
+  if (inHoriz === outHoriz) return void 0;
+  if (inHoriz) {
+    const fromLeft = a.x < b.x;
+    const goingDown = c.y > b.y;
+    if (fromLeft && goingDown) return glyphs.cornerTR;
+    if (fromLeft && !goingDown) return glyphs.cornerBR;
+    if (!fromLeft && goingDown) return glyphs.cornerTL;
+    return glyphs.cornerBL;
+  }
+  const fromAbove = a.y < b.y;
+  const goingRight = c.x > b.x;
+  if (fromAbove && goingRight) return glyphs.cornerBL;
+  if (fromAbove && !goingRight) return glyphs.cornerBR;
+  if (!fromAbove && goingRight) return glyphs.cornerTL;
+  return glyphs.cornerTR;
+}
+function arrowGlyph(prev, tip, glyphs) {
+  if (tip.x > prev.x) return glyphs.arrowRight;
+  if (tip.x < prev.x) return glyphs.arrowLeft;
+  if (tip.y > prev.y) return glyphs.arrowDown;
+  if (tip.y < prev.y) return glyphs.arrowUp;
+  return void 0;
+}
+function stripTrailing(line) {
+  let end = line.length;
+  while (end > 0 && line.charCodeAt(end - 1) === 32) end -= 1;
+  return line.slice(0, end);
+}
+
+// src/base/render/_layout-sugiyama.ts
+function sugiyamaLayout(input) {
+  const state = buildInitial(input);
+  assignLayers(state);
+  insertVirtualNodes(state);
+  minimizeCrossings(state);
+  assignCoordinates(state, input);
+  const edges = routeEdges(state, input);
+  const { width, height } = boundingBox(state);
+  const boxes = [];
+  for (const layer of state.layers) {
+    for (const n of layer) {
+      if (n.isVirtual) continue;
+      boxes.push({
+        id: n.id,
+        layer: n.layer,
+        order: n.order,
+        x: n.x,
+        y: n.y,
+        w: n.w,
+        h: n.h
+      });
+    }
+  }
+  return { boxes, edges, width, height };
+}
+function buildInitial(input) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const id of input.nodes) {
+    nodes.set(id, {
+      id,
+      isVirtual: false,
+      layer: -1,
+      order: 0,
+      x: 0,
+      y: 0,
+      w: input.widthCells(id),
+      h: input.heightCells(id),
+      in: [],
+      out: []
+    });
+  }
+  const hops = [];
+  let chainId = 0;
+  for (const e of input.edges) {
+    if (e.from === e.to) continue;
+    const f = nodes.get(e.from);
+    const t = nodes.get(e.to);
+    if (!f || !t) continue;
+    const hop = {
+      chainId: chainId++,
+      chainFrom: e.from,
+      chainTo: e.to,
+      fromId: e.from,
+      toId: e.to,
+      hopIndex: 0,
+      chainLen: 1
+    };
+    f.out.push(hop);
+    t.in.push(hop);
+    hops.push(hop);
+  }
+  return { nodes, layers: [], hops };
+}
+function assignLayers(state) {
+  const indeg = /* @__PURE__ */ new Map();
+  for (const n of state.nodes.values()) indeg.set(n.id, n.in.length);
+  const queue = [];
+  for (const n of state.nodes.values()) {
+    if ((indeg.get(n.id) ?? 0) === 0) {
+      n.layer = 0;
+      queue.push(n);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let head = 0;
+  while (head < queue.length) {
+    const n = queue[head++];
+    if (visited.has(n.id)) continue;
+    visited.add(n.id);
+    for (const hop of n.out) {
+      const t = state.nodes.get(hop.toId);
+      t.layer = Math.max(t.layer, n.layer + 1);
+      const d = (indeg.get(t.id) ?? 0) - 1;
+      indeg.set(t.id, d);
+      if (d <= 0) queue.push(t);
+    }
+  }
+  for (const n of state.nodes.values()) if (n.layer < 0) n.layer = 0;
+}
+function insertVirtualNodes(state) {
+  const maxLayer = Math.max(0, ...Array.from(state.nodes.values(), (n) => n.layer));
+  const layers = Array.from({ length: maxLayer + 1 }, () => []);
+  for (const n of state.nodes.values()) layers[n.layer].push(n);
+  const newHops = [];
+  let virtCounter = 0;
+  for (const hop of state.hops) {
+    const f = state.nodes.get(hop.fromId);
+    const t = state.nodes.get(hop.toId);
+    const span = t.layer - f.layer;
+    if (span <= 0) {
+      f.out = f.out.filter((h) => h !== hop);
+      t.in = t.in.filter((h) => h !== hop);
+      continue;
+    }
+    if (span === 1) {
+      hop.hopIndex = 0;
+      hop.chainLen = 1;
+      newHops.push(hop);
+      continue;
+    }
+    f.out = f.out.filter((h) => h !== hop);
+    t.in = t.in.filter((h) => h !== hop);
+    let prev = f;
+    for (let i = 1; i < span; i += 1) {
+      const vid = `__virt_${virtCounter++}__`;
+      const v = {
+        id: vid,
+        isVirtual: true,
+        layer: f.layer + i,
+        order: 0,
+        x: 0,
+        y: 0,
+        w: 0,
+        h: 1,
+        in: [],
+        out: []
+      };
+      state.nodes.set(vid, v);
+      layers[v.layer].push(v);
+      const h = {
+        chainId: hop.chainId,
+        chainFrom: hop.chainFrom,
+        chainTo: hop.chainTo,
+        fromId: prev.id,
+        toId: vid,
+        hopIndex: i - 1,
+        chainLen: span
+      };
+      prev.out.push(h);
+      v.in.push(h);
+      newHops.push(h);
+      prev = v;
+    }
+    const finalHop = {
+      chainId: hop.chainId,
+      chainFrom: hop.chainFrom,
+      chainTo: hop.chainTo,
+      fromId: prev.id,
+      toId: t.id,
+      hopIndex: span - 1,
+      chainLen: span
+    };
+    prev.out.push(finalHop);
+    t.in.push(finalHop);
+    newHops.push(finalHop);
+  }
+  for (const layer of layers) {
+    for (let i = 0; i < layer.length; i += 1) layer[i].order = i;
+  }
+  state.layers = layers;
+  state.hops = newHops;
+}
+function minimizeCrossings(state) {
+  const SWEEPS = 4;
+  for (let sweep = 0; sweep < SWEEPS; sweep += 1) {
+    for (let li = 1; li < state.layers.length; li += 1) {
+      sortByBarycenter(state, state.layers[li], "in");
+      reindex(state.layers[li]);
+    }
+    for (let li = state.layers.length - 2; li >= 0; li -= 1) {
+      sortByBarycenter(state, state.layers[li], "out");
+      reindex(state.layers[li]);
+    }
+  }
+  for (let iter = 0; iter < 2; iter += 1) {
+    let improved = false;
+    for (let li = 1; li < state.layers.length; li += 1) {
+      const layer = state.layers[li];
+      for (let i = 0; i + 1 < layer.length; i += 1) {
+        const before = pairCrossings(state, layer[i], layer[i + 1], "in");
+        [layer[i], layer[i + 1]] = [layer[i + 1], layer[i]];
+        reindex(layer);
+        const after = pairCrossings(state, layer[i], layer[i + 1], "in");
+        if (after < before) {
+          improved = true;
+        } else {
+          [layer[i], layer[i + 1]] = [layer[i + 1], layer[i]];
+          reindex(layer);
+        }
+      }
+    }
+    if (!improved) break;
+  }
+}
+function sortByBarycenter(state, layer, direction) {
+  const bary = /* @__PURE__ */ new Map();
+  for (const n of layer) {
+    const neighbors = direction === "in" ? n.in : n.out;
+    if (neighbors.length === 0) {
+      bary.set(n.id, n.order);
+      continue;
+    }
+    let sum = 0;
+    let count = 0;
+    for (const h of neighbors) {
+      const other = state.nodes.get(direction === "in" ? h.fromId : h.toId);
+      if (!other) continue;
+      sum += other.order;
+      count += 1;
+    }
+    bary.set(n.id, count === 0 ? n.order : sum / count);
+  }
+  layer.sort((a, b) => {
+    const ba = bary.get(a.id);
+    const bb = bary.get(b.id);
+    if (ba !== bb) return ba - bb;
+    return a.order - b.order;
+  });
+}
+function reindex(layer) {
+  for (let i = 0; i < layer.length; i += 1) layer[i].order = i;
+}
+function pairCrossings(state, a, b, direction) {
+  const aEdges = direction === "in" ? a.in : a.out;
+  const bEdges = direction === "in" ? b.in : b.out;
+  let crossings = 0;
+  for (const ea of aEdges) {
+    for (const eb of bEdges) {
+      const oa = state.nodes.get(direction === "in" ? ea.fromId : ea.toId)?.order ?? 0;
+      const ob = state.nodes.get(direction === "in" ? eb.fromId : eb.toId)?.order ?? 0;
+      if (a.order < b.order && oa > ob || a.order > b.order && oa < ob) {
+        crossings += 1;
+      }
+    }
+  }
+  return crossings;
+}
+function assignCoordinates(state, input) {
+  if (input.direction === "LR") assignCoordinatesLR(state, input);
+  else assignCoordinatesTD(state, input);
+}
+function assignCoordinatesLR(state, input) {
+  const layerX = [];
+  let cursorX = 0;
+  for (let li = 0; li < state.layers.length; li += 1) {
+    layerX.push(cursorX);
+    let maxW = 0;
+    for (const n of state.layers[li]) maxW = Math.max(maxW, n.w);
+    cursorX += maxW + input.layerGap;
+  }
+  for (let li = 0; li < state.layers.length; li += 1) {
+    for (const n of state.layers[li]) n.x = layerX[li];
+  }
+  for (const layer of state.layers) {
+    let y = 0;
+    for (const n of layer) {
+      n.y = y;
+      y += n.h + input.nodeGap;
+    }
+  }
+  runMedianPasses(state, input, "y");
+}
+function assignCoordinatesTD(state, input) {
+  const layerY = [];
+  let cursorY = 0;
+  for (let li = 0; li < state.layers.length; li += 1) {
+    layerY.push(cursorY);
+    let maxH = 0;
+    for (const n of state.layers[li]) maxH = Math.max(maxH, n.h);
+    cursorY += maxH + input.layerGap;
+  }
+  for (let li = 0; li < state.layers.length; li += 1) {
+    for (const n of state.layers[li]) n.y = layerY[li];
+  }
+  for (const layer of state.layers) {
+    let x = 0;
+    for (const n of layer) {
+      n.x = x;
+      x += n.w + input.nodeGap;
+    }
+  }
+  runMedianPasses(state, input, "x");
+}
+function runMedianPasses(state, input, axis) {
+  const sizeOf = (n) => axis === "y" ? n.h : n.w;
+  const gap = input.nodeGap;
+  for (let pass = 0; pass < 2; pass += 1) {
+    const walk = pass === 0 ? state.layers.slice(1) : state.layers.slice(0, -1).reverse();
+    for (const layer of walk) {
+      const preferred = /* @__PURE__ */ new Map();
+      for (const n of layer) {
+        const neighbors = pass === 0 ? n.in : n.out;
+        if (neighbors.length === 0) continue;
+        const centers = [];
+        for (const h of neighbors) {
+          const other = state.nodes.get(pass === 0 ? h.fromId : h.toId);
+          if (!other) continue;
+          const base = axis === "y" ? other.y : other.x;
+          centers.push(base + Math.floor(sizeOf(other) / 2));
+        }
+        if (centers.length === 0) continue;
+        centers.sort((a, b) => a - b);
+        const mid = centers[Math.floor(centers.length / 2)];
+        preferred.set(n.id, mid - Math.floor(sizeOf(n) / 2));
+      }
+      let floor = 0;
+      for (const n of layer) {
+        const p = preferred.get(n.id);
+        const current = axis === "y" ? n.y : n.x;
+        const target = p ?? current;
+        const clamped = Math.max(target, floor);
+        if (axis === "y") n.y = clamped;
+        else n.x = clamped;
+        floor = clamped + sizeOf(n) + gap;
+      }
+    }
+  }
+}
+function routeEdges(state, input) {
+  const byChain = /* @__PURE__ */ new Map();
+  for (const h of state.hops) {
+    const arr = byChain.get(h.chainId);
+    if (arr) arr.push(h);
+    else byChain.set(h.chainId, [h]);
+  }
+  for (const arr of byChain.values()) arr.sort((a, b) => a.hopIndex - b.hopIndex);
+  const isLR = input.direction === "LR";
+  const primary = (n) => isLR ? n.x : n.y;
+  const primarySize = (n) => isLR ? n.w : n.h;
+  const crossCenter = (n) => isLR ? n.y + Math.floor(n.h / 2) : n.x + Math.floor(n.w / 2);
+  const hopTrackCross = /* @__PURE__ */ new Map();
+  for (let g = 0; g + 1 < state.layers.length; g += 1) {
+    const srcLayer = state.layers[g];
+    const dstLayer = state.layers[g + 1];
+    let gutterStart = 0;
+    for (const n of srcLayer) gutterStart = Math.max(gutterStart, primary(n) + primarySize(n));
+    let gutterEnd = Number.POSITIVE_INFINITY;
+    for (const n of dstLayer) gutterEnd = Math.min(gutterEnd, primary(n));
+    const gEnd = Number.isFinite(gutterEnd) ? gutterEnd - 1 : gutterStart;
+    const gutterWidth = Math.max(1, gEnd - gutterStart + 1);
+    const gutterHops = [];
+    for (const n of srcLayer) for (const h of n.out) gutterHops.push(h);
+    gutterHops.sort((a, b) => {
+      const sa = crossCenter(state.nodes.get(a.fromId));
+      const sb = crossCenter(state.nodes.get(b.fromId));
+      if (sa !== sb) return sa - sb;
+      const da = crossCenter(state.nodes.get(a.toId));
+      const db = crossCenter(state.nodes.get(b.toId));
+      return da - db;
+    });
+    const tracks = [];
+    const hopToTrackIdx = /* @__PURE__ */ new Map();
+    for (const h of gutterHops) {
+      const sc = crossCenter(state.nodes.get(h.fromId));
+      const dc = crossCenter(state.nodes.get(h.toId));
+      const lo = Math.min(sc, dc);
+      const hi = Math.max(sc, dc);
+      let idx = -1;
+      for (let t = 0; t < tracks.length; t += 1) {
+        const intervals = tracks[t];
+        let fits = true;
+        for (const iv of intervals) {
+          if (iv.lo <= hi && lo <= iv.hi) {
+            fits = false;
+            break;
+          }
+        }
+        if (fits) {
+          intervals.push({ lo, hi });
+          idx = t;
+          break;
+        }
+      }
+      if (idx < 0) {
+        tracks.push([{ lo, hi }]);
+        idx = tracks.length - 1;
+      }
+      hopToTrackIdx.set(h, idx);
+    }
+    const count = tracks.length;
+    const hasMargin = gutterWidth >= Math.max(3, count + 2);
+    const usableStart = hasMargin ? gutterStart + 1 : gutterStart;
+    const usableEnd = hasMargin ? gEnd - 1 : gEnd;
+    const usableWidth = Math.max(1, usableEnd - usableStart + 1);
+    for (const h of gutterHops) {
+      const idx = hopToTrackIdx.get(h);
+      let trackPrimary;
+      if (count <= 1) {
+        trackPrimary = usableStart + Math.floor(usableWidth / 2);
+      } else {
+        const step = (usableWidth - 1) / (count - 1);
+        trackPrimary = usableStart + Math.floor(idx * step);
+      }
+      hopTrackCross.set(h, Math.max(gutterStart, Math.min(gEnd, trackPrimary)));
+    }
+  }
+  const out = [];
+  for (const [, hops] of byChain) {
+    const points = [];
+    for (let i = 0; i < hops.length; i += 1) {
+      const h = hops[i];
+      const src = state.nodes.get(h.fromId);
+      const dst = state.nodes.get(h.toId);
+      const track = hopTrackCross.get(h);
+      const srcPrimary = src.isVirtual ? primary(src) : primary(src) + primarySize(src);
+      const dstPrimary = dst.isVirtual ? primary(dst) : primary(dst) - 1;
+      const sc = crossCenter(src);
+      const dc = crossCenter(dst);
+      if (i === 0) pushPoint(points, isLR, srcPrimary, sc);
+      if (sc !== dc) {
+        pushPoint(points, isLR, track, sc);
+        pushPoint(points, isLR, track, dc);
+      }
+      pushPoint(points, isLR, dstPrimary, dc);
+    }
+    const chain = hops[0];
+    out.push({
+      from: chain.chainFrom,
+      to: chain.chainTo,
+      points: dedupWaypoints(points)
+    });
+  }
+  return out;
+}
+function pushPoint(acc, isLR, primary, cross) {
+  acc.push(isLR ? { x: primary, y: cross } : { x: cross, y: primary });
+}
+function dedupWaypoints(points) {
+  const out = [];
+  for (const p of points) {
+    const last = out[out.length - 1];
+    if (!last || last.x !== p.x || last.y !== p.y) out.push(p);
+  }
+  return out;
+}
+function boundingBox(state) {
+  let w = 0;
+  let h = 0;
+  for (const layer of state.layers) {
+    for (const n of layer) {
+      w = Math.max(w, n.x + n.w);
+      h = Math.max(h, n.y + n.h);
+    }
+  }
+  return { width: w, height: h };
+}
+
+// src/base/render/graph-spec-to-ascii.ts
+var DEFAULT_LABEL_WIDTH = 24;
+var LAYER_GAP = 4;
+var NODE_GAP = 1;
+var BOX_HEIGHT = 3;
+function graphSpecToAscii(g, opts) {
+  const direction = normalizeAsciiDirection(opts?.direction);
+  const maxLabel = Math.max(3, opts?.maxLabelWidth ?? DEFAULT_LABEL_WIDTH);
+  const charset = opts?.asciiCharset ?? "unicode";
+  const paths = Object.keys(g.nodes).sort();
+  const nodeSet = new Set(paths);
+  const edges = g.edges.filter((e) => nodeSet.has(e.from) && nodeSet.has(e.to));
+  const labels = /* @__PURE__ */ new Map();
+  const widths = /* @__PURE__ */ new Map();
+  for (const p of paths) {
+    const label = truncateToCells(p, maxLabel);
+    labels.set(p, label);
+    widths.set(p, countCells(label) + 4);
+  }
+  const layout = sugiyamaLayout({
+    nodes: paths,
+    edges,
+    widthCells: (id) => widths.get(id) ?? 3,
+    heightCells: () => BOX_HEIGHT,
+    layerGap: LAYER_GAP,
+    nodeGap: NODE_GAP,
+    direction
+  });
+  const text = renderGrid(layout, {
+    charset,
+    labelOf: (id) => labels.get(id) ?? id
+  });
+  opts?.logger?.(text);
+  return text;
+}
+function normalizeAsciiDirection(direction) {
+  if (direction === void 0 || direction === "LR") return "LR";
+  if (direction === "TD") return "TD";
+  throw new Error(`ascii describe supports direction "LR" or "TD" only; got ${String(direction)}`);
+}
+
+// src/base/render/_internal.ts
+function sortJsonValue(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  const obj = value;
+  const keys = Object.keys(obj).sort();
+  const out = {};
+  for (const k of keys) {
+    out[k] = sortJsonValue(obj[k]);
+  }
+  return out;
+}
+function escapeMermaidLabel(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function escapeD2Label(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function d2DirectionFromGraphDirection(direction) {
+  if (direction === "TD") return "down";
+  if (direction === "BT") return "up";
+  if (direction === "RL") return "left";
+  return "right";
+}
+function collectDiagramArrows(described) {
+  const seen = /* @__PURE__ */ new Set();
+  const arrows = [];
+  function add(from, to) {
+    const key = `${from}\0${to}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    arrows.push([from, to]);
+  }
+  for (const [path, info] of Object.entries(described.nodes)) {
+    const deps = info.deps;
+    if (deps) {
+      for (const dep of deps) add(dep, path);
+    }
+  }
+  for (const edge of described.edges) add(edge.from, edge.to);
+  return arrows;
+}
+function normalizeDiagramDirection(direction) {
+  if (direction === void 0) return "LR";
+  if (direction === "TD" || direction === "LR" || direction === "BT" || direction === "RL") {
+    return direction;
+  }
+  throw new Error(
+    `invalid diagram direction ${String(direction)}; expected one of: TD, LR, BT, RL`
+  );
+}
+function describeData(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean" || value == null)
+    return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/base/render/graph-spec-to-d2.ts
+function graphSpecToD2(g, opts) {
+  const direction = normalizeDiagramDirection(opts?.direction);
+  const paths = Object.keys(g.nodes).sort();
+  const ids = /* @__PURE__ */ new Map();
+  for (let i = 0; i < paths.length; i += 1) ids.set(paths[i], `n${i}`);
+  const lines = [`direction: ${d2DirectionFromGraphDirection(direction)}`];
+  for (const path of paths) {
+    const id = ids.get(path);
+    lines.push(`${id}: "${escapeD2Label(path)}"`);
+  }
+  for (const [from, to] of collectDiagramArrows(g)) {
+    const fromId = ids.get(from);
+    const toId = ids.get(to);
+    if (!fromId || !toId) continue;
+    lines.push(`${fromId} -> ${toId}`);
+  }
+  return lines.join("\n");
+}
+
+// src/base/render/graph-spec-to-json.ts
+function graphSpecToJson(g, opts) {
+  const includeEdges = opts?.includeEdges ?? true;
+  const includeSubgraphs = opts?.includeSubgraphs ?? true;
+  const { expand: _expand, ...rest } = g;
+  const payload = {
+    ...rest,
+    edges: includeEdges ? g.edges : [],
+    subgraphs: includeSubgraphs ? g.subgraphs : []
+  };
+  const text = JSON.stringify(sortJsonValue(payload), null, opts?.indent ?? 2);
+  opts?.logger?.(text);
+  return text;
+}
+
+// src/base/render/graph-spec-to-mermaid.ts
+function graphSpecToMermaid(g, opts) {
+  const direction = normalizeDiagramDirection(opts?.direction);
+  const paths = Object.keys(g.nodes).sort();
+  const ids = /* @__PURE__ */ new Map();
+  for (let i = 0; i < paths.length; i += 1) ids.set(paths[i], `n${i}`);
+  const lines = [`flowchart ${direction}`];
+  for (const path of paths) {
+    const id = ids.get(path);
+    lines.push(`  ${id}["${escapeMermaidLabel(path)}"]`);
+  }
+  for (const [from, to] of collectDiagramArrows(g)) {
+    const fromId = ids.get(from);
+    const toId = ids.get(to);
+    if (!fromId || !toId) continue;
+    lines.push(`  ${fromId} --> ${toId}`);
+  }
+  return lines.join("\n");
+}
+
+// src/base/render/graph-spec-to-mermaid-url.ts
+function mermaidLiveUrl(mermaidSrc, opts) {
+  const theme = opts?.theme ?? "default";
+  const autoSync = opts?.autoSync ?? true;
+  const payload = { code: mermaidSrc, mermaid: { theme }, autoSync };
+  const json = JSON.stringify(payload);
+  const bytes = new TextEncoder().encode(json);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  const b64 = globalThis.btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `https://mermaid.live/edit#base64:${b64}`;
+}
+function graphSpecToMermaidUrl(g, opts) {
+  const mermaidSrc = graphSpecToMermaid(g, opts);
+  return mermaidLiveUrl(mermaidSrc, opts);
+}
+
+// src/base/render/graph-spec-to-pretty.ts
+function graphSpecToPretty(g, opts) {
+  const includeEdges = opts?.includeEdges ?? true;
+  const includeSubgraphs = opts?.includeSubgraphs ?? true;
+  const lines = [];
+  lines.push(`Graph ${g.name}`);
+  lines.push("Nodes:");
+  for (const path of Object.keys(g.nodes).sort()) {
+    const n = g.nodes[path];
+    lines.push(`- ${path} (${n.type}/${n.status}): ${describeData(n.value)}`);
+  }
+  if (includeEdges) {
+    lines.push("Edges:");
+    for (const edge of g.edges) {
+      lines.push(`- ${edge.from} -> ${edge.to}`);
+    }
+  }
+  if (includeSubgraphs) {
+    lines.push("Subgraphs:");
+    for (const sg of g.subgraphs) {
+      lines.push(`- ${sg}`);
+    }
+  }
+  const text = lines.join("\n");
+  opts?.logger?.(text);
+  return text;
+}
+
+// src/base/render/layout-frame-to-svg.ts
+var SPECIAL_CHARS = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+function escapeXml(s) {
+  return s.replace(/[&<>"']/g, (c) => SPECIAL_CHARS[c] ?? c);
+}
+function layoutFrameToSvg(frame, opts) {
+  const cellW = opts?.cellWidth ?? 12;
+  const cellH = opts?.cellHeight ?? 18;
+  const pad = opts?.padding ?? 16;
+  const boxStroke = escapeXml(opts?.boxStroke ?? "#444");
+  const boxFill = escapeXml(opts?.boxFill ?? "#fff");
+  const edgeStroke = escapeXml(opts?.edgeStroke ?? "#888");
+  const textColor = escapeXml(opts?.textColor ?? "#111");
+  const fontFamily = opts?.fontFamily ?? "ui-monospace, monospace";
+  const fontSize = opts?.fontSize ?? 12;
+  let maxX = 0;
+  let maxY = 0;
+  for (const b of frame.boxes) {
+    maxX = Math.max(maxX, b.x + b.w);
+    maxY = Math.max(maxY, b.y + b.h);
+  }
+  for (const e of frame.edges) {
+    for (const [x, y] of e.points) {
+      maxX = Math.max(maxX, x);
+      maxY = Math.max(maxY, y);
+    }
+  }
+  const width = Math.max(1, maxX) * cellW + pad * 2;
+  const height = Math.max(1, maxY) * cellH + pad * 2;
+  const lines = [];
+  lines.push(
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}">`
+  );
+  for (const e of frame.edges) {
+    if (e.points.length < 2) continue;
+    const pts = e.points.map(([x, y]) => `${x * cellW + pad},${y * cellH + pad}`).join(" ");
+    lines.push(
+      `  <polyline points="${pts}" fill="none" stroke="${edgeStroke}" stroke-width="1" data-from="${escapeXml(e.from)}" data-to="${escapeXml(e.to)}" data-dep-index="${e.depIndex}" />`
+    );
+  }
+  for (const b of frame.boxes) {
+    const px = b.x * cellW + pad;
+    const py = b.y * cellH + pad;
+    const pw = Math.max(1, b.w) * cellW;
+    const ph = Math.max(1, b.h) * cellH;
+    const local = b.id.includes("::") ? b.id.split("::").pop() ?? b.id : b.id;
+    lines.push(
+      `  <g data-id="${escapeXml(b.id)}">`,
+      `    <rect x="${px}" y="${py}" width="${pw}" height="${ph}" fill="${boxFill}" stroke="${boxStroke}" stroke-width="1" />`,
+      `    <text x="${px + pw / 2}" y="${py + ph / 2}" fill="${textColor}" font-family="${escapeXml(fontFamily)}" font-size="${fontSize}" text-anchor="middle" dominant-baseline="central">${escapeXml(local)}</text>`,
+      `  </g>`
+    );
+  }
+  lines.push("</svg>");
+  return lines.join("\n");
+}
+//# sourceMappingURL=index.cjs.map