@knowvah/dot-engine 0.1.0

package/src/layout/dot/position-cluster.ts

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Cluster containment and separation constraints for the dot position phase.
+ * @see lib/dotgen/position.c:contain_nodes, contain_clustnodes,
+ *      keepout_othernodes, contain_subclust, separate_subclust, pos_clusters
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import { VIRTUAL, NORMAL, virtualNode, findFastEdge } from './fastgr.js';
+import { agContainsNode } from './mincross-utils.js';
+import { dotRoot, rankGet } from './mincross-utils.js';
+import { SLACKNODE } from './rank.js';
+import {
+  BOTTOM_IX, RIGHT_IX, TOP_IX, LEFT_IX,
+  makeAuxEdge, clusterMarginOf,
+  nodeRw, nodeLw, nodeOrder,
+} from './position-aux.js';
+
+// ---------------------------------------------------------------------------
+// Accessor helpers
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function graphMargin(g: Graph): number {
+  return g.info.clusterMargin ?? clusterMarginOf(g);
+}
+
+/** @internal */
+export function graphMinrank(g: Graph): number { return g.info.minrank ?? 0; }
+
+/** @internal */
+export function graphMaxrank(g: Graph): number { return g.info.maxrank ?? 0; }
+
+/** @internal */
+export function borderLeft(g: Graph): number {
+  return g.info.border?.[LEFT_IX].x ?? 0;
+}
+
+/** @internal */
+export function borderRight(g: Graph): number {
+  return g.info.border?.[RIGHT_IX].x ?? 0;
+}
+
+/** @internal */
+export function borderBottom(g: Graph): number {
+  return g.info.border?.[BOTTOM_IX].x ?? 0;
+}
+
+/** @internal */
+export function borderTop(g: Graph): number {
+  return g.info.border?.[TOP_IX].x ?? 0;
+}
+
+// ---------------------------------------------------------------------------
+// make_lrvn — @see lib/dotgen/position.c:make_lrvn
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:make_lrvn */
+export function makeLrvn(g: Graph): void {
+  if (g.info.ln) return;
+  const root = dotRoot(g);
+  const ln = virtualNode(root);
+  ln.info.node_type = SLACKNODE;
+  const rn = virtualNode(root);
+  rn.info.node_type = SLACKNODE;
+  if (g.info.label && g !== root && !(root.info.flip)) {
+    const w = Math.max(borderBottom(g), borderTop(g));
+    makeAuxEdge(ln, rn, w, 0);
+  }
+  g.info.ln = ln;
+  g.info.rn = rn;
+}
+
+// ---------------------------------------------------------------------------
+// contain_nodes — @see lib/dotgen/position.c:contain_nodes
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:contain_nodes (per-rank) */
+export function containNodesRank(g: Graph, r: number, ln: Node, rn: Node): void {
+  const rk = g.info.rank![r];
+  if (rk.n === 0) return;
+  // C's GD_rank(clust)[i].v is the offset window pointer (merge_ranks aliases
+  // it to GD_rank(root)[i].v + ipos), so v[0]/v[n-1] are cluster-local. TS keeps
+  // .v as the full root array plus a separate vStart, so cluster members must be
+  // read via rankGet (= rk.v[vStart+i]); a raw rk.v[0] reads the root's leftmost
+  // node, not the cluster's. Same vStart-window bug class as mincross Layers 1-2.
+  const first = rankGet(rk, 0);
+  if (!first) return;
+  const margin = graphMargin(g);
+  makeAuxEdge(ln, first, nodeLw(first) + margin + borderLeft(g), 0);
+  const last = rankGet(rk, rk.n - 1);
+  makeAuxEdge(last, rn, nodeRw(last) + margin + borderRight(g), 0);
+}
+
+/** @see lib/dotgen/position.c:contain_nodes */
+export function containNodes(g: Graph): void {
+  makeLrvn(g);
+  const ln = g.info.ln!;
+  const rn = g.info.rn!;
+  for (let r = graphMinrank(g); r <= graphMaxrank(g); r++) {
+    containNodesRank(g, r, ln, rn);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// contain_clustnodes — @see lib/dotgen/position.c:contain_clustnodes
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:contain_clustnodes */
+export function containClustnodes(g: Graph): void {
+  if (g !== dotRoot(g)) {
+    containNodes(g);
+    const ln = g.info.ln!;
+    const rn = g.info.rn!;
+    const ex = findFastEdge(ln, rn);
+    if (ex !== undefined) {
+      ex.info.weight = (ex.info.weight ?? 0) + 128;
+    } else {
+      makeAuxEdge(ln, rn, 1, 128);
+    }
+  }
+  const nClust = g.info.n_cluster ?? 0;
+  for (let c = 1; c <= nClust; c++) containClustnodes(g.info.clust![c - 1]);
+}
+
+// ---------------------------------------------------------------------------
+// vnode_not_related_to — @see lib/dotgen/position.c:vnode_not_related_to
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:vnode_not_related_to */
+export function vnodeNotRelatedTo(g: Graph, v: Node): boolean {
+  if (v.info.node_type !== VIRTUAL) return false;
+  let e = v.info.save_out?.list[0];
+  while (e?.info.to_orig) e = e.info.to_orig;
+  if (!e) return false;
+  if (agContainsNode(g, e.tail)) return false;
+  if (agContainsNode(g, e.head)) return false;
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// keepout_othernodes — @see lib/dotgen/position.c:keepout_othernodes
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:keepout_othernodes (left-side scan for one rank) */
+export function keepoutLeft(root: Graph, g: Graph, r: number, margin: number): void {
+  // v = GD_rank(g)[r].v[0] is the cluster's leftmost node. g.info.rank[r].v is
+  // the shared root array offset by vStart, so read v0 via rankGet — a raw .v[0]
+  // returns the root's leftmost node (order≈0), collapsing the order-1..0 scan to
+  // nothing and dropping every left-keepout edge (same vStart-window class as
+  // containNodesRank). @see lib/dotgen/position.c:keepout_othernodes
+  const v0 = rankGet(g.info.rank![r], 0);
+  if (!v0) return;
+  for (let i = nodeOrder(v0) - 1; i >= 0; i--) {
+    const u = root.info.rank![r].v[i];
+    if (u.info.node_type === NORMAL || vnodeNotRelatedTo(g, u)) {
+      makeAuxEdge(u, g.info.ln!, margin + nodeRw(u), 0);
+      break;
+    }
+  }
+}
+
+/** @see lib/dotgen/position.c:keepout_othernodes (right-side scan for one rank) */
+export function keepoutRight(root: Graph, g: Graph, r: number, margin: number): void {
+  const rk = g.info.rank![r];
+  if (rk.n === 0) return;
+  // Cluster-local leftmost via rankGet, not raw rk.v[0] (the root's leftmost) —
+  // see keepoutLeft. @see lib/dotgen/position.c:keepout_othernodes
+  const v0 = rankGet(rk, 0);
+  if (!v0) return;
+  const rootRk = root.info.rank![r];
+  for (let i = nodeOrder(v0) + rk.n; i < rootRk.n; i++) {
+    const u = rootRk.v[i];
+    if (u.info.node_type === NORMAL || vnodeNotRelatedTo(g, u)) {
+      makeAuxEdge(g.info.rn!, u, margin + nodeLw(u), 0);
+      break;
+    }
+  }
+}
+
+/** @see lib/dotgen/position.c:keepout_othernodes */
+export function keepoutOthernodes(g: Graph): void {
+  const root = dotRoot(g);
+  const margin = graphMargin(g);
+  for (let r = graphMinrank(g); r <= graphMaxrank(g); r++) {
+    if ((g.info.rank![r].n ?? 0) === 0) continue;
+    keepoutLeft(root, g, r, margin);
+    keepoutRight(root, g, r, margin);
+  }
+  const nClust = g.info.n_cluster ?? 0;
+  for (let c = 1; c <= nClust; c++) keepoutOthernodes(g.info.clust![c - 1]);
+}
+
+// ---------------------------------------------------------------------------
+// contain_subclust — @see lib/dotgen/position.c:contain_subclust
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:contain_subclust */
+export function containSubclust(g: Graph): void {
+  const margin = graphMargin(g);
+  makeLrvn(g);
+  const nClust = g.info.n_cluster ?? 0;
+  for (let c = 1; c <= nClust; c++) {
+    const subg = g.info.clust![c - 1];
+    makeLrvn(subg);
+    makeAuxEdge(g.info.ln!, subg.info.ln!, margin + borderLeft(g), 0);
+    makeAuxEdge(subg.info.rn!, g.info.rn!, margin + borderRight(g), 0);
+    containSubclust(subg);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// separate_subclust — @see lib/dotgen/position.c:separate_subclust
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:separate_subclust (check overlap and assign left/right) */
+export function separateClustPair(low: Graph, high: Graph, margin: number): void {
+  if (graphMaxrank(low) < graphMinrank(high)) return;
+  const pivotRank = graphMinrank(high);
+  // C reads GD_rank(low/high)[minrank(high)].v[0] — each cluster's OWN rank
+  // array, i.e. its leftmost node. The port shares the root rank array with a
+  // vStart window, so a raw .v[0] returns the root's leftmost node (order 0) for
+  // BOTH clusters → orders compare equal → left/right is assigned arbitrarily.
+  // That happens to match the layout for rankdir=TB but contradicts it under
+  // flip (LR/RL), so the separation edge points the wrong way and the clusters
+  // collapse together. Read the cluster-local leftmost via rankGet (same
+  // vStart-window class as containNodesRank/keepoutLeft).
+  const lowV0 = rankGet(low.info.rank![pivotRank], 0);
+  const highV0 = rankGet(high.info.rank![pivotRank], 0);
+  if (!lowV0 || !highV0) return;
+  const left = nodeOrder(lowV0) < nodeOrder(highV0) ? low : high;
+  const right = left === low ? high : low;
+  // C: make_aux_edge(GD_rn(left), GD_ln(right), margin, 0) — left's RIGHT border
+  // sits `margin` to the left of right's LEFT border. The port had these args
+  // swapped (right.rn, left.ln); with the old raw-.v[0] bug left/right were
+  // arbitrary, so the two errors cancelled for rankdir=TB but compounded under
+  // flip. @see lib/dotgen/position.c:480
+  makeAuxEdge(left.info.rn!, right.info.ln!, margin, 0);
+}
+
+/** @see lib/dotgen/position.c:separate_subclust */
+export function separateSubclust(g: Graph): void {
+  const nClust = g.info.n_cluster ?? 0;
+  const margin = graphMargin(g);
+  for (let i = 1; i <= nClust; i++) makeLrvn(g.info.clust![i - 1]);
+  for (let i = 1; i <= nClust; i++) {
+    for (let j = i + 1; j <= nClust; j++) {
+      let low = g.info.clust![i - 1];
+      let high = g.info.clust![j - 1];
+      if (graphMinrank(low) > graphMinrank(high)) {
+        const tmp = low; low = high; high = tmp;
+      }
+      separateClustPair(low, high, margin);
+    }
+    separateSubclust(g.info.clust![i - 1]);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// pos_clusters — @see lib/dotgen/position.c:pos_clusters
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:pos_clusters */
+export function posClusters(g: Graph): void {
+  if ((g.info.n_cluster ?? 0) === 0) return;
+  containClustnodes(g);
+  keepoutOthernodes(g);
+  containSubclust(g);
+  separateSubclust(g);
+}
+
+// ---------------------------------------------------------------------------
+// compress_graph — @see lib/dotgen/position.c:compress_graph
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:compress_graph */
+export function compressGraph(g: Graph): void {
+  if (g.info.drawing?.ratioKind !== 'compress') return;
+  const p = g.info.drawing.size;
+  if (!p || p.x * p.y <= 1) return;
+  containNodes(g);
+  const x = Math.min(g.info.flip ? p.y : p.x, 65535);
+  makeAuxEdge(g.info.ln!, g.info.rn!, x, 1000);
+}

package/src/layout/dot/position-ycoords.ts

@@ -0,0 +1,287 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Y-coordinate assignment, cluster height computation, and rank adjustment
+ * for the dot position phase.
+ * @see lib/dotgen/position.c:set_ycoords, clust_ht, adjustRanks, adjustSimple
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import { dotRoot } from './mincross-utils.js';
+import {
+  CL_OFFSET, BOTTOM_IX, RIGHT_IX, TOP_IX, LEFT_IX,
+  clusterMarginOf,
+  graphMinrank, graphMaxrank, graphNclust,
+  graphHt1, graphHt2, graphRanksep, nodeRank,
+} from './position-aux.js';
+
+// ---------------------------------------------------------------------------
+// Accessor helpers
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function graphMarginY(g: Graph): number {
+  return g.info.clusterMargin ?? clusterMarginOf(g);
+}
+
+// ---------------------------------------------------------------------------
+// clustHt helpers — @see lib/dotgen/position.c:clust_ht
+// ---------------------------------------------------------------------------
+
+/** @internal — largest self-edge label half-height for a node */
+export function selfEdgeLabelHt(n: Node): number {
+  const other = n.info.other;
+  if (!other) return 0;
+  let maxHt = 0;
+  for (let j = 0; j < other.size; j++) {
+    const e = other.list[j];
+    if (e.tail === e.head && e.info.label) {
+      const lbl = e.info.label as { dimen?: { y: number } };
+      maxHt = Math.max(maxHt, (lbl.dimen?.y ?? 0) / 2);
+    }
+  }
+  return maxHt;
+}
+
+/** @see lib/dotgen/position.c:clust_ht (single node scan, returns ht2) */
+export function clustHtScanNode(g: Graph, n: Node, r: number): number {
+  const ht2 = Math.max((n.info.ht ?? 0) / 2, selfEdgeLabelHt(n));
+  const rk = g.info.rank![r];
+  if (rk.pht2 < ht2) { rk.pht2 = ht2; rk.ht2 = ht2; }
+  if (rk.pht1 < ht2) { rk.pht1 = ht2; rk.ht1 = ht2; }
+  return ht2;
+}
+
+/** @see lib/dotgen/position.c:clust_ht (update nearest enclosing cluster ht) */
+export function updateClustNodeHt(g: Graph, n: Node, ht2: number): void {
+  const clust = n.info.clust;
+  if (!clust) return;
+  const margin = clust === g ? 0 : graphMarginY(clust);
+  const r = nodeRank(n);
+  if (r === graphMinrank(clust)) clust.info.ht2 = Math.max(clust.info.ht2 ?? 0, ht2 + margin);
+  if (r === graphMaxrank(clust)) clust.info.ht1 = Math.max(clust.info.ht1 ?? 0, ht2 + margin);
+}
+
+/** @see lib/dotgen/position.c:clust_ht (per-rank node scan) */
+export function clustHtRankScan(g: Graph): void {
+  const rankArr = g.info.rank!;
+  for (let r = graphMinrank(g); r <= graphMaxrank(g); r++) {
+    const rk = rankArr[r];
+    for (let i = 0; i < rk.n; i++) {
+      const n = rk.v[i];
+      const ht2 = clustHtScanNode(g, n, r);
+      updateClustNodeHt(g, n, ht2);
+    }
+  }
+}
+
+/** @see lib/dotgen/position.c:clust_ht (sub-cluster ht accumulation) */
+export function clustHtSubclusters(
+  g: Graph,
+  margin: number,
+  ht1In: number,
+  ht2In: number,
+): [number, number, boolean] {
+  let ht1 = ht1In;
+  let ht2 = ht2In;
+  let haveLabel = false;
+  const nClust = graphNclust(g);
+  for (let c = 1; c <= nClust; c++) {
+    const subg = g.info.clust![c - 1];
+    haveLabel = clustHt(subg) || haveLabel;
+    if (graphMaxrank(subg) === graphMaxrank(g)) ht1 = Math.max(ht1, graphHt1(subg) + margin);
+    if (graphMinrank(subg) === graphMinrank(g)) ht2 = Math.max(ht2, graphHt2(subg) + margin);
+  }
+  return [ht1, ht2, haveLabel];
+}
+
+/** @see lib/dotgen/position.c:clust_ht (label height adjustment) */
+export function clustHtLabel(g: Graph, ht1In: number, ht2In: number): [number, number, boolean] {
+  const root = dotRoot(g);
+  if (g === root || !g.info.label) return [ht1In, ht2In, false];
+  if (root.info.flip) return [ht1In, ht2In, true];
+  const ht1 = ht1In + (g.info.border?.[BOTTOM_IX].y ?? 0);
+  const ht2 = ht2In + (g.info.border?.[TOP_IX].y ?? 0);
+  return [ht1, ht2, true];
+}
+
+/** @see lib/dotgen/position.c:clust_ht */
+export function clustHt(g: Graph): boolean {
+  const root = dotRoot(g);
+  const isRoot = g === root;
+  const margin = isRoot ? CL_OFFSET : graphMarginY(g);
+  let ht1 = graphHt1(g);
+  let ht2 = graphHt2(g);
+  let haveLabel: boolean;
+  [ht1, ht2, haveLabel] = clustHtSubclusters(g, margin, ht1, ht2);
+  let lblMark: boolean;
+  [ht1, ht2, lblMark] = clustHtLabel(g, ht1, ht2);
+  haveLabel = haveLabel || lblMark;
+  g.info.ht1 = ht1;
+  g.info.ht2 = ht2;
+  if (!isRoot) {
+    const rankArr = root.info.rank!;
+    rankArr[graphMinrank(g)].ht2 = Math.max(rankArr[graphMinrank(g)].ht2, ht2);
+    rankArr[graphMaxrank(g)].ht1 = Math.max(rankArr[graphMaxrank(g)].ht1, ht1);
+  }
+  return haveLabel;
+}
+
+// ---------------------------------------------------------------------------
+// set_ycoords — @see lib/dotgen/position.c:set_ycoords
+// ---------------------------------------------------------------------------
+
+/** @internal — recompute maxht after adjustRanks (exact_ranksep path) */
+export function recomputeMaxht(g: Graph): number {
+  const rankArr = g.info.rank!;
+  const maxR = graphMaxrank(g);
+  let maxht = 0;
+  let d0 = rankArr[maxR].v[0].info.coord.y;
+  for (let r = maxR - 1; r >= graphMinrank(g); r--) {
+    const d1 = rankArr[r].v[0].info.coord.y;
+    maxht = Math.max(maxht, d1 - d0);
+    d0 = d1;
+  }
+  return maxht;
+}
+
+/** @internal — re-assign y if ranks are equally spaced */
+export function equalSpaceRanks(g: Graph, maxht: number): void {
+  const rankArr = g.info.rank!;
+  for (let r = graphMaxrank(g) - 1; r >= graphMinrank(g); r--) {
+    if (rankArr[r].n > 0) {
+      rankArr[r].v[0].info.coord.y = rankArr[r + 1].v[0].info.coord.y + maxht;
+    }
+  }
+}
+
+/** @see lib/dotgen/position.c:set_ycoords (initial y assignment loop) */
+export function setYcoordsInitial(g: Graph, lbl: boolean): void {
+  const rankArr = g.info.rank!;
+  const maxR = graphMaxrank(g);
+  // Anchor the bottom rank at rank[maxr].ht1 — NOT the root GD_ht1. clust_ht may
+  // expand root GD_ht1 beyond rank[maxr].ht1 by a cluster's CL_OFFSET margin, but
+  // C keeps the anchor at the bare rank ht1 (position.c:777) and lets the bb LL.y
+  // go negative (= margin below the bottom node, position.c:872); a final
+  // translate normalizes to origin. Seeding from GD_ht1 instead pre-baked that
+  // shift into the coords, which for a degenerate bb (no translate) left every
+  // node shifted up by the margin (2825 — see plans/layout-bugs/).
+  // @see lib/dotgen/position.c:set_ycoords (777)
+  rankArr[maxR].v[0].info.coord.y = rankArr[maxR].ht1;
+  let maxht = 0;
+  for (let r = maxR - 1; r >= graphMinrank(g); r--) {
+    const d0 = rankArr[r + 1].pht2 + rankArr[r].pht1 + graphRanksep(g);
+    const d1 = rankArr[r + 1].ht2 + rankArr[r].ht1 + CL_OFFSET;
+    const delta = Math.max(d0, d1);
+    if (rankArr[r].n > 0) {
+      rankArr[r].v[0].info.coord.y = rankArr[r + 1].v[0].info.coord.y + delta;
+    }
+    maxht = Math.max(maxht, delta);
+  }
+  if (lbl && g.info.flip) {
+    adjustRanks(g, 0);
+    if (g.info.exact_ranksep) maxht = recomputeMaxht(g);
+  }
+  if (g.info.exact_ranksep) equalSpaceRanks(g, maxht);
+}
+
+/** @see lib/dotgen/position.c:set_ycoords (copy y from rank leader to all nodes) */
+export function setYcoordsCopy(g: Graph): void {
+  const rankArr = g.info.rank!;
+  for (let n = g.info.nlist; n !== undefined; n = n.info.next) {
+    n.info.coord.y = rankArr[nodeRank(n)].v[0].info.coord.y;
+  }
+}
+
+/** @see lib/dotgen/position.c:set_ycoords */
+export function setYcoords(g: Graph): void {
+  clustHtRankScan(g);
+  const lbl = clustHt(g);
+  setYcoordsInitial(g, lbl);
+  setYcoordsCopy(g);
+}
+
+// ---------------------------------------------------------------------------
+// adjustSimple / adjustRanks — @see lib/dotgen/position.c
+// ---------------------------------------------------------------------------
+
+/** @internal — shift ranks above minr by deltop */
+export function shiftRanksAbove(root: Graph, minr: number, deltop: number): void {
+  const rankArr = root.info.rank!;
+  for (let r = minr - 1; r >= graphMinrank(root); r--) {
+    if (rankArr[r].n > 0) rankArr[r].v[0].info.coord.y += deltop;
+  }
+}
+
+/** @see lib/dotgen/position.c:adjustSimple */
+export function adjustSimple(g: Graph, delta: number, marginTotal: number): void {
+  const root = dotRoot(g);
+  const rankArr = root.info.rank!;
+  const maxr = graphMaxrank(g);
+  const minr = graphMinrank(g);
+  const bottom = (delta + 1) / 2;
+  const delbottom = graphHt1(g) + bottom - (rankArr[maxr].ht1 - marginTotal);
+  if (delbottom > 0) {
+    for (let r = maxr; r >= minr; r--) {
+      if (rankArr[r].n > 0) rankArr[r].v[0].info.coord.y += delbottom;
+    }
+    const deltop = graphHt2(g) + (delta - bottom) + delbottom - (rankArr[minr].ht2 - marginTotal);
+    if (deltop > 0) shiftRanksAbove(root, minr, deltop);
+  } else {
+    const deltop = graphHt2(g) + (delta - bottom) - (rankArr[minr].ht2 - marginTotal);
+    if (deltop > 0) shiftRanksAbove(root, minr, deltop);
+  }
+  g.info.ht2 = graphHt2(g) + delta - bottom;
+  g.info.ht1 = graphHt1(g) + bottom;
+}
+
+/** @see lib/dotgen/position.c:adjustRanks (label height delta application) */
+export function adjustRanksLabel(g: Graph, root: Graph, marginTotal: number): void {
+  // C's adjustRanks does NOT gate on flip here — it reads GD_border[LEFT/RIGHT]
+  // unconditionally (the outer `lbl && GD_flip` guard in set_ycoords already
+  // ensures a flipped drawing). The border is set to LEFT/RIGHT by
+  // applyLabelBorder using the ROOT's flip; a cluster subgraph's own info.flip
+  // is not propagated (undefined), so gating on it here skipped the cluster
+  // label rank-reservation entirely — 2239's cluster_dtlsdec1 (a PEM-cert label,
+  // border[R].y=4507) reserved 0 room instead of ~2210, halving the LR width.
+  // A non-flip cluster has border[LEFT/RIGHT]=0, so `if (!lht) return` covers it.
+  // @see lib/dotgen/position.c:adjustRanks (label branch)
+  const lht = Math.max(g.info.border?.[LEFT_IX].y ?? 0, g.info.border?.[RIGHT_IX].y ?? 0);
+  if (!lht) return;
+  const rankArr = root.info.rank!;
+  const rht = rankArr[graphMinrank(g)].v[0].info.coord.y - rankArr[graphMaxrank(g)].v[0].info.coord.y;
+  const delta = lht - (rht + graphHt1(g) + graphHt2(g));
+  if (delta > 0) adjustSimple(g, delta, marginTotal);
+}
+
+/** @see lib/dotgen/position.c:adjustRanks */
+export function adjustRanks(g: Graph, marginTotal: number): void {
+  const root = dotRoot(g);
+  const isRoot = g === root;
+  const margin = isRoot ? 0 : graphMarginY(g);
+  let ht1 = graphHt1(g);
+  let ht2 = graphHt2(g);
+  const nClust = graphNclust(g);
+  for (let c = 1; c <= nClust; c++) {
+    const subg = g.info.clust![c - 1];
+    adjustRanks(subg, margin + marginTotal);
+    if (graphMaxrank(subg) === graphMaxrank(g)) ht1 = Math.max(ht1, graphHt1(subg) + margin);
+    if (graphMinrank(subg) === graphMinrank(g)) ht2 = Math.max(ht2, graphHt2(subg) + margin);
+  }
+  g.info.ht1 = ht1;
+  g.info.ht2 = ht2;
+  if (!isRoot && g.info.label) adjustRanksLabel(g, root, marginTotal);
+  if (!isRoot) {
+    // Read GD_ht1(g)/GD_ht2(g) (g.info.*), NOT the local ht1/ht2 snapshot:
+    // adjustRanksLabel -> adjustSimple (above) grows g.info.ht1/ht2 to include
+    // the cluster label reservation, and C's global-rank update reads those
+    // mutated values. Using the pre-label local snapshot leaves the maxrank
+    // ht1 too small, so maximal_bbox builds a thin tail box and multi-rank
+    // edges crossing the reserved gap route straight instead of bowing over
+    // the label. @see lib/dotgen/position.c:adjustRanks (rank[].ht update)
+    const rankArr = root.info.rank!;
+    rankArr[graphMinrank(g)].ht2 = Math.max(rankArr[graphMinrank(g)].ht2, graphHt2(g));
+    rankArr[graphMaxrank(g)].ht1 = Math.max(rankArr[graphMaxrank(g)].ht1, graphHt1(g));
+  }
+}