@diagrammo/dgmo 0.27.0 → 0.28.0

package/dist/advanced.js

@@ -27682,12 +27682,1344 @@ var init_renderer6 = __esm({
   }
 });
 
+// src/boxes-and-lines/layout-layered.ts
+function rng(s) {
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function layeredCandidates(parsed, sizes, opts) {
+  if (parsed.groups.length > 0) return [];
+  const nCount = parsed.nodes.length;
+  if (nCount < 3 || nCount > 40) return [];
+  const isTB = parsed.direction === "TB";
+  const nodesep = opts?.nodesep ?? NODESEP;
+  const ranksep = opts?.ranksep ?? RANKSEP;
+  const backEdgeSide = opts?.backEdgeSide ?? "nearest";
+  const restarts = opts?.restarts ?? (nCount <= 14 ? 28 : nCount <= 25 ? 14 : 6);
+  const keepK = opts?.keepK ?? 3;
+  const labels = parsed.nodes.map((n) => n.label);
+  const labelSet = new Set(labels);
+  const edges = parsed.edges.map((e, i) => ({ e, i })).filter(
+    ({ e }) => labelSet.has(e.source) && labelSet.has(e.target) && e.source !== e.target
+  );
+  if (edges.length === 0) return [];
+  const adj = /* @__PURE__ */ new Map();
+  for (const l of labels) adj.set(l, []);
+  for (const { e, i } of edges)
+    adj.get(e.source).push({ to: e.target, idx: i });
+  const reversed = /* @__PURE__ */ new Set();
+  const state = /* @__PURE__ */ new Map();
+  for (const l of labels) state.set(l, 0);
+  const dfs = (u) => {
+    state.set(u, 1);
+    for (const { to, idx } of adj.get(u)) {
+      const st = state.get(to);
+      if (st === 1)
+        reversed.add(idx);
+      else if (st === 0) dfs(to);
+    }
+    state.set(u, 2);
+  };
+  for (const l of labels) if (state.get(l) === 0) dfs(l);
+  const dag = edges.map(
+    ({ e, i }) => reversed.has(i) ? { from: e.target, to: e.source, idx: i, rev: true } : { from: e.source, to: e.target, idx: i, rev: false }
+  );
+  const outDag = /* @__PURE__ */ new Map();
+  const inDeg = /* @__PURE__ */ new Map();
+  for (const l of labels) {
+    outDag.set(l, []);
+    inDeg.set(l, 0);
+  }
+  for (const d of dag) {
+    outDag.get(d.from).push(d.to);
+    inDeg.set(d.to, (inDeg.get(d.to) ?? 0) + 1);
+  }
+  const rank = /* @__PURE__ */ new Map();
+  for (const l of labels) rank.set(l, 0);
+  const queue = labels.filter((l) => (inDeg.get(l) ?? 0) === 0);
+  const indeg2 = new Map(inDeg);
+  const topo = [];
+  while (queue.length) {
+    const u = queue.shift();
+    topo.push(u);
+    for (const v of outDag.get(u)) {
+      rank.set(v, Math.max(rank.get(v), rank.get(u) + 1));
+      indeg2.set(v, indeg2.get(v) - 1);
+      if (indeg2.get(v) === 0) queue.push(v);
+    }
+  }
+  if (topo.length !== labels.length) return [];
+  const maxRank = Math.max(...labels.map((l) => rank.get(l)));
+  const node = /* @__PURE__ */ new Map();
+  for (const n of parsed.nodes) {
+    const s = sizes.get(n.label) ?? { width: NODE_WIDTH, height: NODE_HEIGHT };
+    node.set(n.label, {
+      id: n.label,
+      dummy: false,
+      rank: rank.get(n.label),
+      cross: 0,
+      thick: isTB ? s.width : s.height,
+      depth: isTB ? s.height : s.width,
+      realW: s.width,
+      realH: s.height
+    });
+  }
+  const segs = [];
+  const chains = [];
+  const backEdges = [];
+  for (const d of dag) {
+    if (d.rev) {
+      backEdges.push({ edgeIdx: d.idx, src: d.to, tgt: d.from });
+      continue;
+    }
+    const r0 = rank.get(d.from);
+    const r1 = rank.get(d.to);
+    const dagChain = [d.from];
+    let prev = d.from;
+    for (let r = r0 + 1; r < r1; r++) {
+      const id = `__d${d.idx}_${r}`;
+      node.set(id, {
+        id,
+        dummy: true,
+        rank: r,
+        cross: 0,
+        thick: DUMMY_THICK,
+        depth: 0,
+        realW: 0,
+        realH: 0
+      });
+      segs.push({ a: prev, b: id });
+      dagChain.push(id);
+      prev = id;
+    }
+    segs.push({ a: prev, b: d.to });
+    dagChain.push(d.to);
+    chains.push({
+      edgeIdx: d.idx,
+      chain: d.rev ? dagChain.slice().reverse() : dagChain
+    });
+  }
+  const ranks = Array.from({ length: maxRank + 1 }, () => []);
+  for (const n of node.values()) ranks[n.rank].push(n.id);
+  const up = /* @__PURE__ */ new Map();
+  const down = /* @__PURE__ */ new Map();
+  for (const id of node.keys()) {
+    up.set(id, []);
+    down.set(id, []);
+  }
+  for (const s of segs) {
+    down.get(s.a).push(s.b);
+    up.get(s.b).push(s.a);
+  }
+  const orderOf = /* @__PURE__ */ new Map();
+  const applyOrder = (ord) => {
+    for (const id of node.keys()) orderOf.set(id, ord.get(id));
+  };
+  const gapCrossings = (r) => {
+    const lower = ranks[r + 1];
+    if (!lower) return 0;
+    const es = [];
+    for (const a of ranks[r]) {
+      const pa = orderOf.get(a);
+      for (const b of down.get(a)) es.push({ p: pa, q: orderOf.get(b) });
+    }
+    let c = 0;
+    for (let i = 0; i < es.length; i++)
+      for (let j = i + 1; j < es.length; j++) {
+        const A = es[i], B = es[j];
+        if ((A.p - B.p) * (A.q - B.q) < 0) c++;
+      }
+    return c;
+  };
+  const totalCrossings = () => {
+    let c = 0;
+    for (let r = 0; r < maxRank; r++) c += gapCrossings(r);
+    return c;
+  };
+  const median = (vals) => {
+    if (vals.length === 0) return -1;
+    vals.sort((x, y) => x - y);
+    const m = Math.floor(vals.length / 2);
+    if (vals.length % 2 === 1) return vals[m];
+    if (vals.length === 2) return (vals[0] + vals[1]) / 2;
+    const left = vals[m - 1] - vals[0];
+    const right = vals[vals.length - 1] - vals[m];
+    return left + right === 0 ? (vals[m - 1] + vals[m]) / 2 : (vals[m - 1] * right + vals[m] * left) / (left + right);
+  };
+  const wmedianRank = (r, useUp) => {
+    const ids = ranks[r];
+    const neigh = useUp ? up : down;
+    const med = /* @__PURE__ */ new Map();
+    for (const id of ids)
+      med.set(id, median(neigh.get(id).map((x) => orderOf.get(x))));
+    const movable = ids.filter((id) => med.get(id) >= 0).sort((a, b) => med.get(a) - med.get(b));
+    const out = new Array(ids.length).fill(null);
+    for (const id of ids) if (med.get(id) < 0) out[orderOf.get(id)] = id;
+    let mi = 0;
+    for (let slot = 0; slot < out.length; slot++)
+      if (out[slot] === null) out[slot] = movable[mi++];
+    const final = out;
+    final.forEach((id, i) => orderOf.set(id, i));
+    ranks[r] = final;
+  };
+  const transpose = () => {
+    let improved = true;
+    let guard = 0;
+    while (improved && guard++ < 12) {
+      improved = false;
+      for (let r = 0; r <= maxRank; r++) {
+        const ids = ranks[r];
+        for (let i = 0; i < ids.length - 1; i++) {
+          const before = (r > 0 ? gapCrossings(r - 1) : 0) + (r < maxRank ? gapCrossings(r) : 0);
+          const a = ids[i], b = ids[i + 1];
+          ids[i] = b;
+          ids[i + 1] = a;
+          orderOf.set(b, i);
+          orderOf.set(a, i + 1);
+          const after = (r > 0 ? gapCrossings(r - 1) : 0) + (r < maxRank ? gapCrossings(r) : 0);
+          if (after < before) {
+            improved = true;
+          } else {
+            ids[i] = a;
+            ids[i + 1] = b;
+            orderOf.set(a, i);
+            orderOf.set(b, i + 1);
+          }
+        }
+      }
+    }
+  };
+  const initOrder = (seed) => {
+    const r = seed === 0 ? null : rng(seed);
+    for (let rr = 0; rr <= maxRank; rr++) {
+      const ids = ranks[rr].slice();
+      if (r) {
+        for (let i = ids.length - 1; i > 0; i--) {
+          const j = Math.floor(r() * (i + 1));
+          [ids[i], ids[j]] = [ids[j], ids[i]];
+        }
+      }
+      ranks[rr] = ids;
+      ids.forEach((id, i) => orderOf.set(id, i));
+    }
+  };
+  const found = [];
+  for (let s = 0; s < restarts; s++) {
+    initOrder(s);
+    let best = totalCrossings();
+    let bestSnap = new Map(orderOf);
+    for (let iter = 0; iter < 8; iter++) {
+      const down1 = iter % 2 === 0;
+      if (down1) for (let r = 1; r <= maxRank; r++) wmedianRank(r, true);
+      else for (let r = maxRank - 1; r >= 0; r--) wmedianRank(r, false);
+      transpose();
+      const c = totalCrossings();
+      if (c < best) {
+        best = c;
+        bestSnap = new Map(orderOf);
+      }
+      if (c === 0) break;
+    }
+    applyOrder(bestSnap);
+    for (let r = 0; r <= maxRank; r++)
+      ranks[r].sort((a, b) => orderOf.get(a) - orderOf.get(b));
+    const sig = ranks.map((r) => r.join(",")).join("|");
+    if (!found.some((f) => f.sig === sig))
+      found.push({ sig, cross: best, order: new Map(bestSnap) });
+  }
+  found.sort((a, b) => a.cross - b.cross);
+  const keep = found.slice(0, keepK);
+  if (keep.length === 0) return [];
+  const results = [];
+  for (const cand of keep) {
+    applyOrder(cand.order);
+    const rk = Array.from({ length: maxRank + 1 }, () => []);
+    for (const n of node.values()) rk[n.rank].push(n.id);
+    for (let r = 0; r <= maxRank; r++)
+      rk[r].sort((a, b) => cand.order.get(a) - cand.order.get(b));
+    results.push(realize(rk));
+  }
+  return results;
+  function realize(rk) {
+    const bandDepth = rk.map(
+      (ids) => Math.max(0, ...ids.map((id) => node.get(id).depth))
+    );
+    const bandCenter = [];
+    let acc = MARGIN3;
+    for (let r = 0; r <= maxRank; r++) {
+      bandCenter[r] = acc + bandDepth[r] / 2;
+      acc += bandDepth[r] + ranksep;
+    }
+    for (let r = 0; r <= maxRank; r++) {
+      let x = MARGIN3;
+      for (const id of rk[r]) {
+        const n = node.get(id);
+        n.cross = x + n.thick / 2;
+        x += n.thick + nodesep;
+      }
+    }
+    const ITER = 18;
+    for (let it = 0; it < ITER; it++) {
+      const downPass = it % 2 === 0;
+      const order = downPass ? Array.from({ length: maxRank + 1 }, (_, i) => i) : Array.from({ length: maxRank + 1 }, (_, i) => maxRank - i);
+      for (const r of order) {
+        const ids = rk[r];
+        const desired = ids.map((id) => {
+          const n = node.get(id);
+          let sw = 0, sx2 = 0;
+          for (const nb of up.get(id)) {
+            const w = weight(n, node.get(nb));
+            sw += w;
+            sx2 += w * node.get(nb).cross;
+          }
+          for (const nb of down.get(id)) {
+            const w = weight(n, node.get(nb));
+            sw += w;
+            sx2 += w * node.get(nb).cross;
+          }
+          return sw > 0 ? sx2 / sw : n.cross;
+        });
+        placeWithSeparation(ids, desired);
+      }
+    }
+    let minC = Infinity;
+    for (const n of node.values()) minC = Math.min(minC, n.cross - n.thick / 2);
+    const shift = MARGIN3 - minC;
+    for (const n of node.values()) n.cross += shift;
+    const coord = (n) => isTB ? { x: n.cross, y: bandCenter[n.rank] } : { x: bandCenter[n.rank], y: n.cross };
+    const layoutNodes = parsed.nodes.map((pn) => {
+      const n = node.get(pn.label);
+      const c = coord(n);
+      return {
+        label: pn.label,
+        x: c.x,
+        y: c.y,
+        width: n.realW,
+        height: n.realH
+      };
+    });
+    const chainById = /* @__PURE__ */ new Map();
+    for (const ch of chains) chainById.set(ch.edgeIdx, ch.chain);
+    let minCross = Infinity, maxCross = -Infinity;
+    for (const n of node.values()) {
+      if (n.dummy) continue;
+      minCross = Math.min(minCross, n.cross - n.thick / 2);
+      maxCross = Math.max(maxCross, n.cross + n.thick / 2);
+    }
+    const GAP = 34;
+    const LANE = 28;
+    const sideOf = (b) => {
+      if (backEdgeSide === "left") return -1;
+      if (backEdgeSide === "right") return 1;
+      const d = node.get(b.src).cross - node.get(b.tgt).cross;
+      return d >= 0 ? 1 : -1;
+    };
+    const backSorted = backEdges.map((b) => ({
+      ...b,
+      side: sideOf(b),
+      span: Math.abs(node.get(b.src).rank - node.get(b.tgt).rank)
+    })).sort((a, b) => a.side - b.side || a.span - b.span);
+    const sideCounts = /* @__PURE__ */ new Map();
+    for (const b of backSorted)
+      sideCounts.set(b.side, (sideCounts.get(b.side) ?? 0) + 1);
+    const laneCounter = /* @__PURE__ */ new Map();
+    const backPoints = /* @__PURE__ */ new Map();
+    const faceLim = (depth) => Math.max(0, depth / 2 - 6);
+    const hubIndex = /* @__PURE__ */ new Map();
+    const hubSize = /* @__PURE__ */ new Map();
+    {
+      const counter = /* @__PURE__ */ new Map();
+      for (const b of backSorted) {
+        const key = `${b.side}|${b.tgt}`;
+        const idx = counter.get(key) ?? 0;
+        counter.set(key, idx + 1);
+        hubIndex.set(b.edgeIdx, idx);
+      }
+      for (const [key, v] of counter) hubSize.set(key, v);
+    }
+    for (const b of backSorted) {
+      const s = b.side;
+      const k = laneCounter.get(s) ?? 0;
+      laneCounter.set(s, k + 1);
+      const K = sideCounts.get(s);
+      const src = node.get(b.src);
+      const tgt = node.get(b.tgt);
+      const laneC = s > 0 ? maxCross + GAP + k * LANE : minCross - GAP - k * LANE;
+      const srcCtr = bandCenter[src.rank];
+      const tgtCtr = bandCenter[tgt.rank];
+      const frac = K > 1 ? (k + 1) / (K + 1) : 0;
+      const srcR = srcCtr + frac * faceLim(src.depth);
+      const tgtR = tgtCtr - frac * faceLim(tgt.depth);
+      const m = (c, r) => isTB ? { x: c, y: r } : { x: r, y: c };
+      const off = 10;
+      const srcEdgeC = src.cross + s * (src.thick / 2 + off);
+      const tgtEdgeC = tgt.cross + s * (tgt.thick / 2 + off);
+      const hubK = hubIndex.get(b.edgeIdx);
+      const hubN = hubSize.get(`${s}|${b.tgt}`);
+      if (hubN > 1 && hubK > 0) {
+        const tgtTop = tgtCtr - (tgt.depth / 2 + GAP + (hubK - 1) * LANE);
+        const entryCross = tgt.cross + s * faceLim(tgt.thick) * (hubK / hubN);
+        backPoints.set(b.edgeIdx, [
+          m(src.cross, srcCtr),
+          m(srcEdgeC, srcR),
+          m(laneC, srcR),
+          m(laneC, tgtTop),
+          m(entryCross, tgtTop),
+          m(tgt.cross, tgtCtr)
+        ]);
+      } else {
+        backPoints.set(b.edgeIdx, [
+          m(src.cross, srcCtr),
+          m(srcEdgeC, srcR),
+          m(laneC, srcR),
+          m(laneC, tgtR),
+          m(tgtEdgeC, tgtR),
+          m(tgt.cross, tgtCtr)
+        ]);
+      }
+    }
+    const layoutEdges = [];
+    for (let i = 0; i < parsed.edges.length; i++) {
+      const e = parsed.edges[i];
+      if (!labelSet.has(e.source) || !labelSet.has(e.target)) continue;
+      let points;
+      if (e.source === e.target) {
+        const c = coord(node.get(e.source));
+        points = [c, c];
+      } else if (backPoints.has(i)) {
+        points = backPoints.get(i);
+      } else {
+        const chain = chainById.get(i);
+        if (!chain) continue;
+        points = chain.map((id) => coord(node.get(id)));
+      }
+      layoutEdges.push({
+        source: e.source,
+        target: e.target,
+        ...e.label !== void 0 && { label: e.label },
+        bidirectional: e.bidirectional,
+        lineNumber: e.lineNumber,
+        points,
+        yOffset: 0,
+        parallelCount: 1,
+        metadata: e.metadata
+      });
+    }
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const n of layoutNodes) {
+      minX = Math.min(minX, n.x - n.width / 2);
+      minY = Math.min(minY, n.y - n.height / 2);
+      maxX = Math.max(maxX, n.x + n.width / 2);
+      maxY = Math.max(maxY, n.y + n.height / 2);
+    }
+    for (const e of layoutEdges)
+      for (const p of e.points) {
+        minX = Math.min(minX, p.x);
+        minY = Math.min(minY, p.y);
+        maxX = Math.max(maxX, p.x);
+        maxY = Math.max(maxY, p.y);
+      }
+    const sx = MARGIN3 - minX;
+    const sy = MARGIN3 - minY;
+    const shifted = sx !== 0 || sy !== 0 ? {
+      nodes: layoutNodes.map((n) => ({ ...n, x: n.x + sx, y: n.y + sy })),
+      edges: layoutEdges.map((e) => ({
+        ...e,
+        points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+      }))
+    } : { nodes: layoutNodes, edges: layoutEdges };
+    return {
+      nodes: shifted.nodes,
+      edges: shifted.edges,
+      groups: [],
+      width: maxX + sx + MARGIN3,
+      height: maxY + sy + MARGIN3
+    };
+  }
+  function weight(a, b) {
+    if (a.dummy && b.dummy) return W_DUMMY_DUMMY;
+    if (a.dummy || b.dummy) return W_REAL_DUMMY;
+    return W_REAL_REAL;
+  }
+  function placeWithSeparation(ids, desired) {
+    const n = ids.length;
+    if (n === 0) return;
+    const half = ids.map((id) => node.get(id).thick / 2);
+    const off = [0];
+    for (let i = 1; i < n; i++)
+      off[i] = off[i - 1] + half[i - 1] + nodesep + half[i];
+    const d = desired.map((v, i) => v - off[i]);
+    const blocks = [];
+    for (let i = 0; i < n; i++) {
+      let b = { pos: d[i], count: 1, sumOffset: d[i], first: i };
+      while (blocks.length && blocks[blocks.length - 1].pos >= b.pos) {
+        const prev = blocks.pop();
+        const count = prev.count + b.count;
+        const sumOffset = prev.sumOffset + b.sumOffset;
+        b = { pos: sumOffset / count, count, sumOffset, first: prev.first };
+      }
+      blocks.push(b);
+    }
+    const xs = new Array(n);
+    for (const b of blocks)
+      for (let k = 0; k < b.count; k++) xs[b.first + k] = b.pos;
+    for (let i = 0; i < n; i++) node.get(ids[i]).cross = xs[i] + off[i];
+  }
+}
+var NODESEP, RANKSEP, DUMMY_THICK, MARGIN3, W_REAL_REAL, W_REAL_DUMMY, W_DUMMY_DUMMY;
+var init_layout_layered = __esm({
+  "src/boxes-and-lines/layout-layered.ts"() {
+    "use strict";
+    init_layout5();
+    NODESEP = 50;
+    RANKSEP = 60;
+    DUMMY_THICK = 10;
+    MARGIN3 = 40;
+    W_REAL_REAL = 1;
+    W_REAL_DUMMY = 2;
+    W_DUMMY_DUMMY = 8;
+  }
+});
+
+// src/boxes-and-lines/layout-search.ts
+var layout_search_exports = {};
+__export(layout_search_exports, {
+  countEdgeNearMiss: () => countEdgeNearMiss,
+  countEdgeNodePierces: () => countEdgeNodePierces,
+  countEdgeOverlaps: () => countEdgeOverlaps,
+  countGroupOverlaps: () => countGroupOverlaps,
+  countSplineCrossings: () => countSplineCrossings,
+  deroutePierces: () => deroutePierces,
+  detectEdgeNodePierces: () => detectEdgeNodePierces,
+  detectEdgeOverlaps: () => detectEdgeOverlaps,
+  detectGroupOverlaps: () => detectGroupOverlaps,
+  layoutBoxesAndLinesSearch: () => layoutBoxesAndLinesSearch,
+  separateGroupBands: () => separateGroupBands
+});
+import dagre4 from "@dagrejs/dagre";
+import { line as d3line, curveBasis as curveBasis5 } from "d3-shape";
+function rng2(s) {
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function shuffle(a, r) {
+  const x = a.slice();
+  for (let i = x.length - 1; i > 0; i--) {
+    const j = Math.floor(r() * (i + 1));
+    [x[i], x[j]] = [x[j], x[i]];
+  }
+  return x;
+}
+function flatten(d) {
+  const toks = d.match(/[MLQC]|-?\d*\.?\d+(?:e-?\d+)?/gi) ?? [];
+  const pts = [];
+  let i = 0, cx = 0, cy = 0, cmd = "";
+  const num = () => parseFloat(toks[i++]);
+  const samp = (p0, c1, c2, p1) => {
+    for (let t = 0; t <= 1; t += 0.12) {
+      const u = 1 - t;
+      if (c2)
+        pts.push({
+          x: u * u * u * p0.x + 3 * u * u * t * c1.x + 3 * u * t * t * c2.x + t * t * t * p1.x,
+          y: u * u * u * p0.y + 3 * u * u * t * c1.y + 3 * u * t * t * c2.y + t * t * t * p1.y
+        });
+      else
+        pts.push({
+          x: u * u * p0.x + 2 * u * t * c1.x + t * t * p1.x,
+          y: u * u * p0.y + 2 * u * t * c1.y + t * t * p1.y
+        });
+    }
+  };
+  while (i < toks.length) {
+    const tk = toks[i];
+    if (/[MLQC]/i.test(tk)) {
+      cmd = tk;
+      i++;
+    }
+    if (cmd === "M" || cmd === "L") {
+      const x = num(), y = num();
+      pts.push({ x, y });
+      cx = x;
+      cy = y;
+    } else if (cmd === "Q") {
+      const c1 = { x: num(), y: num() }, p1 = { x: num(), y: num() };
+      samp({ x: cx, y: cy }, c1, null, p1);
+      cx = p1.x;
+      cy = p1.y;
+    } else if (cmd === "C") {
+      const c1 = { x: num(), y: num() }, c2 = { x: num(), y: num() }, p1 = { x: num(), y: num() };
+      samp({ x: cx, y: cy }, c1, c2, p1);
+      cx = p1.x;
+      cy = p1.y;
+    } else i++;
+  }
+  return pts;
+}
+function segPoint(p1, p2, p3, p4) {
+  const den = (p2.x - p1.x) * (p4.y - p3.y) - (p2.y - p1.y) * (p4.x - p3.x);
+  if (Math.abs(den) < 1e-9) return null;
+  const t = ((p3.x - p1.x) * (p4.y - p3.y) - (p3.y - p1.y) * (p4.x - p3.x)) / den, u = ((p3.x - p1.x) * (p2.y - p1.y) - (p3.y - p1.y) * (p2.x - p1.x)) / den;
+  return t > 0 && t < 1 && u > 0 && u < 1 ? { x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y) } : null;
+}
+function countSplineCrossings(layout) {
+  const center = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes) center.set(n.label, { x: n.x, y: n.y });
+  for (const g of layout.groups)
+    if (g.collapsed) center.set("__group_" + g.label, { x: g.x, y: g.y });
+  const polys = layout.edges.map((e) => {
+    const pts = e.points.length >= 2 ? flatten(splineGen(e.points) ?? "") : [];
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of pts) {
+      if (p.x < x0) x0 = p.x;
+      if (p.x > x1) x1 = p.x;
+      if (p.y < y0) y0 = p.y;
+      if (p.y > y1) y1 = p.y;
+    }
+    return { pts, s: e.source, t: e.target, x0, y0, x1, y1 };
+  });
+  const R = 34;
+  let total = 0;
+  for (let a = 0; a < polys.length; a++)
+    for (let b = a + 1; b < polys.length; b++) {
+      const A = polys[a], B = polys[b];
+      if (A.pts.length < 2 || B.pts.length < 2) continue;
+      if (A.x1 < B.x0 || B.x1 < A.x0 || A.y1 < B.y0 || B.y1 < A.y0) continue;
+      const shared = [A.s, A.t].filter((n) => n === B.s || n === B.t).map((n) => center.get(n)).filter(Boolean);
+      const hits = [];
+      for (let i = 1; i < A.pts.length; i++)
+        for (let j = 1; j < B.pts.length; j++) {
+          const p = segPoint(
+            A.pts[i - 1],
+            A.pts[i],
+            B.pts[j - 1],
+            B.pts[j]
+          );
+          if (!p) continue;
+          if (shared.some((c) => Math.hypot(p.x - c.x, p.y - c.y) < R))
+            continue;
+          if (!hits.some((h) => Math.hypot(h.x - p.x, h.y - p.y) < 6))
+            hits.push(p);
+        }
+      total += hits.length;
+    }
+  return total;
+}
+function pointSegDist(p, a, b) {
+  const dx = b.x - a.x, dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-9) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+function distToPoly(p, poly) {
+  let m = Infinity;
+  for (let i = 1; i < poly.length; i++)
+    m = Math.min(m, pointSegDist(p, poly[i - 1], poly[i]));
+  return m;
+}
+function pointRectDist(p, r) {
+  const dx = Math.max(r.x - r.w / 2 - p.x, 0, p.x - (r.x + r.w / 2));
+  const dy = Math.max(r.y - r.h / 2 - p.y, 0, p.y - (r.y + r.h / 2));
+  return Math.hypot(dx, dy);
+}
+function detectEdgeOverlaps(layout, opts) {
+  const dist = opts?.dist ?? 8;
+  const minLen = opts?.minLen ?? 16;
+  const nodeClear = opts?.nodeClear ?? 12;
+  const rect = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes)
+    rect.set(n.label, { x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rect.set("__group_" + g.label, {
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const polys = layout.edges.map((e) => {
+    const pts = e.points.length >= 2 ? flatten(splineGen(e.points) ?? "") : [];
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of pts) {
+      if (p.x < x0) x0 = p.x;
+      if (p.x > x1) x1 = p.x;
+      if (p.y < y0) y0 = p.y;
+      if (p.y > y1) y1 = p.y;
+    }
+    return { pts, s: e.source, t: e.target, x0, y0, x1, y1 };
+  });
+  const runs = [];
+  for (let a = 0; a < polys.length; a++)
+    for (let b = a + 1; b < polys.length; b++) {
+      const A = polys[a], B = polys[b];
+      if (A.pts.length < 2 || B.pts.length < 2) continue;
+      if (A.x1 + dist < B.x0 || B.x1 + dist < A.x0 || A.y1 + dist < B.y0 || B.y1 + dist < A.y0)
+        continue;
+      const shared = [A.s, A.t].filter((n) => n === B.s || n === B.t).map((n) => rect.get(n)).filter(Boolean);
+      let run = [];
+      let runLen = 0;
+      const flush = () => {
+        if (runLen >= minLen && run.length >= 2)
+          runs.push({
+            mid: run[Math.floor(run.length / 2)],
+            length: runLen,
+            pts: run.slice()
+          });
+        run = [];
+        runLen = 0;
+      };
+      for (const p of A.pts) {
+        const nearShared = shared.some((r) => pointRectDist(p, r) < nodeClear);
+        const covered = !nearShared && distToPoly(p, B.pts) < dist;
+        if (covered) {
+          if (run.length)
+            runLen += Math.hypot(
+              p.x - run[run.length - 1].x,
+              p.y - run[run.length - 1].y
+            );
+          run.push(p);
+        } else flush();
+      }
+      flush();
+    }
+  return runs;
+}
+function countEdgeOverlaps(layout, opts) {
+  return detectEdgeOverlaps(layout, opts).length;
+}
+function detectEdgeNodePierces(layout, opts) {
+  const inset = opts?.inset ?? 6;
+  const minPts = opts?.minPts ?? 2;
+  const rects = [];
+  for (const n of layout.nodes)
+    rects.push({ key: n.label, x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rects.push({
+        key: "__group_" + g.label,
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const inside = (p, r) => Math.abs(p.x - r.x) < r.w / 2 - inset && Math.abs(p.y - r.y) < r.h / 2 - inset;
+  const out = [];
+  layout.edges.forEach((e, idx) => {
+    if (e.points.length < 2) return;
+    const poly = flatten(splineGen(e.points) ?? "");
+    for (const r of rects) {
+      if (r.key === e.source || r.key === e.target || "__group_" + r.key === e.source || "__group_" + r.key === e.target)
+        continue;
+      const hits = poly.filter((p) => inside(p, r));
+      if (hits.length >= minPts)
+        out.push({ edgeIdx: idx, node: r.key, pts: hits });
+    }
+  });
+  return out;
+}
+function countEdgeNodePierces(layout, opts) {
+  return detectEdgeNodePierces(layout, opts).length;
+}
+function deroutePierces(layout) {
+  const pierces = detectEdgeNodePierces(layout);
+  if (!pierces.length) return layout;
+  const rect = /* @__PURE__ */ new Map();
+  for (const n of layout.nodes)
+    rect.set(n.label, { x: n.x, y: n.y, w: n.width, h: n.height });
+  for (const g of layout.groups)
+    if (g.collapsed)
+      rect.set("__group_" + g.label, {
+        x: g.x,
+        y: g.y,
+        w: g.width,
+        h: g.height
+      });
+  const byEdge = /* @__PURE__ */ new Map();
+  for (const p of pierces) {
+    const arr = byEdge.get(p.edgeIdx);
+    if (arr) arr.push(p.node);
+    else byEdge.set(p.edgeIdx, [p.node]);
+  }
+  const edges = layout.edges.map((e, idx) => {
+    const nodes = byEdge.get(idx);
+    if (!nodes) return e;
+    let pts = e.points.map((p) => ({ x: p.x, y: p.y }));
+    for (const label of nodes) {
+      const r = rect.get(label);
+      if (r) pts = detourAround(pts, r);
+    }
+    return { ...e, points: pts };
+  });
+  return { ...layout, edges };
+}
+function detourAround(pts, r) {
+  if (pts.length < 2) return pts;
+  const c = { x: r.x, y: r.y };
+  let bestSeg = -1;
+  let bestT = 0;
+  let bestD = Infinity;
+  let bestPt = pts[0];
+  for (let i = 0; i < pts.length - 1; i++) {
+    const a2 = pts[i], b2 = pts[i + 1];
+    const dx = b2.x - a2.x, dy = b2.y - a2.y;
+    const len2 = dx * dx + dy * dy || 1e-9;
+    let t = ((c.x - a2.x) * dx + (c.y - a2.y) * dy) / len2;
+    t = Math.max(0, Math.min(1, t));
+    const q = { x: a2.x + t * dx, y: a2.y + t * dy };
+    const d = Math.hypot(q.x - c.x, q.y - c.y);
+    if (d < bestD) {
+      bestD = d;
+      bestSeg = i;
+      bestT = t;
+      bestPt = q;
+    }
+  }
+  if (bestSeg < 0) return pts;
+  let nx = bestPt.x - c.x;
+  let ny = bestPt.y - c.y;
+  if (Math.hypot(nx, ny) < 1) {
+    if (r.w <= r.h) {
+      nx = 1;
+      ny = 0;
+    } else {
+      nx = 0;
+      ny = 1;
+    }
+  }
+  const nlen = Math.hypot(nx, ny) || 1;
+  nx /= nlen;
+  ny /= nlen;
+  const a = pts[bestSeg], b = pts[bestSeg + 1];
+  let ex = b.x - a.x, ey = b.y - a.y;
+  const elen = Math.hypot(ex, ey) || 1;
+  ex /= elen;
+  ey /= elen;
+  const clear = Math.hypot(r.w, r.h) / 2 + 18;
+  const hw = Math.hypot(r.w, r.h) / 2;
+  void bestT;
+  const before = {
+    x: bestPt.x - ex * hw + nx * clear * 0.5,
+    y: bestPt.y - ey * hw + ny * clear * 0.5
+  };
+  const peak = { x: c.x + nx * clear, y: c.y + ny * clear };
+  const after = {
+    x: bestPt.x + ex * hw + nx * clear * 0.5,
+    y: bestPt.y + ey * hw + ny * clear * 0.5
+  };
+  const out = pts.slice(0, bestSeg + 1);
+  out.push(before, peak, after);
+  out.push(...pts.slice(bestSeg + 1));
+  return out;
+}
+function countEdgeNearMiss(layout, opts) {
+  const near = opts?.near ?? 14;
+  const tight = opts?.tight ?? 8;
+  const minLen = opts?.minLen ?? 18;
+  const close = detectEdgeOverlaps(layout, { dist: near, minLen }).length;
+  const over = detectEdgeOverlaps(layout, { dist: tight, minLen }).length;
+  return Math.max(0, close - over);
+}
+function detectGroupOverlaps(layout, opts) {
+  const margin = opts?.margin ?? 4;
+  const raw = layout.groups.map((g) => ({
+    label: g.label,
+    l: g.x - g.width / 2,
+    r: g.x + g.width / 2,
+    t: g.y - g.height / 2,
+    b: g.y + g.height / 2
+  }));
+  const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
+  const rend = raw.map((a, i) => {
+    const parent = raw.some((b, j) => j !== i && contains(a, b));
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE2 } : a;
+  });
+  const hit = /* @__PURE__ */ new Set();
+  for (let i = 0; i < raw.length; i++)
+    for (let j = i + 1; j < raw.length; j++) {
+      if (contains(raw[i], raw[j]) || contains(raw[j], raw[i])) continue;
+      const a = rend[i], b = rend[j];
+      const dx = Math.max(a.l - b.r, b.l - a.r);
+      const dy = Math.max(a.t - b.b, b.t - a.b);
+      if (Math.max(dx, dy) < margin) {
+        hit.add(raw[i].label);
+        hit.add(raw[j].label);
+      }
+    }
+  return [...hit];
+}
+function countGroupOverlaps(layout, opts) {
+  const margin = opts?.margin ?? 4;
+  const raw = layout.groups.map((g) => ({
+    l: g.x - g.width / 2,
+    r: g.x + g.width / 2,
+    t: g.y - g.height / 2,
+    b: g.y + g.height / 2
+  }));
+  const contains = (outer, inner) => outer.l <= inner.l + margin && outer.r >= inner.r - margin && outer.t <= inner.t + margin && outer.b >= inner.b - margin;
+  const rend = raw.map((a, i) => {
+    const parent = raw.some((b, j) => j !== i && contains(a, b));
+    return parent ? { ...a, t: a.t - GROUP_LABEL_ZONE2 } : a;
+  });
+  let count = 0;
+  for (let i = 0; i < raw.length; i++)
+    for (let j = i + 1; j < raw.length; j++) {
+      if (contains(raw[i], raw[j]) || contains(raw[j], raw[i])) continue;
+      const a = rend[i], b = rend[j];
+      const dx = Math.max(a.l - b.r, b.l - a.r);
+      const dy = Math.max(a.t - b.b, b.t - a.b);
+      if (Math.max(dx, dy) < margin) count++;
+    }
+  return count;
+}
+function separateGroupBands(layout, parsed) {
+  if (layout.groups.some((g) => g.collapsed)) return layout;
+  if (countGroupOverlaps(layout) === 0) return layout;
+  const parentOf = /* @__PURE__ */ new Map();
+  for (const g of parsed.groups) parentOf.set(g.label, g.parentGroup);
+  const topOf = (label) => {
+    let cur = label;
+    const seen = /* @__PURE__ */ new Set();
+    for (; ; ) {
+      const p = parentOf.get(cur);
+      if (!p || seen.has(p)) return cur;
+      seen.add(cur);
+      cur = p;
+    }
+  };
+  const topLabels = parsed.groups.filter((g) => !g.parentGroup).map((g) => g.label);
+  if (topLabels.length < 2) return layout;
+  const nodeTop = /* @__PURE__ */ new Map();
+  for (const g of parsed.groups)
+    for (const child of g.children)
+      if (!parsed.groups.some((gg) => gg.label === child))
+        nodeTop.set(child, topOf(g.label));
+  const axis = parsed.direction === "TB" ? "x" : "y";
+  const boxByLabel = new Map(layout.groups.map((g) => [g.label, g]));
+  const bands = topLabels.map((label) => {
+    const g = boxByLabel.get(label);
+    const half2 = (axis === "y" ? g.height : g.width) / 2;
+    let lo = (axis === "y" ? g.y : g.x) - half2;
+    const hi = (axis === "y" ? g.y : g.x) + half2;
+    const isParent = parsed.groups.some((c) => c.parentGroup === label);
+    if (axis === "y" && isParent) lo -= GROUP_LABEL_ZONE2;
+    return { label, lo, hi, c: (lo + hi) / 2 };
+  });
+  bands.sort((a, b) => a.c - b.c);
+  const GAP = 16;
+  const half = bands.map((b) => (b.hi - b.lo) / 2);
+  const off = [0];
+  for (let i = 1; i < bands.length; i++)
+    off[i] = off[i - 1] + half[i - 1] + GAP + half[i];
+  const desired = bands.map((b, i) => b.c - off[i]);
+  const blocks = [];
+  for (let i = 0; i < bands.length; i++) {
+    let blk = { pos: desired[i], count: 1, sum: desired[i], first: i };
+    while (blocks.length && blocks[blocks.length - 1].pos >= blk.pos) {
+      const prev = blocks.pop();
+      const count = prev.count + blk.count;
+      const sum = prev.sum + blk.sum;
+      blk = { pos: sum / count, count, sum, first: prev.first };
+    }
+    blocks.push(blk);
+  }
+  const newC = new Array(bands.length);
+  for (const blk of blocks)
+    for (let k = 0; k < blk.count; k++)
+      newC[blk.first + k] = blk.pos + off[blk.first + k];
+  const delta = /* @__PURE__ */ new Map();
+  let moved = false;
+  bands.forEach((b, i) => {
+    const d = newC[i] - b.c;
+    delta.set(b.label, d);
+    if (Math.abs(d) > 0.5) moved = true;
+  });
+  if (!moved) return layout;
+  const nodeDelta = (label) => {
+    const top = nodeTop.get(label);
+    return top ? delta.get(top) ?? 0 : 0;
+  };
+  const shift = (p, d) => axis === "y" ? { x: p.x, y: p.y + d } : { x: p.x + d, y: p.y };
+  const nodes = layout.nodes.map((n) => {
+    const d = nodeDelta(n.label);
+    return d ? { ...n, ...axis === "y" ? { y: n.y + d } : { x: n.x + d } } : n;
+  });
+  const groups = layout.groups.map((g) => {
+    const d = delta.get(topOf(g.label)) ?? 0;
+    return d ? { ...g, ...axis === "y" ? { y: g.y + d } : { x: g.x + d } } : g;
+  });
+  const edges = layout.edges.map((e) => {
+    const ds = nodeDelta(e.source);
+    const dt = nodeDelta(e.target);
+    if (!ds && !dt) return e;
+    const N = e.points.length;
+    const points = e.points.map((p, i) => {
+      const f = N > 1 ? i / (N - 1) : 0;
+      return shift(p, ds * (1 - f) + dt * f);
+    });
+    return { ...e, points };
+  });
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  const acc = (x, y) => {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  };
+  for (const n of nodes) {
+    acc(n.x - n.width / 2, n.y - n.height / 2);
+    acc(n.x + n.width / 2, n.y + n.height / 2);
+  }
+  for (const g of groups) {
+    acc(g.x - g.width / 2, g.y - g.height / 2 - GROUP_LABEL_ZONE2);
+    acc(g.x + g.width / 2, g.y + g.height / 2);
+  }
+  for (const e of edges) for (const p of e.points) acc(p.x, p.y);
+  const M = 40;
+  const sx = M - minX, sy = M - minY;
+  const reshift = sx !== 0 || sy !== 0;
+  return {
+    nodes: reshift ? nodes.map((n) => ({ ...n, x: n.x + sx, y: n.y + sy })) : nodes,
+    groups: reshift ? groups.map((g) => ({ ...g, x: g.x + sx, y: g.y + sy })) : groups,
+    edges: reshift ? edges.map((e) => ({
+      ...e,
+      points: e.points.map((p) => ({ x: p.x + sx, y: p.y + sy }))
+    })) : edges,
+    width: maxX - minX + 2 * M,
+    height: maxY - minY + 2 * M
+  };
+}
+function segCross(p1, p2, p3, p4) {
+  const d1x = p2.x - p1.x, d1y = p2.y - p1.y, d2x = p4.x - p3.x, d2y = p4.y - p3.y;
+  const den = d1x * d2y - d1y * d2x;
+  if (Math.abs(den) < 1e-9) return false;
+  const t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / den;
+  const s = ((p3.x - p1.x) * d1y - (p3.y - p1.y) * d1x) / den;
+  return t > 1e-3 && t < 0.999 && s > 1e-3 && s < 0.999;
+}
+function countCrossingsFast(layout) {
+  const E = layout.edges.filter((e) => e.points.length >= 2);
+  const bb = E.map((e) => {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of e.points) {
+      if (p.x < x0) x0 = p.x;
+      if (p.x > x1) x1 = p.x;
+      if (p.y < y0) y0 = p.y;
+      if (p.y > y1) y1 = p.y;
+    }
+    return { x0, y0, x1, y1 };
+  });
+  let count = 0;
+  for (let i = 0; i < E.length; i++)
+    for (let j = i + 1; j < E.length; j++) {
+      const A = E[i], B = E[j];
+      if (A.source === B.source || A.source === B.target || A.target === B.source || A.target === B.target)
+        continue;
+      const a = bb[i], b = bb[j];
+      if (a.x1 < b.x0 || b.x1 < a.x0 || a.y1 < b.y0 || b.y1 < a.y0) continue;
+      const pa = A.points, pb = B.points;
+      let hit = false;
+      for (let ai = 0; ai < pa.length - 1 && !hit; ai++)
+        for (let bi = 0; bi < pb.length - 1; bi++) {
+          if (segCross(pa[ai], pa[ai + 1], pb[bi], pb[bi + 1])) {
+            hit = true;
+            break;
+          }
+        }
+      if (hit) count++;
+    }
+  return count;
+}
+function meanDrift(layout, prev) {
+  if (!prev?.size) return 0;
+  let sum = 0, n = 0;
+  for (const node of layout.nodes) {
+    const p = prev.get(node.label);
+    if (p) {
+      sum += Math.hypot(node.x - p.x, node.y - p.y);
+      n++;
+    }
+  }
+  return n ? sum / n : 0;
+}
+function edgeLength(layout) {
+  let total = 0;
+  for (const e of layout.edges)
+    for (let i = 1; i < e.points.length; i++)
+      total += Math.hypot(
+        e.points[i].x - e.points[i - 1].x,
+        e.points[i].y - e.points[i - 1].y
+      );
+  return total;
+}
+function layoutBoxesAndLinesSearch(parsed, collapseInfo, opts) {
+  const hideDescriptions = opts?.hideDescriptions ?? false;
+  const collapsedGroupLabels = /* @__PURE__ */ new Set();
+  if (collapseInfo) {
+    const missing = /* @__PURE__ */ new Set();
+    for (const og of collapseInfo.originalGroups)
+      if (!parsed.groups.some((g) => g.label === og.label))
+        missing.add(og.label);
+    for (const label of missing) {
+      const og = collapseInfo.originalGroups.find((g) => g.label === label);
+      const parent = og?.parentGroup;
+      if (!parent || !missing.has(parent)) collapsedGroupLabels.add(label);
+    }
+  }
+  const sizes = /* @__PURE__ */ new Map();
+  let maxDescH = 0;
+  for (const node of parsed.nodes) {
+    const s = hideDescriptions ? { width: NODE_WIDTH, height: NODE_HEIGHT } : computeNodeSize(node, parsed.showValues === true);
+    sizes.set(node.label, s);
+    if (!hideDescriptions && node.description && node.description.length > 0)
+      maxDescH = Math.max(maxDescH, s.height);
+  }
+  if (maxDescH > 0) {
+    for (const node of parsed.nodes)
+      if (node.description && node.description.length > 0) {
+        const s = sizes.get(node.label);
+        sizes.set(node.label, { width: s.width, height: maxDescH });
+      }
+  }
+  const gid = (label) => `__group_${label}`;
+  const rankdir = parsed.direction === "TB" ? "TB" : "LR";
+  function place(cfg) {
+    const r = cfg.seed === void 0 ? null : rng2(cfg.seed + 1);
+    const ord = (a) => r ? shuffle(a, r) : a.slice();
+    const g = new dagre4.graphlib.Graph({ compound: true, multigraph: true });
+    g.setGraph({
+      rankdir,
+      ranker: cfg.ranker,
+      nodesep: cfg.nodesep,
+      ranksep: cfg.ranksep,
+      edgesep: 20,
+      marginx: 40,
+      marginy: 40
+    });
+    g.setDefaultEdgeLabel(() => ({}));
+    for (const grp of ord(parsed.groups))
+      g.setNode(gid(grp.label), { label: grp.label });
+    for (const node of ord(parsed.nodes)) {
+      const s = sizes.get(node.label);
+      g.setNode(node.label, { width: s.width, height: s.height });
+    }
+    for (const label of collapsedGroupLabels)
+      g.setNode(gid(label), { width: NODE_WIDTH, height: NODE_HEIGHT });
+    for (const grp of parsed.groups) {
+      if (grp.parentGroup && g.hasNode(gid(grp.parentGroup)))
+        g.setParent(gid(grp.label), gid(grp.parentGroup));
+      for (const c of ord(grp.children)) {
+        if (g.hasNode(c)) g.setParent(c, gid(grp.label));
+      }
+    }
+    if (collapseInfo)
+      for (const label of collapsedGroupLabels) {
+        const og = collapseInfo.originalGroups.find((x) => x.label === label);
+        if (og?.parentGroup && !collapsedGroupLabels.has(og.parentGroup) && g.hasNode(gid(og.parentGroup)))
+          g.setParent(gid(label), gid(og.parentGroup));
+      }
+    for (const e of ord(parsed.edges))
+      if (g.hasNode(e.source) && g.hasNode(e.target))
+        g.setEdge(e.source, e.target, {});
+    dagre4.layout(g);
+    const nodes = parsed.nodes.map((n2) => {
+      const p = g.node(n2.label);
+      return {
+        label: n2.label,
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height
+      };
+    });
+    const groups = parsed.groups.map(
+      (grp) => {
+        const p = g.node(gid(grp.label));
+        return {
+          label: grp.label,
+          lineNumber: grp.lineNumber,
+          x: p.x,
+          y: p.y,
+          width: p.width,
+          height: p.height,
+          collapsed: false,
+          childCount: grp.children.length
+        };
+      }
+    );
+    for (const label of collapsedGroupLabels) {
+      const p = g.node(gid(label));
+      groups.push({
+        label,
+        lineNumber: 0,
+        x: p.x,
+        y: p.y,
+        width: p.width,
+        height: p.height,
+        collapsed: true,
+        childCount: collapseInfo?.collapsedChildCounts.get(label) ?? 0
+      });
+    }
+    const edges = parsed.edges.filter((e) => g.hasEdge(e.source, e.target)).map((e) => {
+      const ed = g.edge(e.source, e.target);
+      return {
+        source: e.source,
+        target: e.target,
+        ...e.label !== void 0 && { label: e.label },
+        bidirectional: e.bidirectional,
+        lineNumber: e.lineNumber,
+        points: ed?.points ?? [],
+        yOffset: 0,
+        parallelCount: 1,
+        metadata: e.metadata
+      };
+    });
+    const gg = g.graph();
+    return {
+      nodes,
+      edges,
+      groups,
+      width: gg.width ?? 800,
+      height: gg.height ?? 600
+    };
+  }
+  const n = parsed.nodes.length;
+  const seedCount = opts?.seeds ?? (n <= 12 ? 80 : n <= 22 ? 40 : n <= 35 ? 22 : 10);
+  const REFINE_K = opts?.refineK ?? 6;
+  const lambda = opts?.lambda ?? DEFAULT_LAMBDA;
+  const prev = opts?.previousPositions;
+  const RANKERS = ["network-simplex", "tight-tree", "longest-path"];
+  const SPACINGS = [
+    { nodesep: 50, ranksep: 60 },
+    { nodesep: 34, ranksep: 46 },
+    { nodesep: 66, ranksep: 82 }
+  ];
+  const configs = [];
+  for (const ranker of RANKERS)
+    for (const sp of SPACINGS) configs.push({ ranker, ...sp });
+  for (let s = 0; s < seedCount; s++)
+    configs.push({
+      ranker: "network-simplex",
+      nodesep: 50,
+      ranksep: 60,
+      seed: s
+    });
+  const badness = (lay, floor) => {
+    const x = countSplineCrossings(lay);
+    if (x > floor) return Infinity;
+    return x + countEdgeOverlaps(lay) + countEdgeNodePierces(lay) + countGroupOverlaps(lay);
+  };
+  const objective = (lay, viol) => viol * 1e6 + edgeLength(lay) + lambda * meanDrift(lay, prev) * 10;
+  const pool = [];
+  for (const cfg of configs) {
+    try {
+      pool.push(place(cfg));
+    } catch {
+    }
+  }
+  if (!pool.length)
+    return place({ ranker: "network-simplex", nodesep: 50, ranksep: 60 });
+  let layered = [];
+  try {
+    layered = layeredCandidates(parsed, sizes);
+  } catch {
+  }
+  pool.sort(
+    (a, b) => objective(a, countCrossingsFast(a)) - objective(b, countCrossingsFast(b))
+  );
+  const refineK = Math.min(REFINE_K, pool.length);
+  let best = pool[0];
+  let bestObj = Infinity;
+  let bestBad = Infinity;
+  const consider = (lay) => {
+    const bad = badness(lay, bestBad);
+    if (bad === Infinity) return;
+    const sc = objective(lay, bad);
+    if (sc < bestObj) {
+      bestObj = sc;
+      bestBad = bad;
+      best = lay;
+    }
+  };
+  for (const lay of pool.slice(0, refineK)) consider(lay);
+  if (bestBad >= ESCALATE_THRESHOLD && n <= ESCALATE_MAX_N) {
+    const extra = [];
+    for (let s = seedCount; s < seedCount + ESCALATE_SEEDS; s++) {
+      try {
+        extra.push(
+          place({
+            ranker: "network-simplex",
+            nodesep: 50,
+            ranksep: 60,
+            seed: s
+          })
+        );
+      } catch {
+      }
+    }
+    extra.sort(
+      (a, b) => objective(a, countCrossingsFast(a)) - objective(b, countCrossingsFast(b))
+    );
+    for (const lay of extra.slice(0, ESCALATE_REFINE)) consider(lay);
+  }
+  for (const lay of layered) {
+    const variants = [lay];
+    const dp = deroutePierces(lay);
+    if (dp !== lay) variants.push(dp);
+    for (const v of variants) {
+      const bad = badness(v, bestBad - 1);
+      if (bad < bestBad) {
+        bestBad = bad;
+        best = v;
+      }
+    }
+  }
+  if (bestBad > 0) {
+    const rerouted = deroutePierces(best);
+    if (rerouted !== best && badness(rerouted, bestBad - 1) < bestBad)
+      best = rerouted;
+  }
+  if (bestBad > 0 && countGroupOverlaps(best) > 0) {
+    const separated = separateGroupBands(best, parsed);
+    if (separated !== best && badness(separated, bestBad - 1) < bestBad)
+      best = separated;
+  }
+  return best;
+}
+var DEFAULT_LAMBDA, ESCALATE_THRESHOLD, ESCALATE_MAX_N, ESCALATE_SEEDS, ESCALATE_REFINE, splineGen, GROUP_LABEL_ZONE2;
+var init_layout_search = __esm({
+  "src/boxes-and-lines/layout-search.ts"() {
+    "use strict";
+    init_layout5();
+    init_layout_layered();
+    DEFAULT_LAMBDA = 4;
+    ESCALATE_THRESHOLD = 4;
+    ESCALATE_MAX_N = 45;
+    ESCALATE_SEEDS = 18;
+    ESCALATE_REFINE = 10;
+    splineGen = d3line().x((d) => d.x).y((d) => d.y).curve(curveBasis5);
+    GROUP_LABEL_ZONE2 = 32;
+  }
+});
+
 // src/boxes-and-lines/layout.ts
 var layout_exports5 = {};
 __export(layout_exports5, {
+  NODE_HEIGHT: () => NODE_HEIGHT,
+  NODE_WIDTH: () => NODE_WIDTH,
+  computeNodeSize: () => computeNodeSize,
   layoutBoxesAndLines: () => layoutBoxesAndLines
 });
-import ELK from "elkjs/lib/elk.bundled.js";
 function splitCamelCase2(word) {
   const parts = [];
   let start = 0;
@@ -27758,417 +29090,21 @@ function computeNodeSize(node, reserveValueRow) {
   const totalHeight = labelHeight + SEPARATOR_GAP5 + DESC_PADDING + descriptionHeight + DESC_PADDING + (reserveValueRow ? VALUE_ROW_H : 0);
   return { width: w, height: Math.max(NODE_HEIGHT, totalHeight) };
 }
-function getElk() {
-  if (!elkInstance) elkInstance = new ELK();
-  return elkInstance;
-}
-function baseOptions() {
-  return {
-    "elk.algorithm": "layered",
-    // INCLUDE_CHILDREN lets ELK route edges across container boundaries.
-    "elk.hierarchyHandling": "INCLUDE_CHILDREN",
-    "elk.edgeRouting": "ORTHOGONAL",
-    "elk.layered.unnecessaryBendpoints": "true",
-    // Let edges leave from top/bottom of nodes (not just the flow-direction
-    // sides) when it reduces crossings.
-    "elk.layered.allowNonFlowPortsToSwitchSides": "true"
-  };
-}
-function bkBaseline() {
-  return {
-    ...baseOptions(),
-    "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
-    "elk.layered.nodePlacement.bk.fixedAlignment": "BALANCED",
-    "elk.layered.nodePlacement.bk.edgeStraightening": "IMPROVE_STRAIGHTNESS",
-    "elk.layered.compaction.connectedComponents": "true",
-    "elk.layered.spacing.nodeNodeBetweenLayers": "90",
-    "elk.spacing.nodeNode": "55",
-    "elk.spacing.edgeNode": "55",
-    "elk.spacing.edgeEdge": "18"
-  };
-}
-function getVariants() {
-  const bk = bkBaseline();
-  return [
-    {
-      name: "bk-baseline",
-      options: {
-        ...bk,
-        "elk.layered.crossingMinimization.greedySwitch.type": "ONE_SIDED"
-      }
-    },
-    {
-      name: "bk-aggressive",
-      options: {
-        ...bk,
-        "elk.layered.crossingMinimization.greedySwitch.type": "TWO_SIDED",
-        "elk.layered.thoroughness": "50"
-      }
-    },
-    {
-      name: "bk-wide",
-      options: {
-        ...bk,
-        "elk.layered.crossingMinimization.greedySwitch.type": "TWO_SIDED",
-        "elk.layered.thoroughness": "50",
-        "elk.spacing.nodeNode": "70",
-        "elk.spacing.edgeNode": "75",
-        "elk.spacing.edgeEdge": "22",
-        "elk.layered.spacing.nodeNodeBetweenLayers": "120"
-      }
-    },
-    {
-      name: "longest-path",
-      options: {
-        ...bk,
-        "elk.layered.layering.strategy": "LONGEST_PATH",
-        "elk.layered.crossingMinimization.greedySwitch.type": "TWO_SIDED",
-        "elk.layered.thoroughness": "50"
-      }
-    },
-    {
-      name: "bounded-width",
-      options: {
-        ...bk,
-        "elk.layered.layering.strategy": "COFFMAN_GRAHAM",
-        "elk.layered.layering.coffmanGraham.layerBound": "3",
-        "elk.layered.crossingMinimization.greedySwitch.type": "TWO_SIDED",
-        "elk.layered.thoroughness": "50"
-      }
-    }
-  ];
-}
-function countCrossings(edges) {
-  let count = 0;
-  for (let i = 0; i < edges.length; i++) {
-    const edgeI = edges[i];
-    const a = edgeI.points;
-    if (a.length < 2) continue;
-    for (let j = i + 1; j < edges.length; j++) {
-      const edgeJ = edges[j];
-      const b = edgeJ.points;
-      if (b.length < 2) continue;
-      if (edgeI.source === edgeJ.source) continue;
-      if (edgeI.source === edgeJ.target) continue;
-      if (edgeI.target === edgeJ.source) continue;
-      if (edgeI.target === edgeJ.target) continue;
-      for (let ai = 0; ai < a.length - 1; ai++) {
-        for (let bi = 0; bi < b.length - 1; bi++) {
-          if (segmentsCross(a[ai], a[ai + 1], b[bi], b[bi + 1])) count++;
-        }
-      }
-    }
-  }
-  return count;
-}
-function segmentsCross(p1, p2, p3, p4) {
-  const d1x = p2.x - p1.x;
-  const d1y = p2.y - p1.y;
-  const d2x = p4.x - p3.x;
-  const d2y = p4.y - p3.y;
-  const denom = d1x * d2y - d1y * d2x;
-  if (Math.abs(denom) < 1e-9) return false;
-  const t = ((p3.x - p1.x) * d2y - (p3.y - p1.y) * d2x) / denom;
-  const s = ((p3.x - p1.x) * d1y - (p3.y - p1.y) * d1x) / denom;
-  const EPS = 1e-3;
-  return t > EPS && t < 1 - EPS && s > EPS && s < 1 - EPS;
-}
-function countTotalBends(edges) {
-  let bends = 0;
-  for (const e of edges) bends += Math.max(0, e.points.length - 2);
-  return bends;
-}
-function scoreLayout(layout) {
-  return {
-    crossings: countCrossings(layout.edges),
-    bends: countTotalBends(layout.edges),
-    area: layout.width * layout.height
-  };
-}
-function cmpScore(a, b) {
-  const aBucket = a.crossings <= CROSSINGS_FORGIVENESS ? 0 : a.crossings;
-  const bBucket = b.crossings <= CROSSINGS_FORGIVENESS ? 0 : b.crossings;
-  if (aBucket !== bBucket) return aBucket - bBucket;
-  if (a.area !== b.area) return a.area - b.area;
-  return a.bends - b.bends;
-}
 async function layoutBoxesAndLines(parsed, collapseInfo, layoutOptions) {
-  const hideDescriptions = layoutOptions?.hideDescriptions ?? false;
-  const direction = parsed.direction === "TB" ? "DOWN" : "RIGHT";
-  const collapsedGroupLabels = /* @__PURE__ */ new Set();
-  if (collapseInfo) {
-    const missingGroups = /* @__PURE__ */ new Set();
-    for (const og of collapseInfo.originalGroups) {
-      if (!parsed.groups.some((g) => g.label === og.label)) {
-        missingGroups.add(og.label);
-      }
-    }
-    for (const label of missingGroups) {
-      const og = collapseInfo.originalGroups.find((g) => g.label === label);
-      const parentLabel = og?.parentGroup;
-      if (!parentLabel || !missingGroups.has(parentLabel)) {
-        collapsedGroupLabels.add(label);
-      }
-    }
-  }
-  const nodeSizes = /* @__PURE__ */ new Map();
-  let maxDescHeight = 0;
-  for (const node of parsed.nodes) {
-    const size = hideDescriptions ? { width: NODE_WIDTH, height: NODE_HEIGHT } : computeNodeSize(node, parsed.showValues === true);
-    nodeSizes.set(node.label, size);
-    if (!hideDescriptions && node.description && node.description.length > 0) {
-      maxDescHeight = Math.max(maxDescHeight, size.height);
-    }
-  }
-  if (maxDescHeight > 0) {
-    for (const node of parsed.nodes) {
-      if (node.description && node.description.length > 0) {
-        const size = nodeSizes.get(node.label);
-        nodeSizes.set(node.label, { width: size.width, height: maxDescHeight });
-      }
-    }
-  }
-  const expandedGroupSet = new Set(parsed.groups.map((g) => g.label));
-  const gid = (label) => `__group_${label}`;
-  function buildGraph() {
-    const nodeById = /* @__PURE__ */ new Map();
-    const parentOf = /* @__PURE__ */ new Map();
-    for (const node of parsed.nodes) {
-      const size = nodeSizes.get(node.label);
-      nodeById.set(node.label, {
-        id: node.label,
-        width: size.width,
-        height: size.height,
-        labels: [{ text: node.label }]
-      });
-    }
-    for (const group of parsed.groups) {
-      nodeById.set(gid(group.label), {
-        id: gid(group.label),
-        labels: [{ text: group.label }],
-        layoutOptions: {
-          "elk.padding": `[top=${CONTAINER_PAD_TOP2},left=${CONTAINER_PAD_X3},bottom=${CONTAINER_PAD_BOTTOM3},right=${CONTAINER_PAD_X3}]`,
-          // Suggest square-ish containers — has limited effect with
-          // INCLUDE_CHILDREN but doesn't hurt.
-          "elk.aspectRatio": "1.4"
-        },
-        children: [],
-        edges: []
-      });
-    }
-    for (const label of collapsedGroupLabels) {
-      nodeById.set(gid(label), {
-        id: gid(label),
-        width: NODE_WIDTH,
-        height: NODE_HEIGHT,
-        labels: [{ text: label }]
-      });
-    }
-    for (const group of parsed.groups) {
-      if (group.parentGroup && nodeById.has(gid(group.parentGroup))) {
-        parentOf.set(gid(group.label), gid(group.parentGroup));
-      }
-    }
-    if (collapseInfo) {
-      for (const label of collapsedGroupLabels) {
-        const og = collapseInfo.originalGroups.find((g) => g.label === label);
-        if (og?.parentGroup && !collapsedGroupLabels.has(og.parentGroup) && nodeById.has(gid(og.parentGroup))) {
-          parentOf.set(gid(label), gid(og.parentGroup));
-        }
-      }
-    }
-    for (const group of parsed.groups) {
-      for (const child of group.children) {
-        if (expandedGroupSet.has(child)) continue;
-        if (nodeById.has(child)) {
-          parentOf.set(child, gid(group.label));
-        }
-      }
-    }
-    const roots = [];
-    for (const [id, node] of nodeById) {
-      const parentId = parentOf.get(id);
-      if (parentId) {
-        const parent = nodeById.get(parentId);
-        parent.children = parent.children ?? [];
-        parent.children.push(node);
-      } else {
-        roots.push(node);
-      }
-    }
-    const rootEdges = [];
-    for (let i = 0; i < parsed.edges.length; i++) {
-      const edge = parsed.edges[i];
-      if (!nodeById.has(edge.source) || !nodeById.has(edge.target)) continue;
-      rootEdges.push({
-        id: `e${i}`,
-        sources: [edge.source],
-        targets: [edge.target]
-      });
-    }
-    return { roots, rootEdges };
-  }
-  async function runVariant(variant) {
-    const { roots, rootEdges } = buildGraph();
-    const elkRoot = {
-      id: "root",
-      layoutOptions: {
-        ...variant.options,
-        "elk.direction": direction,
-        "elk.padding": `[top=${MARGIN3},left=${MARGIN3},bottom=${MARGIN3},right=${MARGIN3}]`
-      },
-      children: roots,
-      edges: rootEdges
-    };
-    const result = await getElk().layout(elkRoot);
-    return extractLayout(result);
-  }
-  function extractLayout(result) {
-    const layoutNodes = [];
-    const layoutGroups = [];
-    const allEdges = [];
-    const containerAbs = /* @__PURE__ */ new Map();
-    function walk(n, offsetX, offsetY, isRoot) {
-      const nx = (n.x ?? 0) + offsetX;
-      const ny = (n.y ?? 0) + offsetY;
-      const nw = n.width ?? 0;
-      const nh = n.height ?? 0;
-      if (isRoot) {
-        containerAbs.set("root", { x: nx, y: ny });
-      } else {
-        const isGroup = n.id.startsWith("__group_");
-        if (isGroup) {
-          const label = n.id.slice("__group_".length);
-          const collapsed = collapsedGroupLabels.has(label);
-          const og = collapseInfo?.originalGroups.find(
-            (g) => g.label === label
-          );
-          const pg = parsed.groups.find((g) => g.label === label);
-          const childCount = collapsed ? collapseInfo?.collapsedChildCounts.get(label) ?? 0 : void 0;
-          layoutGroups.push({
-            label,
-            lineNumber: pg?.lineNumber ?? og?.lineNumber ?? 0,
-            x: nx + nw / 2,
-            y: ny + nh / 2,
-            width: nw,
-            height: nh,
-            collapsed,
-            ...childCount !== void 0 && { childCount }
-          });
-          if (!collapsed) containerAbs.set(n.id, { x: nx, y: ny });
-        } else {
-          layoutNodes.push({
-            label: n.id,
-            x: nx + nw / 2,
-            y: ny + nh / 2,
-            width: nw,
-            height: nh
-          });
-        }
-      }
-      if (n.edges) for (const e of n.edges) allEdges.push(e);
-      if (n.children) for (const c of n.children) walk(c, nx, ny, false);
-    }
-    walk(result, 0, 0, true);
-    const edgeYOffsets = new Array(parsed.edges.length).fill(0);
-    const edgeParallelCounts = new Array(parsed.edges.length).fill(1);
-    const parallelGroups = /* @__PURE__ */ new Map();
-    for (let i = 0; i < parsed.edges.length; i++) {
-      const edge = parsed.edges[i];
-      const [a, b] = edge.source < edge.target ? [edge.source, edge.target] : [edge.target, edge.source];
-      const key = `${a}\0${b}`;
-      if (!parallelGroups.has(key)) parallelGroups.set(key, []);
-      parallelGroups.get(key).push(i);
-    }
-    for (const group of parallelGroups.values()) {
-      const capped = group.slice(0, MAX_PARALLEL_EDGES);
-      for (const idx of group.slice(MAX_PARALLEL_EDGES)) {
-        edgeParallelCounts[idx] = 0;
-      }
-      if (capped.length < 2) continue;
-      for (let j = 0; j < capped.length; j++) {
-        const cappedJ = capped[j];
-        edgeYOffsets[cappedJ] = (j - (capped.length - 1) / 2) * PARALLEL_SPACING;
-        edgeParallelCounts[cappedJ] = capped.length;
-      }
-    }
-    const edgeById = /* @__PURE__ */ new Map();
-    for (const e of allEdges) edgeById.set(e.id, e);
-    const layoutEdges = [];
-    for (let i = 0; i < parsed.edges.length; i++) {
-      const edge = parsed.edges[i];
-      if (edgeParallelCounts[i] === 0) continue;
-      const elkEdge = edgeById.get(`e${i}`);
-      if (!elkEdge?.sections || elkEdge.sections.length === 0) continue;
-      const container = elkEdge.container ?? "root";
-      const off = containerAbs.get(container) ?? { x: 0, y: 0 };
-      const s = elkEdge.sections[0];
-      const points = [
-        { x: s.startPoint.x + off.x, y: s.startPoint.y + off.y },
-        ...(s.bendPoints ?? []).map((p) => ({
-          x: p.x + off.x,
-          y: p.y + off.y
-        })),
-        { x: s.endPoint.x + off.x, y: s.endPoint.y + off.y }
-      ];
-      let labelX;
-      let labelY;
-      if (edge.label && points.length >= 2) {
-        const mid = Math.floor(points.length / 2);
-        const midPoint = points[mid];
-        labelX = midPoint.x;
-        labelY = midPoint.y - 10;
-      }
-      layoutEdges.push({
-        source: edge.source,
-        target: edge.target,
-        ...edge.label !== void 0 && { label: edge.label },
-        bidirectional: edge.bidirectional,
-        lineNumber: edge.lineNumber,
-        points,
-        ...labelX !== void 0 && { labelX },
-        ...labelY !== void 0 && { labelY },
-        // In-bounds — i < parsed.edges.length, arrays sized to that length.
-        yOffset: edgeYOffsets[i],
-        parallelCount: edgeParallelCounts[i],
-        metadata: edge.metadata,
-        deferred: true
-      });
-    }
-    let maxX = 0;
-    let maxY = 0;
-    for (const node of layoutNodes) {
-      maxX = Math.max(maxX, node.x + node.width / 2);
-      maxY = Math.max(maxY, node.y + node.height / 2);
-    }
-    for (const group of layoutGroups) {
-      maxX = Math.max(maxX, group.x + group.width / 2);
-      maxY = Math.max(maxY, group.y + group.height / 2);
+  const { layoutBoxesAndLinesSearch: layoutBoxesAndLinesSearch2 } = await Promise.resolve().then(() => (init_layout_search(), layout_search_exports));
+  const searched = layoutBoxesAndLinesSearch2(parsed, collapseInfo, {
+    ...layoutOptions?.hideDescriptions !== void 0 && {
+      hideDescriptions: layoutOptions.hideDescriptions
+    },
+    ...layoutOptions?.previousPositions !== void 0 && {
+      previousPositions: layoutOptions.previousPositions
     }
-    return {
-      nodes: layoutNodes,
-      edges: layoutEdges,
-      groups: layoutGroups,
-      width: maxX + MARGIN3,
-      height: maxY + MARGIN3
-    };
-  }
-  const N = parsed.nodes.length + parsed.groups.length;
-  const E = parsed.edges.length;
-  const trivial = N < 8 && E < 10;
-  const variants = trivial ? [getVariants()[1]] : getVariants();
-  const results = await Promise.all(variants.map((v) => runVariant(v)));
-  let best = results[0];
-  let bestScore = scoreLayout(best);
-  for (let i = 1; i < results.length; i++) {
-    const resultI = results[i];
-    const s = scoreLayout(resultI);
-    if (cmpScore(s, bestScore) < 0) {
-      best = resultI;
-      bestScore = s;
-    }
-  }
-  return attachNotes(best, parsed, layoutOptions?.collapsedNotes);
+  });
+  return attachNotes(
+    applyParallelEdgeOffsets(searched),
+    parsed,
+    layoutOptions?.collapsedNotes
+  );
 }
 function attachNotes(layout, parsed, collapsedNotes) {
   const notesSuppressed = parsed.options?.["no-notes"] === "on";
@@ -28246,20 +29182,47 @@ function attachNotes(layout, parsed, collapsedNotes) {
     nodes: finalNodes,
     edges: finalEdges,
     groups: finalGroups,
-    width: bbMaxX + shiftX + MARGIN3,
-    height: bbMaxY + shiftY + MARGIN3
+    width: bbMaxX + shiftX + MARGIN4,
+    height: bbMaxY + shiftY + MARGIN4
+  };
+}
+function applyParallelEdgeOffsets(layout) {
+  const groups = /* @__PURE__ */ new Map();
+  layout.edges.forEach((e, i) => {
+    const [a, b] = e.source < e.target ? [e.source, e.target] : [e.target, e.source];
+    const key = `${a}\0${b}`;
+    const arr = groups.get(key);
+    if (arr) arr.push(i);
+    else groups.set(key, [i]);
+  });
+  if ([...groups.values()].every((g) => g.length < 2)) return layout;
+  const yOffset = new Array(layout.edges.length).fill(0);
+  const count = new Array(layout.edges.length).fill(1);
+  for (const idxs of groups.values()) {
+    const capped = idxs.slice(0, MAX_PARALLEL_EDGES);
+    for (const drop of idxs.slice(MAX_PARALLEL_EDGES)) count[drop] = 0;
+    if (capped.length < 2) continue;
+    capped.forEach((idx, j) => {
+      yOffset[idx] = (j - (capped.length - 1) / 2) * PARALLEL_SPACING;
+      count[idx] = capped.length;
+    });
+  }
+  return {
+    ...layout,
+    edges: layout.edges.map((e, i) => ({
+      ...e,
+      yOffset: yOffset[i],
+      parallelCount: count[i]
+    }))
   };
 }
-var MARGIN3, CONTAINER_PAD_X3, CONTAINER_PAD_TOP2, CONTAINER_PAD_BOTTOM3, MAX_PARALLEL_EDGES, PARALLEL_SPACING, PHI, NODE_HEIGHT, NODE_WIDTH, DESC_NODE_WIDTH, DESC_FONT_SIZE2, DESC_LINE_HEIGHT2, DESC_PADDING, SEPARATOR_GAP5, MAX_DESC_LINES2, MAX_LABEL_LINES, LABEL_LINE_HEIGHT, LABEL_PAD, VALUE_ROW_FONT, VALUE_ROW_H, elkInstance, CROSSINGS_FORGIVENESS;
+var MARGIN4, MAX_PARALLEL_EDGES, PARALLEL_SPACING, PHI, NODE_HEIGHT, NODE_WIDTH, DESC_NODE_WIDTH, DESC_FONT_SIZE2, DESC_LINE_HEIGHT2, DESC_PADDING, SEPARATOR_GAP5, MAX_DESC_LINES2, MAX_LABEL_LINES, LABEL_LINE_HEIGHT, LABEL_PAD, VALUE_ROW_FONT, VALUE_ROW_H;
 var init_layout5 = __esm({
   "src/boxes-and-lines/layout.ts"() {
     "use strict";
     init_text_measure();
     init_notes();
-    MARGIN3 = 40;
-    CONTAINER_PAD_X3 = 30;
-    CONTAINER_PAD_TOP2 = 40;
-    CONTAINER_PAD_BOTTOM3 = 24;
+    MARGIN4 = 40;
     MAX_PARALLEL_EDGES = 5;
     PARALLEL_SPACING = 22;
     PHI = 1.618;
@@ -28276,8 +29239,6 @@ var init_layout5 = __esm({
     LABEL_PAD = 12;
     VALUE_ROW_FONT = 11;
     VALUE_ROW_H = SEPARATOR_GAP5 + VALUE_ROW_FONT * DESC_LINE_HEIGHT2 + DESC_PADDING;
-    elkInstance = null;
-    CROSSINGS_FORGIVENESS = 1;
   }
 });
 
@@ -28432,7 +29393,7 @@ function layoutMindmap(parsed, _palette, options) {
     leafWidth: ctx.structural(LEAF_WIDTH),
     hGap: ctx.aesthetic(H_GAP2),
     vGap: ctx.aesthetic(V_GAP2),
-    margin: ctx.aesthetic(MARGIN4),
+    margin: ctx.aesthetic(MARGIN5),
     multiRootGap: ctx.aesthetic(MULTI_ROOT_GAP)
   };
   populateDepthCache(roots);
@@ -28810,7 +29771,7 @@ function populateDepthCache(roots) {
   };
   walk(roots, 0);
 }
-var ROOT_WIDTH, DEPTH1_WIDTH, LEAF_WIDTH, SINGLE_LABEL_HEIGHT, LABEL_LINE_HEIGHT2, DESC_LINE_HEIGHT3, NODE_V_PAD, H_GAP2, V_GAP2, MARGIN4, MULTI_ROOT_GAP, nodeDepthCache;
+var ROOT_WIDTH, DEPTH1_WIDTH, LEAF_WIDTH, SINGLE_LABEL_HEIGHT, LABEL_LINE_HEIGHT2, DESC_LINE_HEIGHT3, NODE_V_PAD, H_GAP2, V_GAP2, MARGIN5, MULTI_ROOT_GAP, nodeDepthCache;
 var init_layout6 = __esm({
   "src/mindmap/layout.ts"() {
     "use strict";
@@ -28826,7 +29787,7 @@ var init_layout6 = __esm({
     NODE_V_PAD = 10;
     H_GAP2 = 40;
     V_GAP2 = 12;
-    MARGIN4 = 40;
+    MARGIN5 = 40;
     MULTI_ROOT_GAP = 60;
     nodeDepthCache = /* @__PURE__ */ new Map();
   }
@@ -30101,7 +31062,7 @@ __export(layout_exports8, {
   layoutC4Deployment: () => layoutC4Deployment,
   rollUpContextRelationships: () => rollUpContextRelationships
 });
-import dagre4 from "@dagrejs/dagre";
+import dagre5 from "@dagrejs/dagre";
 function computeEdgePenalty(edgeList, nodePositions, degrees, nodeGeometry) {
   let penalty = 0;
   for (const edge of edgeList) {
@@ -30526,7 +31487,7 @@ function layoutC4Context(parsed, activeTagGroup) {
   }
   const contextRels = rollUpContextRelationships(parsed);
   const spacing = computeAdaptiveSpacing(contextRels);
-  const g = new dagre4.graphlib.Graph();
+  const g = new dagre5.graphlib.Graph();
   g.setGraph({
     rankdir: "TB",
     nodesep: spacing.nodesep,
@@ -30547,7 +31508,7 @@ function layoutC4Context(parsed, activeTagGroup) {
       g.setEdge(rel.sourceName, rel.targetName, { label: rel.label ?? "" });
     }
   }
-  dagre4.layout(g);
+  dagre5.layout(g);
   reduceCrossings(
     g,
     validRels.map((r) => ({ source: r.sourceName, target: r.targetName }))
@@ -30614,8 +31575,8 @@ function layoutC4Context(parsed, activeTagGroup) {
     }
   }
   if (nodes.length > 0) {
-    const shiftX = MARGIN5 - minX;
-    const shiftY = MARGIN5 - minY;
+    const shiftX = MARGIN6 - minX;
+    const shiftY = MARGIN6 - minY;
     for (const node of nodes) {
       node.x += shiftX;
       node.y += shiftY;
@@ -30627,12 +31588,12 @@ function layoutC4Context(parsed, activeTagGroup) {
       }
     }
   }
-  let totalWidth = nodes.length > 0 ? maxX - minX + MARGIN5 * 2 : 0;
-  let totalHeight = nodes.length > 0 ? maxY - minY + MARGIN5 * 2 : 0;
+  let totalWidth = nodes.length > 0 ? maxX - minX + MARGIN6 * 2 : 0;
+  let totalHeight = nodes.length > 0 ? maxY - minY + MARGIN6 * 2 : 0;
   const legendGroups = computeLegendGroups3(parsed.tagGroups);
   if (legendGroups.length > 0) {
-    const legendY = totalHeight + MARGIN5;
-    let legendX = MARGIN5;
+    const legendY = totalHeight + MARGIN6;
+    let legendX = MARGIN6;
     for (const lg of legendGroups) {
       lg.x = legendX;
       lg.y = legendY;
@@ -30725,7 +31686,7 @@ function layoutC4Containers(parsed, systemName, activeTagGroup) {
     }
   }
   const hasGroups = elementToGroup.size > 0;
-  const g = hasGroups ? new dagre4.graphlib.Graph({ compound: true }) : new dagre4.graphlib.Graph();
+  const g = hasGroups ? new dagre5.graphlib.Graph({ compound: true }) : new dagre5.graphlib.Graph();
   g.setDefaultEdgeLabel(() => ({}));
   if (hasGroups) {
     const seenGroups = /* @__PURE__ */ new Set();
@@ -30803,7 +31764,7 @@ function layoutC4Containers(parsed, systemName, activeTagGroup) {
       g.setEdge(rel.sourceName, rel.targetName, { label: rel.label ?? "" });
     }
   }
-  dagre4.layout(g);
+  dagre5.layout(g);
   const nodeGroupMap = hasGroups ? new Map([...elementToGroup.entries()].map(([k, v]) => [k, v.name])) : void 0;
   reduceCrossings(
     g,
@@ -30964,8 +31925,8 @@ function layoutC4Containers(parsed, systemName, activeTagGroup) {
       if (pt.y > maxY) maxY = pt.y;
     }
   }
-  const shiftX = MARGIN5 - minX;
-  const shiftY = MARGIN5 - minY;
+  const shiftX = MARGIN6 - minX;
+  const shiftY = MARGIN6 - minY;
   for (const node of nodes) {
     node.x += shiftX;
     node.y += shiftY;
@@ -30982,12 +31943,12 @@ function layoutC4Containers(parsed, systemName, activeTagGroup) {
       pt.y += shiftY;
     }
   }
-  let totalWidth = maxX - minX + MARGIN5 * 2;
-  let totalHeight = maxY - minY + MARGIN5 * 2;
+  let totalWidth = maxX - minX + MARGIN6 * 2;
+  let totalHeight = maxY - minY + MARGIN6 * 2;
   const legendGroups = computeLegendGroups3(parsed.tagGroups);
   if (legendGroups.length > 0) {
-    const legendY = totalHeight + MARGIN5;
-    let legendX = MARGIN5;
+    const legendY = totalHeight + MARGIN6;
+    let legendX = MARGIN6;
     for (const lg of legendGroups) {
       lg.x = legendX;
       lg.y = legendY;
@@ -31132,7 +32093,7 @@ function layoutC4Components(parsed, systemName, containerName, activeTagGroup) {
     }
   }
   const hasGroups = elementToGroup.size > 0;
-  const g = hasGroups ? new dagre4.graphlib.Graph({ compound: true }) : new dagre4.graphlib.Graph();
+  const g = hasGroups ? new dagre5.graphlib.Graph({ compound: true }) : new dagre5.graphlib.Graph();
   g.setDefaultEdgeLabel(() => ({}));
   if (hasGroups) {
     const seenGroups = /* @__PURE__ */ new Set();
@@ -31216,7 +32177,7 @@ function layoutC4Components(parsed, systemName, containerName, activeTagGroup) {
       g.setEdge(rel.sourceName, rel.targetName, { label: rel.label ?? "" });
     }
   }
-  dagre4.layout(g);
+  dagre5.layout(g);
   const nodeGroupMap = hasGroups ? new Map([...elementToGroup.entries()].map(([k, v]) => [k, v.name])) : void 0;
   reduceCrossings(
     g,
@@ -31379,8 +32340,8 @@ function layoutC4Components(parsed, systemName, containerName, activeTagGroup) {
       if (pt.y > maxY) maxY = pt.y;
     }
   }
-  const shiftX = MARGIN5 - minX;
-  const shiftY = MARGIN5 - minY;
+  const shiftX = MARGIN6 - minX;
+  const shiftY = MARGIN6 - minY;
   for (const node of nodes) {
     node.x += shiftX;
     node.y += shiftY;
@@ -31397,12 +32358,12 @@ function layoutC4Components(parsed, systemName, containerName, activeTagGroup) {
       pt.y += shiftY;
     }
   }
-  let totalWidth = maxX - minX + MARGIN5 * 2;
-  let totalHeight = maxY - minY + MARGIN5 * 2;
+  let totalWidth = maxX - minX + MARGIN6 * 2;
+  let totalHeight = maxY - minY + MARGIN6 * 2;
   const legendGroups = computeLegendGroups3(parsed.tagGroups);
   if (legendGroups.length > 0) {
-    const legendY = totalHeight + MARGIN5;
-    let legendX = MARGIN5;
+    const legendY = totalHeight + MARGIN6;
+    let legendX = MARGIN6;
     for (const lg of legendGroups) {
       lg.x = legendX;
       lg.y = legendY;
@@ -31508,7 +32469,7 @@ function layoutC4Deployment(parsed, activeTagGroup) {
   for (const r of refEntries) {
     nameToElement.set(r.element.name, r.element);
   }
-  const g = new dagre4.graphlib.Graph({ compound: true });
+  const g = new dagre5.graphlib.Graph({ compound: true });
   g.setDefaultEdgeLabel(() => ({}));
   for (const [infraId] of infraIds) {
     g.setNode(infraId, {});
@@ -31552,7 +32513,7 @@ function layoutC4Deployment(parsed, activeTagGroup) {
       g.setEdge(rel.sourceName, rel.targetName, { label: rel.label ?? "" });
     }
   }
-  dagre4.layout(g);
+  dagre5.layout(g);
   const nodeInfraMap = /* @__PURE__ */ new Map();
   for (const r of refEntries) nodeInfraMap.set(r.element.name, r.infraId);
   reduceCrossings(
@@ -31690,8 +32651,8 @@ function layoutC4Deployment(parsed, activeTagGroup) {
       if (pt.y > maxY) maxY = pt.y;
     }
   }
-  const shiftX = MARGIN5 - minX;
-  const shiftY = MARGIN5 - minY;
+  const shiftX = MARGIN6 - minX;
+  const shiftY = MARGIN6 - minY;
   for (const node of nodes) {
     node.x += shiftX;
     node.y += shiftY;
@@ -31706,12 +32667,12 @@ function layoutC4Deployment(parsed, activeTagGroup) {
       pt.y += shiftY;
     }
   }
-  let totalWidth = maxX - minX + MARGIN5 * 2;
-  let totalHeight = maxY - minY + MARGIN5 * 2;
+  let totalWidth = maxX - minX + MARGIN6 * 2;
+  let totalHeight = maxY - minY + MARGIN6 * 2;
   const legendGroups = computeLegendGroups3(parsed.tagGroups);
   if (legendGroups.length > 0) {
-    const legendY = totalHeight + MARGIN5;
-    let legendX = MARGIN5;
+    const legendY = totalHeight + MARGIN6;
+    let legendX = MARGIN6;
     for (const lg of legendGroups) {
       lg.x = legendX;
       lg.y = legendY;
@@ -31731,7 +32692,7 @@ function layoutC4Deployment(parsed, activeTagGroup) {
     height: totalHeight
   };
 }
-var gNode, gEdge, MIN_NODE_WIDTH, MAX_NODE_WIDTH, TYPE_LABEL_HEIGHT, DIVIDER_GAP, NAME_HEIGHT, NAME_FONT_SIZE, DESC_LINE_HEIGHT5, DESC_FONT_SIZE4, CARD_V_PAD3, CARD_H_PAD3, META_LINE_HEIGHT5, META_FONT_SIZE5, MARGIN5, BOUNDARY_PAD, GROUP_BOUNDARY_PAD, EDGE_NODE_COLLISION_WEIGHT, META_EXCLUDE_KEYS;
+var gNode, gEdge, MIN_NODE_WIDTH, MAX_NODE_WIDTH, TYPE_LABEL_HEIGHT, DIVIDER_GAP, NAME_HEIGHT, NAME_FONT_SIZE, DESC_LINE_HEIGHT5, DESC_FONT_SIZE4, CARD_V_PAD3, CARD_H_PAD3, META_LINE_HEIGHT5, META_FONT_SIZE5, MARGIN6, BOUNDARY_PAD, GROUP_BOUNDARY_PAD, EDGE_NODE_COLLISION_WEIGHT, META_EXCLUDE_KEYS;
 var init_layout8 = __esm({
   "src/c4/layout.ts"() {
     "use strict";
@@ -31751,7 +32712,7 @@ var init_layout8 = __esm({
     CARD_H_PAD3 = 20;
     META_LINE_HEIGHT5 = 16;
     META_FONT_SIZE5 = 11;
-    MARGIN5 = 40;
+    MARGIN6 = 40;
     BOUNDARY_PAD = 40;
     GROUP_BOUNDARY_PAD = 24;
     EDGE_NODE_COLLISION_WEIGHT = 5e3;
@@ -32786,7 +33747,7 @@ var layout_exports9 = {};
 __export(layout_exports9, {
   layoutGraph: () => layoutGraph
 });
-import dagre5 from "@dagrejs/dagre";
+import dagre6 from "@dagrejs/dagre";
 function computeNodeWidth(label, shape) {
   if (shape === "pseudostate") return 24;
   const base = Math.max(120, label.length * 9 + 40);
@@ -32820,7 +33781,7 @@ function layoutGraph(graph, options) {
   if (allNodes.length === 0) {
     return { nodes: [], edges: [], groups: [], width: 0, height: 0 };
   }
-  const g = new dagre5.graphlib.Graph({ compound: true });
+  const g = new dagre6.graphlib.Graph({ compound: true });
   g.setGraph({
     rankdir: graph.direction,
     nodesep: 50,
@@ -32871,7 +33832,7 @@ function layoutGraph(graph, options) {
       label: edge.label ?? ""
     });
   }
-  dagre5.layout(g);
+  dagre6.layout(g);
   const collapsedGroupIds = collapsedChildCounts ? new Set(collapsedChildCounts.keys()) : /* @__PURE__ */ new Set();
   const basePositioned = allNodes.map((node) => {
     const pos = g.node(node.id);
@@ -34575,7 +35536,7 @@ __export(layout_exports10, {
   layoutInfra: () => layoutInfra,
   separateGroups: () => separateGroups
 });
-import dagre6 from "@dagrejs/dagre";
+import dagre7 from "@dagrejs/dagre";
 function countDisplayProps(node, expanded, options) {
   if (!expanded) return 0;
   let count = node.properties.filter((p) => DISPLAY_KEYS.has(p.key)).length;
@@ -34877,7 +35838,7 @@ function layoutInfra(computed, expandedNodeIds, collapsedNodes) {
     };
   }
   const isLR = computed.direction !== "TB";
-  const g = new dagre6.graphlib.Graph();
+  const g = new dagre7.graphlib.Graph();
   g.setGraph({
     rankdir: computed.direction === "TB" ? "TB" : "LR",
     nodesep: isLR ? 70 : 60,
@@ -34928,7 +35889,7 @@ function layoutInfra(computed, expandedNodeIds, collapsedNodes) {
       g.setEdge(edge.sourceId, edge.targetId, { label: edge.label });
     }
   }
-  dagre6.layout(g);
+  dagre7.layout(g);
   const layoutNodes = computed.nodes.map(
     (node) => {
       const pos = g.node(node.id);
@@ -36670,17 +37631,17 @@ function mulberry32(seed) {
     return ((t ^ t >>> 14) >>> 0) / 4294967296;
   };
 }
-function standardNormal(rng) {
+function standardNormal(rng3) {
   let u = 0;
   let v = 0;
-  while (u === 0) u = rng();
-  while (v === 0) v = rng();
+  while (u === 0) u = rng3();
+  while (v === 0) v = rng3();
   return Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
 }
-function gamma(shape, rng) {
+function gamma(shape, rng3) {
   if (shape < 1) {
-    const u = rng();
-    return gamma(shape + 1, rng) * Math.pow(u, 1 / shape);
+    const u = rng3();
+    return gamma(shape + 1, rng3) * Math.pow(u, 1 / shape);
   }
   const d = shape - 1 / 3;
   const c = 1 / Math.sqrt(9 * d);
@@ -36688,29 +37649,29 @@ function gamma(shape, rng) {
     let x;
     let v;
     do {
-      x = standardNormal(rng);
+      x = standardNormal(rng3);
       v = 1 + c * x;
     } while (v <= 0);
     v = v * v * v;
-    const u = rng();
+    const u = rng3();
     if (u < 1 - 0.0331 * x * x * x * x) return d * v;
     if (Math.log(u) < x * x / 2 + d * (1 - v + Math.log(v))) return d * v;
   }
 }
-function sampleBeta(alpha, beta, rng) {
-  const x = gamma(alpha, rng);
-  const y = gamma(beta, rng);
+function sampleBeta(alpha, beta, rng3) {
+  const x = gamma(alpha, rng3);
+  const y = gamma(beta, rng3);
   return x / (x + y);
 }
-function sampleBetaPert(o, m, p, rng) {
+function sampleBetaPert(o, m, p, rng3) {
   if (o === p) return m;
   const range = p - o;
   const alpha = 1 + 4 * (m - o) / range;
   const beta = 1 + 4 * (p - m) / range;
-  return o + sampleBeta(alpha, beta, rng) * range;
+  return o + sampleBeta(alpha, beta, rng3) * range;
 }
 function simulate(resolved, expanded, _predecessors, _successors, topo, terminals, poisoned, opts) {
-  const rng = mulberry32(opts.seed);
+  const rng3 = mulberry32(opts.seed);
   const expById = /* @__PURE__ */ new Map();
   for (const e of expanded) expById.set(e.id, e);
   const completionTimes = new Array(opts.trials);
@@ -36733,7 +37694,7 @@ function simulate(resolved, expanded, _predecessors, _successors, topo, terminal
       } else if (exp.o === exp.p) {
         duration = exp.m;
       } else {
-        duration = sampleBetaPert(exp.o, exp.m, exp.p, rng);
+        duration = sampleBetaPert(exp.o, exp.m, exp.p, rng3);
       }
       let esLower = 0;
       let efLower = -Infinity;
@@ -37725,7 +38686,7 @@ __export(layout_exports11, {
   layoutPert: () => layoutPert,
   relayoutPert: () => relayoutPert
 });
-import dagre7 from "@dagrejs/dagre";
+import dagre8 from "@dagrejs/dagre";
 function computeNodeSizing(resolved) {
   const unit = resolved.options.timeUnit;
   const sprintMode = resolved.options.sprintMode;
@@ -37843,7 +38804,7 @@ function relayoutPert(resolved, overrides, collapsedGroupIds = /* @__PURE__ */ n
     }
   }
   const dagreId = (id) => memberToGroup.get(id) ?? id;
-  const g = new dagre7.graphlib.Graph();
+  const g = new dagre8.graphlib.Graph();
   g.setGraph({
     rankdir: resolved.options.direction,
     nodesep: 50,
@@ -37882,7 +38843,7 @@ function relayoutPert(resolved, overrides, collapsedGroupIds = /* @__PURE__ */ n
     seenEdges.add(k);
     g.setEdge(src, tgt, {});
   }
-  dagre7.layout(g);
+  dagre8.layout(g);
   const swimApplied = applySwimLanes(
     g,
     resolved,
@@ -38228,7 +39189,7 @@ function reduceCrossings2(g, direction) {
     buckets.get(key).push(id);
   }
   const edges = g.edges().map((e) => ({ v: e.v, w: e.w }));
-  const countCrossings2 = () => {
+  const countCrossings = () => {
     let total = 0;
     for (let i = 0; i < edges.length; i++) {
       const a = edges[i];
@@ -38241,13 +39202,13 @@ function reduceCrossings2(g, direction) {
         const b1 = g.node(b.v);
         const b2 = g.node(b.w);
         if (!b1 || !b2) continue;
-        if (segmentsCross2(a1, a2, b1, b2)) total++;
+        if (segmentsCross(a1, a2, b1, b2)) total++;
       }
     }
     return total;
   };
   const MAX_ITER = 8;
-  let baseline = countCrossings2();
+  let baseline = countCrossings();
   if (baseline === 0) return;
   for (let iter = 0; iter < MAX_ITER; iter++) {
     let improved = false;
@@ -38265,7 +39226,7 @@ function reduceCrossings2(g, direction) {
         const bv = bn[slotAxis];
         an[slotAxis] = bv;
         bn[slotAxis] = av;
-        const after = countCrossings2();
+        const after = countCrossings();
         if (after < baseline) {
           baseline = after;
           improved = true;
@@ -38286,7 +39247,7 @@ function reduceCrossings2(g, direction) {
     data.points = smoothEdge(src, tgt, direction);
   }
 }
-function segmentsCross2(a1, a2, b1, b2) {
+function segmentsCross(a1, a2, b1, b2) {
   const ccw = (p, q, r) => (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
   const d1 = ccw(b1, b2, a1);
   const d2 = ccw(b1, b2, a2);
@@ -48047,10 +49008,10 @@ function tierBand(maxSpanDeg) {
 }
 function labelBudget(width, height, band) {
   const bandCap = {
-    world: 6,
-    continental: 5,
-    regional: 4,
-    local: 3
+    world: 7,
+    continental: 6,
+    regional: 5,
+    local: 4
   };
   const area2 = Math.floor(Math.sqrt(Math.max(0, width * height)) / 150);
   return Math.max(0, Math.min(area2, bandCap[band]));
@@ -48183,8 +49144,11 @@ function placeContextLabels(args) {
       color: waterColor,
       fontSize: FONT,
       // water names keep the base font (no footprint to scale on)
-      // Water before any country (×1000), then by tier, then kind, then name.
-      sort: tier * 10 + KIND_ORDER[kind]
+      // Orientation-value bands (lower = earlier): MAJOR water (oceans + major
+      // seas, tier ≤ 1) leads at `tier*10+kind` (0..~16); MINOR water (tier ≥ 2:
+      // smaller seas, bays, gulfs, straits) drops to band 2 (2000+) — BELOW the
+      // country band (1000+), so a big country outranks a minor basin.
+      sort: (tier <= 1 ? 0 : 2e3) + tier * 10 + KIND_ORDER[kind]
     });
   }
   const ranked = countries.map((c) => {
@@ -48197,7 +49161,7 @@ function placeContextLabels(args) {
   let ci = 0;
   for (const r of ranked) {
     const { c, w, h, area: area2 } = r;
-    if (w > width * 0.66 || h > height * 0.66) continue;
+    if (!c.curatedAnchor && w > width * 0.66 && h > height * 0.66) continue;
     if (!insideViewport(c.anchor, width, height)) continue;
     const sizeFrac = Math.sqrt(area2) / canvasLinear;
     const t = Math.min(
@@ -48222,15 +49186,23 @@ function placeContextLabels(args) {
       letterSpacing: 0,
       color,
       fontSize,
-      // Always after every water body (+1e6); larger area = earlier.
-      sort: 1e6 + ci++
+      // Band 1 (orientation-value ranking): above MINOR water (band 2, 2000+) but
+      // below MAJOR water — oceans + major seas (band 0, ≤~16). So a big country
+      // (US, Canada, Russia) outranks a minor sea/bay (Sargasso, Bahía de
+      // Campeche) yet never displaces an ocean. Larger area = earlier within the
+      // band (`ci` is the area-desc rank index).
+      sort: 1e3 + ci++
     });
   }
   candidates.sort((a, b) => a.sort - b.sort);
   const placed = [];
   const placedRects = [];
+  const countryCount = candidates.reduce((n, c) => n + (c.italic ? 0 : 1), 0);
+  const waterCap = budget - Math.min(2, countryCount);
+  let waterPlaced = 0;
   for (const cand of candidates) {
     if (placed.length >= budget) break;
+    if (cand.italic && waterPlaced >= waterCap) continue;
     const rect = rectAround(
       cand.cx,
       cand.cy,
@@ -48257,6 +49229,7 @@ function placeContextLabels(args) {
     if (collides(rect)) continue;
     if (placedRects.some((r) => overlapsPadded(rect, r, CONTEXT_PAD))) continue;
     placedRects.push(rect);
+    if (cand.italic) waterPlaced++;
     placed.push({
       x: cand.cx,
       y: cand.cy,
@@ -50230,16 +51203,16 @@ function layoutMap(resolved, data, size, opts) {
       countryCandidates.push({
         name: f.properties?.name ?? iso,
         bbox: [x0, y0, x1, y1],
-        anchor: a && Number.isFinite(a[0]) ? [a[0], a[1]] : null
+        anchor: a && Number.isFinite(a[0]) ? [a[0], a[1]] : null,
+        curatedAnchor: !!anchorLngLat
       });
     }
     const framedStateContainers = (resolved.poiFrameContainers ?? []).some(
       (id) => id.startsWith("US-")
     );
     if (usLayer && framedStateContainers) {
-      const containerSet = new Set(resolved.poiFrameContainers);
       for (const [iso, f] of usLayer) {
-        if (containerSet.has(iso) || regionById.has(iso)) continue;
+        if (regionById.has(iso)) continue;
         const viewF = cullFeatureToView(f);
         if (!viewF) continue;
         const b = path.bounds(viewF);
@@ -50367,8 +51340,15 @@ var init_layout15 = __esm({
     W_MAX = 8;
     FONT2 = 11;
     WORLD_LABEL_ANCHORS = {
-      US: [-98.5, 39.5]
+      US: [-98.5, 39.5],
       // CONUS geographic centre (near Lebanon, Kansas)
+      // Russia crosses the antimeridian (Chukotka at ~170°W), so on a non-global
+      // (e.g. Europe) projection its geometry smears across the whole frame and the
+      // area-weighted centroid lands mid-map (over Europe) — useless as a label
+      // anchor. Pin it to European Russia (~Volga) so a Europe view labels visible
+      // western Russia on its eastern margin; on a world view this still sits over
+      // Russian land. (See the curated-anchor smear-gate bypass in context-labels.)
+      RU: [45, 58]
     };
     MAX_CLUSTER_EXTENT_FACTOR = 0.18;
     MAX_COLUMN_ROWS = 7;