@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,382 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Auxiliary edge construction and removal for the dot position phase.
+ * @see lib/dotgen/position.c
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import { Node as NodeClass } from '../../model/node.js';
+import { Edge as EdgeClass } from '../../model/edge.js';
+import { fastEdge, findFastEdge } from './fastgr.js';
+import { SLACKNODE, EDGE_LABEL } from './rank.js';
+import { selfRightSpace } from '../../common/splines-selfedge.js';
+import { lateInt } from '../../common/nodeinit.js';
+import { cround } from '../../common/arith.js';
+
+/** @see lib/common/const.h:CL_OFFSET */
+export const CL_OFFSET = 8;
+
+/**
+ * Cluster margin = `late_int(g, G_margin, CL_OFFSET, 0)`. The `margin` attribute
+ * is resolved up the subgraph chain (matching `agxget` inheritance), so a
+ * cluster with no own `margin` inherits an ancestor's; absent everywhere it
+ * falls back to `CL_OFFSET`, and negatives clamp to 0. Used for both the
+ * x-coordinate (`make_lrvn`/`make_lrconstraints`/separate clusters) and the
+ * rank/y-coordinate (`set_ycoords`) cluster spacing.
+ * @see lib/dotgen/position.c:397,436,460,642
+ */
+export function clusterMarginOf(g: Graph): number {
+  let raw: string | undefined;
+  for (let s: Graph | null = g; s !== null; s = s.parent) {
+    const v = s.attrs.get('margin');
+    if (v !== undefined) { raw = v; break; }
+  }
+  return lateInt(raw, CL_OFFSET, 0);
+}
+
+/** @see lib/common/const.h:BOTTOM_IX */
+export const BOTTOM_IX = 0;
+/** @see lib/common/const.h:RIGHT_IX */
+export const RIGHT_IX = 1;
+/** @see lib/common/const.h:TOP_IX */
+export const TOP_IX = 2;
+/** @see lib/common/const.h:LEFT_IX */
+export const LEFT_IX = 3;
+
+// ---------------------------------------------------------------------------
+// Accessor helpers — each ?? is its own CCN=2 function so callers stay ≤10
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function nodeRw(n: Node): number { return n.info.rw ?? 0; }
+
+/** @internal */
+export function nodeLw(n: Node): number { return n.info.lw ?? 0; }
+
+/** @internal */
+export function nodeOrder(n: Node): number { return n.info.order ?? 0; }
+
+/** @internal */
+export function nodeRank(n: Node): number { return n.info.rank ?? 0; }
+
+/** @internal */
+export function nodeUfSize(n: Node): number { return n.info.UF_size ?? 1; }
+
+/** @internal */
+export function edgeMinlen(e: Edge): number { return e.info.minlen ?? 1; }
+
+/** @internal */
+export function edgeWeight(e: Edge): number { return e.info.weight ?? 0; }
+
+/** @internal */
+export function edgeDist(e: Edge): number { return e.info.dist ?? 0; }
+
+/** @internal */
+export function graphNodesep(g: Graph): number { return g.info.nodesep ?? 0; }
+
+/** @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 graphNclust(g: Graph): number { return g.info.n_cluster ?? 0; }
+
+/** @internal */
+export function graphHt1(g: Graph): number { return g.info.ht1 ?? 0; }
+
+/** @internal */
+export function graphHt2(g: Graph): number { return g.info.ht2 ?? 0; }
+
+/** @internal */
+export function graphRanksep(g: Graph): number { return g.info.ranksep ?? 0; }
+
+// ---------------------------------------------------------------------------
+// make_aux_edge — @see lib/dotgen/position.c:make_aux_edge
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:make_aux_edge */
+export function makeAuxEdge(u: Node, v: Node, len: number, wt: number): Edge {
+  const e = new EdgeClass(u, v, '');
+  // C ROUND() is half away from zero. @see lib/dotgen/position.c:195
+  e.info.minlen = cround(Math.min(len, 2147483647));
+  e.info.weight = wt;
+  fastEdge(e);
+  return e;
+}
+
+// ---------------------------------------------------------------------------
+// allocate_aux_edges — @see lib/dotgen/position.c:allocate_aux_edges
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:allocate_aux_edges */
+export function allocateAuxEdges(g: Graph): void {
+  for (let n = g.info.nlist; n !== undefined; n = n.info.next) {
+    n.info.save_in = n.info.in;
+    n.info.save_out = n.info.out;
+    const ni = n.info.out?.size ?? 0;
+    const nj = n.info.in?.size ?? 0;
+    n.info.in = { list: new Array(ni + nj + 3), size: 0 };
+    n.info.out = { list: new Array(3), size: 0 };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// make_LR_constraints helpers
+// ---------------------------------------------------------------------------
+
+/** LR node separation for a rank (accounts for edge labels).
+ * C uses smaller separation (5) on odd ranks when the graph has edge labels
+ * (real nodes sit on even ranks 0,2,4…). `abomination` inserts a flat-label
+ * rank at -1 in C, but this 0-based port shifts every rank up by 1 instead
+ * (AD-2), inverting the parity; `abomShift` undoes that so the parity matches C.
+ *
+ * The EDGE_LABEL gate reads `g.root`, not `g`: C is `GD_has_labels(g->root)`.
+ * Under `pack` the layout graph is a component whose own has_labels is 0 (C
+ * scopes only `edgelabel_ranks`, rank.c:170, to the layout graph) while the true
+ * root carries the flag — so reading `g` here silently used the full nodesep on
+ * odd ranks instead of C's `sep[1] = 5`, widening every packed component that
+ * contains an edge label.
+ * @see lib/dotgen/position.c:make_LR_constraints (GD_has_labels(g->root)) */
+export function lrSep(g: Graph, rankIdx: number): number {
+  const nodesep = graphNodesep(g);
+  if (!((g.root.info.has_labels ?? 0) & EDGE_LABEL)) return nodesep;
+  return (rankIdx + (g.info.abomShift ?? 0)) & 1 ? 5 : nodesep;
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (single flat-edge constraint) */
+export function processFlatEdge(g: Graph, u: Node, e: Edge): void {
+  const nodesep = graphNodesep(g);
+  const isOrdered = nodeOrder(u) < nodeOrder(e.head);
+  const t0 = isOrdered ? e.tail : e.head;
+  const h0 = isOrdered ? e.head : e.tail;
+  const width = nodeRw(t0) + nodeLw(h0);
+  // C declares `int m0` in make_LR_constraints (position.c), and ED_minlen is
+  // also int, so every assignment of the double `…+ width` (width is fractional
+  // from node rw/lw) truncates toward zero. Keeping m0 a float let a fractional
+  // minlen (e.g. 180.4138 on the multiline-label Octagon/Parallelogram pair)
+  // reach the x-coord network simplex, producing a fractional x-coordinate and a
+  // sub-pixel shift exposed by set_aspect (pgram). @see position.c:make_LR_constraints
+  let m0 = Math.trunc(edgeMinlen(e) * nodesep + width);
+  const ex = findFastEdge(t0, h0);
+  if (ex !== undefined) {
+    // C ROUND(ED_dist(e)) — half away from zero. @see lib/dotgen/position.c:307
+    m0 = Math.trunc(Math.max(m0, width + nodesep + cround(edgeDist(e))));
+    ex.info.minlen = Math.max(ex.info.minlen ?? 1, m0);
+    ex.info.weight = Math.max(ex.info.weight ?? 0, edgeWeight(e));
+  } else if (!e.info.label) {
+    makeAuxEdge(t0, h0, m0, edgeWeight(e));
+  }
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (flat-edge endpoint loop) */
+export function makeFlatEdgeConstraints(g: Graph, u: Node): void {
+  const flatOut = u.info.flat_out;
+  if (!flatOut) return;
+  for (let k = 0; k < flatOut.size; k++) {
+    processFlatEdge(g, u, flatOut.list[k]);
+  }
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (flat-label constraint body) */
+export function applyFlatLabel(
+  g: Graph,
+  e: Edge,
+  e0raw: Edge,
+  e1raw: Edge,
+): void {
+  const nodesep = graphNodesep(g);
+  const e0 = nodeOrder(e0raw.head) <= nodeOrder(e1raw.head) ? e0raw : e1raw;
+  const e1 = e0 === e0raw ? e1raw : e0raw;
+  const m0 = edgeMinlen(e) * nodesep / 2;
+  const m1a = m0 + nodeRw(e0.head) + nodeLw(e0.tail);
+  if (!canReach(e0.tail, e0.head)) makeAuxEdge(e0.head, e0.tail, m1a, edgeWeight(e));
+  const m1b = m0 + nodeRw(e1.tail) + nodeLw(e1.head);
+  if (!canReach(e1.head, e1.tail)) makeAuxEdge(e1.tail, e1.head, m1b, edgeWeight(e));
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (flat-label constraints via ND_alg) */
+export function makeFlatLabelConstraints(g: Graph, u: Node): void {
+  const e = u.info.posAlg;
+  if (!e) return;
+  const so = u.info.save_out;
+  if (!so || so.size < 2) return;
+  applyFlatLabel(g, e, so.list[0], so.list[1]);
+}
+
+/** @see lib/dotgen/position.c:go */
+export function go(u: Node, v: Node): boolean {
+  if (u === v) return true;
+  const out = u.info.out;
+  if (!out) return false;
+  for (let i = 0; i < out.size; i++) {
+    if (go(out.list[i].head, v)) return true;
+  }
+  return false;
+}
+
+/** @see lib/dotgen/position.c:canreach */
+export function canReach(u: Node, v: Node): boolean {
+  return go(u, v);
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (self-edge width accumulation) */
+export function selfWidth(u: Node): number {
+  const other = u.info.other;
+  if (!other || other.size === 0) return 0;
+  let sw = 0;
+  for (let k = 0; k < other.size; k++) {
+    const e = other.list[k];
+    if (e.tail === e.head) sw += selfRightSpace(e);
+  }
+  return sw;
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (per-rank inner loop, one node pair) */
+export function lrRankPair(g: Graph, r: number, u: Node, v: Node, last: number): number {
+  const nodesep = lrSep(g, r);
+  const width = nodeRw(u) + nodeLw(v) + nodesep;
+  makeAuxEdge(u, v, width, 0);
+  /* C: `last = (ND_rank(v) = last + width)`. ND_rank is an int, so the
+   * double `last + width` truncates toward zero on assignment, and the
+   * truncated *integer* flows back into `last` — positions accumulate as
+   * integers. The port's info.rank is a float, so without this truncation the
+   * fractional node widths accumulate, perturbing the initial feasible ranks
+   * (slack/tight-edge detection) and selecting a different vertex of the
+   * x-coord NS optimal face (honda-tokoro weight=0 degeneracy).
+   * @see lib/dotgen/position.c:make_LR_constraints */
+  const next = Math.trunc(last + width);
+  v.info.rank = next;
+  return next;
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints (per-rank inner loop) */
+export function makeLrRankConstraints(g: Graph, r: number): void {
+  const rank = g.info.rank!;
+  const rk = rank[r];
+  let last = 0;
+  for (let j = 0; j < rk.n; j++) {
+    const u = rk.v[j];
+    u.info.mval = u.info.rw;
+    u.info.rw = nodeRw(u) + selfWidth(u);
+    if (rk.v[0]) u.info.rank = last;
+    const v = rk.v[j + 1];
+    if (v) last = lrRankPair(g, r, u, v, last);
+    makeFlatLabelConstraints(g, u);
+    makeFlatEdgeConstraints(g, u);
+  }
+  if (rk.n > 0) rk.v[0].info.rank = 0;
+}
+
+/** @see lib/dotgen/position.c:make_LR_constraints */
+export function makeLrConstraints(g: Graph): void {
+  for (let i = (g.info.minrank ?? 0); i <= (g.info.maxrank ?? 0); i++) {
+    makeLrRankConstraints(g, i);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// make_edge_pairs — @see lib/dotgen/position.c:make_edge_pairs
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:make_edge_pairs (per-edge) */
+export function addEdgePair(g: Graph, e: Edge): void {
+  const sn = makeSlackNode(g);
+  const hp = e.info.head_port.p;
+  const tp = e.info.tail_port.p;
+  // C: `int m0 = (ED_head_port(e).p.x - ED_tail_port(e).p.x)` truncates the
+  // fractional port offset toward zero BEFORE the +1 and the aux-edge minlen
+  // round (position.c:338). Keeping it as a float and letting makeAuxEdge round
+  // m0+1 inflates the tail/head separation by 1pt for any fractional port
+  // offset (e.g. a record field center), shifting the ported node's x by 1.
+  const d = Math.trunc(hp.x - tp.x);
+  const m0 = Math.max(0, d);
+  const m1 = Math.max(0, -d);
+  makeAuxEdge(sn, e.tail, m0 + 1, edgeWeight(e));
+  makeAuxEdge(sn, e.head, m1 + 1, edgeWeight(e));
+  sn.info.rank = Math.min(nodeRank(e.tail) - m0 - 1, nodeRank(e.head) - m1 - 1);
+}
+
+/** @see lib/dotgen/position.c:make_edge_pairs */
+export function makeEdgePairs(g: Graph): void {
+  for (let n = g.info.nlist; n !== undefined; n = n.info.next) {
+    const so = n.info.save_out;
+    if (!so) continue;
+    for (let i = 0; i < so.size; i++) {
+      addEdgePair(g, so.list[i]);
+    }
+  }
+}
+
+/** Create a SLACKNODE virtual node and prepend to nlist. */
+export function makeSlackNode(g: Graph): Node {
+  const sn = new NodeClass(0, '', g);
+  sn.info.node_type = SLACKNODE;
+  sn.info.in = { list: [], size: 0 };
+  sn.info.out = { list: [], size: 0 };
+  sn.info.next = g.info.nlist;
+  if (g.info.nlist !== undefined) g.info.nlist.info.prev = sn;
+  g.info.nlist = sn;
+  return sn;
+}
+
+// ---------------------------------------------------------------------------
+// create_aux_edges / remove_aux_edges
+// ---------------------------------------------------------------------------
+
+/** @see lib/dotgen/position.c:create_aux_edges */
+export function createAuxEdges(
+  g: Graph,
+  posClusters: (g: Graph) => void,
+  compressGraph: (g: Graph) => void,
+): void {
+  allocateAuxEdges(g);
+  makeLrConstraints(g);
+  makeEdgePairs(g);
+  posClusters(g);
+  compressGraph(g);
+}
+
+/** @see lib/dotgen/position.c:remove_aux_edges (SLACKNODE removal loop) */
+export function removeSlackNodes(g: Graph): void {
+  let nprev: Node | undefined;
+  let n = g.info.nlist;
+  while (n !== undefined) {
+    const nnext = n.info.next;
+    if ((n.info.node_type ?? 0) === SLACKNODE) {
+      if (nprev !== undefined) nprev.info.next = nnext;
+      else g.info.nlist = nnext;
+      if (nnext !== undefined) nnext.info.prev = nprev;
+    } else {
+      nprev = n;
+    }
+    n = nnext;
+  }
+}
+
+/** @see lib/dotgen/position.c:remove_aux_edges (per-node cleanup) */
+export function removeAuxEdgesNode(n: Node): void {
+  const out = n.info.out;
+  if (out) {
+    for (let i = 0; i < out.size; i++) {
+      out.list[i].info.weight = undefined;
+    }
+    out.list.length = 0; out.size = 0;
+  }
+  const inn = n.info.in;
+  if (inn) { inn.list.length = 0; inn.size = 0; }
+  n.info.out = n.info.save_out;
+  n.info.in = n.info.save_in;
+}
+
+/** @see lib/dotgen/position.c:remove_aux_edges */
+export function removeAuxEdges(g: Graph): void {
+  for (let n = g.info.nlist; n !== undefined; n = n.info.next) {
+    removeAuxEdgesNode(n);
+  }
+  removeSlackNodes(g);
+}

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

@@ -0,0 +1,221 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Bounding box computation, aspect ratio scaling, and set_aspect for dot.
+ * @see lib/dotgen/position.c:dot_compute_bb, rec_bb, scale_bb, set_aspect
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { TextlabelT } from '../../common/types.js';
+import { NORMAL } from './fastgr.js';
+import { dotRoot } from './mincross-utils.js';
+import { cround } from '../../common/arith.js';
+import {
+  CL_OFFSET,
+  TOP_IX, BOTTOM_IX, LEFT_IX, RIGHT_IX,
+  graphMinrank, graphMaxrank, graphNclust,
+  graphHt1, graphHt2, nodeRank,
+} from './position-aux.js';
+
+// ---------------------------------------------------------------------------
+// dot_compute_bb helpers — @see lib/dotgen/position.c:dot_compute_bb
+// ---------------------------------------------------------------------------
+
+/** @internal — first NORMAL node in rank, scanning left to right */
+export function firstNormalNode(rk: { v: Node[]; n: number }): Node | undefined {
+  for (let c = 0; c < rk.n; c++) {
+    if (rk.v[c].info.node_type === NORMAL) return rk.v[c];
+  }
+  return undefined;
+}
+
+/** @internal — last NORMAL node in rank, scanning right to left */
+export function lastNormalNode(rk: { v: Node[]; n: number }): Node | undefined {
+  for (let c = rk.n - 1; c >= 0; c--) {
+    if (rk.v[c].info.node_type === NORMAL) return rk.v[c];
+  }
+  return undefined;
+}
+
+/** @internal — find x range of NORMAL nodes in one rank */
+export function rankNormalXRange(rk: { v: Node[]; n: number }): [number, number] {
+  const first = firstNormalNode(rk);
+  if (!first) return [2147483647, -2147483647];
+  const lx = first.info.coord.x - (first.info.lw ?? 0);
+  const last = lastNormalNode(rk);
+  const rx = last ? last.info.coord.x + (last.info.rw ?? 0) : -2147483647;
+  return [lx, rx];
+}
+
+/** @see lib/dotgen/position.c:dot_compute_bb (root x-range scan) */
+export function computeBbRootX(g: Graph): [number, number] {
+  let llx = 2147483647;
+  let urx = -2147483647;
+  for (let r = graphMinrank(g); r <= graphMaxrank(g); r++) {
+    const rk = g.info.rank![r];
+    if (rk.n === 0) continue;
+    const [lx, rx] = rankNormalXRange(rk);
+    if (lx < llx) llx = lx;
+    if (rx > urx) urx = rx;
+  }
+  const nClust = graphNclust(g);
+  for (let c = 1; c <= nClust; c++) {
+    const bb = g.info.clust![c - 1].info.bb;
+    if (!bb) continue;
+    llx = Math.min(llx, bb.ll.x - CL_OFFSET);
+    urx = Math.max(urx, bb.ur.x + CL_OFFSET);
+  }
+  return [llx, urx];
+}
+
+/** @see lib/dotgen/position.c:dot_compute_bb */
+export function dotComputeBb(g: Graph, root: Graph): void {
+  const isRoot = g === root;
+  let llx: number;
+  let urx: number;
+  if (isRoot) {
+    [llx, urx] = computeBbRootX(g);
+  } else {
+    llx = nodeRank(g.info.ln!);
+    urx = nodeRank(g.info.rn!);
+  }
+  const rankArr = root.info.rank!;
+  const lly = rankArr[graphMaxrank(g)].v[0].info.coord.y - graphHt1(g);
+  const ury = rankArr[graphMinrank(g)].v[0].info.coord.y + graphHt2(g);
+  g.info.bb = { ll: { x: llx, y: lly }, ur: { x: urx, y: ury } };
+}
+
+/** @see lib/dotgen/position.c:rec_bb */
+export function recBb(g: Graph, root: Graph): void {
+  const nClust = graphNclust(g);
+  for (let c = 1; c <= nClust; c++) recBb(g.info.clust![c - 1], root);
+  dotComputeBb(g, root);
+}
+
+/** @see lib/dotgen/position.c:scale_bb */
+export function scaleBb(g: Graph, xf: number, yf: number): void {
+  const nClust = graphNclust(g);
+  for (let c = 1; c <= nClust; c++) scaleBb(g.info.clust![c - 1], xf, yf);
+  if (!g.info.bb) return;
+  g.info.bb.ll.x *= xf; g.info.bb.ll.y *= yf;
+  g.info.bb.ur.x *= xf; g.info.bb.ur.y *= yf;
+}
+
+// ---------------------------------------------------------------------------
+// set_aspect helpers — @see lib/dotgen/position.c:set_aspect
+// ---------------------------------------------------------------------------
+
+type SzPoint = { x: number; y: number };
+type DrawingPartial = { size: SzPoint; ratioKind: string; ratio?: number };
+
+/** @internal — fill ratio scale factors */
+export function aspectFillScale(d: DrawingPartial, sz: SzPoint): [number, number] | null {
+  if (d.size.x <= 0) return null;
+  let xf = d.size.x / sz.x;
+  let yf = d.size.y / sz.y;
+  if (xf < 1.0 || yf < 1.0) {
+    if (xf < yf) { yf /= xf; xf = 1.0; } else { xf /= yf; yf = 1.0; }
+  }
+  return [xf, yf];
+}
+
+/** @internal — expand ratio scale factors */
+export function aspectExpandScale(d: DrawingPartial, g: Graph): [number, number] | null {
+  if (d.size.x <= 0) return null;
+  const bb = g.info.bb!;
+  const xf = d.size.x / bb.ur.x;
+  const yf = d.size.y / bb.ur.y;
+  if (xf > 1.0 && yf > 1.0) { const s = Math.min(xf, yf); return [s, s]; }
+  return null;
+}
+
+/** @internal — fixed ratio scale factors */
+export function aspectValueScale(d: DrawingPartial, sz: SzPoint): [number, number] {
+  const desired = d.ratio ?? 1;
+  const actual = sz.y / sz.x;
+  if (actual < desired) return [1.0, desired / actual];
+  return [actual / desired, 1.0];
+}
+
+/** @see lib/dotgen/position.c:set_aspect (choose scale factors for ratio mode) */
+export function aspectScaleFactors(g: Graph, sz: SzPoint): [number, number] | null {
+  const d = g.info.drawing;
+  if (!d || !d.ratioKind || d.ratioKind === 'none') return null;
+  if (d.ratioKind === 'fill') return aspectFillScale(d, sz);
+  if (d.ratioKind === 'expand') return aspectExpandScale(d, g);
+  if (d.ratioKind === 'value') return aspectValueScale(d, sz);
+  return null;
+}
+
+/** @see lib/dotgen/position.c:set_aspect */
+export function setAspect(g: Graph): void {
+  recBb(g, g);
+  const drawing = g.info.drawing;
+  if (graphMaxrank(g) <= 0 || !drawing?.ratioKind) return;
+  const bb = g.info.bb!;
+  let sz: SzPoint = { x: bb.ur.x - bb.ll.x, y: bb.ur.y - bb.ll.y };
+  if (g.info.flip) sz = { x: sz.y, y: sz.x };
+  let factors = aspectScaleFactors(g, sz);
+  if (!factors) return;
+  if (g.info.flip) factors = [factors[1], factors[0]];
+  const [xf, yf] = factors;
+  for (let n = g.info.nlist; n !== undefined; n = n.info.next) {
+    // C round(): half away from zero. The frame is un-normalized here, so the
+    // leftmost real node may be negative. @see lib/dotgen/position.c:966-967
+    n.info.coord.x = cround(n.info.coord.x * xf);
+    n.info.coord.y = cround(n.info.coord.y * yf);
+  }
+  scaleBb(g, xf, yf);
+}
+
+// ---------------------------------------------------------------------------
+// placeGraphLabel — @see lib/common/postproc.c:place_graph_label
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/postproc.c:place_graph_label (non-flip branch) */
+function placeLabelNonFlip(g: Graph): { x: number; y: number } {
+  const bb = g.info.bb!;
+  const labelPos = g.info.label_pos ?? 1;
+  const border = g.info.border;
+  const zero = { x: 0, y: 0 };
+  const d = (labelPos & 1) ? (border?.[TOP_IX] ?? zero) : (border?.[BOTTOM_IX] ?? zero);
+  const py = (labelPos & 1) ? bb.ur.y - d.y / 2 : bb.ll.y + d.y / 2;
+  const px = (labelPos & 4) ? bb.ur.x - d.x / 2
+    : (labelPos & 2) ? bb.ll.x + d.x / 2
+    : (bb.ll.x + bb.ur.x) / 2;
+  return { x: px, y: py };
+}
+
+/** @see lib/common/postproc.c:place_flip_graph_label */
+function placeLabelFlip(g: Graph): { x: number; y: number } {
+  const bb = g.info.bb!;
+  const labelPos = g.info.label_pos ?? 1;
+  const border = g.info.border;
+  const zero = { x: 0, y: 0 };
+  const d = (labelPos & 1) ? (border?.[RIGHT_IX] ?? zero) : (border?.[LEFT_IX] ?? zero);
+  const px = (labelPos & 1) ? bb.ur.x - d.x / 2 : bb.ll.x + d.x / 2;
+  const py = (labelPos & 4) ? bb.ll.y + d.y / 2
+    : (labelPos & 2) ? bb.ur.y - d.y / 2
+    : (bb.ll.y + bb.ur.y) / 2;
+  return { x: px, y: py };
+}
+
+/**
+ * Set cluster label positions after bounding boxes are computed.
+ * @see lib/common/postproc.c:place_graph_label
+ */
+export function placeGraphLabel(g: Graph): void {
+  if (g !== g.root) {
+    const lab = g.info.label as TextlabelT | undefined;
+    if (lab && !lab.set) {
+      lab.pos = (g.root.info.flip ?? false) ? placeLabelFlip(g) : placeLabelNonFlip(g);
+      lab.set = true;
+    }
+  }
+  const nClust = g.info.n_cluster ?? 0;
+  for (let c = 0; c < nClust; c++) placeGraphLabel(g.info.clust![c]!);
+}
+
+/** @internal — get dot root for use in bbox computations */
+export { dotRoot };