@knowvah/dot-engine 0.1.0

package/src/layout/fdp/tlayout.ts

@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * fdp initial layout — grid-accelerated Fruchterman–Reingold on point
+ * nodes with boundary ports.
+ *
+ * Spec read at the 15.0.0 tag: the post-tag tree reorders doRep floats
+ * (hypot vs sqrt(x²·y²)) and adds an Mlimit cutoff; the golden refs are
+ * 15.0.0 output, so neither is ported.
+ *
+ * All math is double precision (unlike neato's float32 stress kernel).
+ * Force-accumulation order is load-bearing: node iteration is the
+ * component's id order, edge iteration is the graph edge order, and
+ * grid cells walk in ascending (i, j) order.
+ *
+ * Parameter state lives in tlayout-parms.ts; initial placement in
+ * tlayout-init.ts.
+ *
+ * @see lib/fdpgen/tlayout.c (15.0.0)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import { fma, fms } from '../../common/fma.js';
+import { Grid, type Cell } from './grid.js';
+import {
+  type Bport,
+  type XParams,
+  dndata,
+  disp,
+  isPort,
+  gdata,
+  P_FIX,
+} from './fdp-model.js';
+import { parms, cool, initParams, resetParams } from './tlayout-parms.js';
+import { initPositions } from './tlayout-init.js';
+import { crand } from '../../common/crand.js';
+
+export { fdpInitParams, fdpParms, setSeedFdp, INIT_RANDOM, INIT_REGULAR, INIT_SELF } from './tlayout-parms.js';
+
+// ---------------------------------------------------------------------------
+// Forces
+// ---------------------------------------------------------------------------
+
+/**
+ * Coincident-node fallback: re-roll the delta with rand() until the pair is
+ * non-zero, mirroring C's `while` loops (doRep re-rolls while dist==0,
+ * applyAttr while dist2==0; both re-roll until (xdelta,ydelta) ≠ (0,0), which
+ * for the integer 5−rand()%10 deltas is equivalent). macOS libc rand() is the
+ * Park–Miller MINSTD stream (crand). fdp seeds only srand48 (a separate
+ * drand48 placement stream), so this rand() stream starts unseeded ⇒ srand(1)
+ * (reset per render in fdpLayoutEngine) and is shared, in call order, across
+ * tlayout doRep/applyAttr and xlayout doRep.
+ * @see lib/fdpgen/tlayout.c:doRep / applyAttr
+ * @see lib/fdpgen/xlayout.c:doRep
+ */
+export function coincidentDelta(): { xdelta: number; ydelta: number } {
+  let xdelta = 0;
+  let ydelta = 0;
+  do {
+    xdelta = 5 - crand() % 10;
+    ydelta = 5 - crand() % 10;
+  } while (xdelta === 0 && ydelta === 0);
+  return { xdelta, ydelta };
+}
+
+/**
+ * Repulsive force = K²/d (useNew) or K²/d².
+ * @see lib/fdpgen/tlayout.c:doRep
+ */
+function doRep(
+  p: Node, q: Node, xdelta: number, ydelta: number, dist2: number,
+): void {
+  let force: number;
+
+  if (dist2 === 0.0) {
+    const d = coincidentDelta();
+    xdelta = d.xdelta;
+    ydelta = d.ydelta;
+    dist2 = fma(xdelta, xdelta, ydelta * ydelta);
+  }
+  if (parms.useNew) {
+    const dist = Math.sqrt(dist2);
+    force = parms.K * parms.K / (dist * dist2);
+  } else {
+    force = parms.K * parms.K / dist2;
+  }
+  if (isPort(p) && isPort(q)) force *= 10.0;
+  const dq = disp(q);
+  const dp = disp(p);
+  // arm64 contraction: disp ± delta·force are fmadd/fmsub
+  dq[0] = fma(xdelta, force, dq[0]);
+  dq[1] = fma(ydelta, force, dq[1]);
+  dp[0] = fms(xdelta, force, dp[0]);
+  dp[1] = fms(ydelta, force, dp[1]);
+}
+
+/** @see lib/fdpgen/tlayout.c:applyRep */
+function applyRep(p: Node, q: Node): void {
+  const xdelta = q.info.pos![0]! - p.info.pos![0]!;
+  const ydelta = q.info.pos![1]! - p.info.pos![1]!;
+  doRep(p, q, xdelta, ydelta, fma(xdelta, xdelta, ydelta * ydelta));
+}
+
+/** @see lib/fdpgen/tlayout.c:doNeighbor */
+function doNeighbor(grid: Grid, i: number, j: number, nodes: Node[]): void {
+  const cellp = grid.find(i, j);
+  if (cellp === undefined) return;
+  for (const p of nodes) {
+    for (const q of cellp.nodes) {
+      const xdelta = q.info.pos![0]! - p.info.pos![0]!;
+      const ydelta = q.info.pos![1]! - p.info.pos![1]!;
+      const dist2 = fma(xdelta, xdelta, ydelta * ydelta);
+      if (dist2 < parms.Cell * parms.Cell) doRep(p, q, xdelta, ydelta, dist2);
+    }
+  }
+}
+
+/** @see lib/fdpgen/tlayout.c:gridRepulse */
+function gridRepulse(cellp: Cell, grid: Grid): void {
+  const nodes = cellp.nodes;
+  const i = cellp.i;
+  const j = cellp.j;
+  for (const p of nodes) {
+    for (const q of nodes) {
+      if (p !== q) applyRep(p, q);
+    }
+  }
+
+  doNeighbor(grid, i - 1, j - 1, nodes);
+  doNeighbor(grid, i - 1, j, nodes);
+  doNeighbor(grid, i - 1, j + 1, nodes);
+  doNeighbor(grid, i, j - 1, nodes);
+  doNeighbor(grid, i, j + 1, nodes);
+  doNeighbor(grid, i + 1, j - 1, nodes);
+  doNeighbor(grid, i + 1, j, nodes);
+  doNeighbor(grid, i + 1, j + 1, nodes);
+}
+
+/**
+ * Attractive force = weight × (d − len)/d (useNew) or weight × d/len.
+ * @see lib/fdpgen/tlayout.c:applyAttr
+ */
+function applyAttr(p: Node, q: Node, e: Edge): void {
+  let xdelta = q.info.pos![0]! - p.info.pos![0]!;
+  let ydelta = q.info.pos![1]! - p.info.pos![1]!;
+  let dist2 = fma(xdelta, xdelta, ydelta * ydelta);
+  if (dist2 === 0.0) {
+    const d = coincidentDelta();
+    xdelta = d.xdelta;
+    ydelta = d.ydelta;
+    dist2 = fma(xdelta, xdelta, ydelta * ydelta);
+  }
+  const dist = Math.sqrt(dist2);
+  let force: number;
+  if (parms.useNew) {
+    force = (e.info.factor ?? 1) * (dist - (e.info.dist ?? 1)) / dist;
+  } else {
+    force = (e.info.factor ?? 1) * dist / (e.info.dist ?? 1);
+  }
+  const dq = disp(q);
+  const dp = disp(p);
+  dq[0] = fms(xdelta, force, dq[0]);
+  dq[1] = fms(ydelta, force, dq[1]);
+  dp[0] = fma(xdelta, force, dp[0]);
+  dp[1] = fma(ydelta, force, dp[1]);
+}
+
+// ---------------------------------------------------------------------------
+// updatePos
+// ---------------------------------------------------------------------------
+
+/** Temperature-limited move of one node; returns its new raw target. */
+function moveTarget(n: Node, temp: number): { x: number; y: number } {
+  const dx = disp(n)[0];
+  const dy = disp(n)[1];
+  const len2 = fma(dx, dx, dy * dy);
+  const temp2 = temp * temp;
+  /* limit by temperature */
+  if (len2 < temp2) {
+    return { x: n.info.pos![0]! + dx, y: n.info.pos![1]! + dy };
+  }
+  const fact = temp / Math.sqrt(len2);
+  return {
+    x: fma(dx, fact, n.info.pos![0]!),
+    y: fma(dy, fact, n.info.pos![1]!),
+  };
+}
+
+/** Boundary-ellipse clamp for the with-ports case. */
+function clampToBoundary(n: Node, x: number, y: number): void {
+  const d = Math.sqrt(
+    x * x / (parms.Wd * parms.Wd) + y * y / (parms.Ht * parms.Ht));
+  if (isPort(n)) {
+    n.info.pos![0] = x / d;
+    n.info.pos![1] = y / d;
+  } else if (d >= 1.0) {
+    n.info.pos![0] = 0.95 * x / d;
+    n.info.pos![1] = 0.95 * y / d;
+  } else {
+    n.info.pos![0] = x;
+    n.info.pos![1] = y;
+  }
+}
+
+/**
+ * Move nodes by their accumulated displacement, limited by temperature
+ * and (when ports exist) the boundary ellipse.
+ * @see lib/fdpgen/tlayout.c:updatePos
+ */
+function updatePos(g: Graph, temp: number, pp: Bport[] | null): void {
+  for (const n of g.nodes.values()) {
+    if (dndata(n).pinned & P_FIX) continue;
+    const { x, y } = moveTarget(n, temp);
+    if (pp) {
+      clampToBoundary(n, x, y);
+    } else {
+      n.info.pos![0] = x;
+      n.info.pos![1] = y;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// adjust passes
+// ---------------------------------------------------------------------------
+
+/** FLOOR @see lib/fdpgen/tlayout.c:FLOOR */
+const FLOOR = Math.floor;
+
+/** One grid-accelerated iteration. @see lib/fdpgen/tlayout.c:gAdjust */
+function gAdjust(g: Graph, temp: number, pp: Bport[] | null, grid: Grid): void {
+  if (temp <= 0.0) return;
+
+  grid.clear();
+
+  for (const n of g.nodes.values()) {
+    const d = disp(n);
+    d[0] = d[1] = 0;
+    grid.add(
+      FLOOR(n.info.pos![0]! / parms.Cell),
+      FLOOR(n.info.pos![1]! / parms.Cell),
+      n,
+    );
+  }
+
+  for (const n of g.nodes.values()) {
+    for (const e of n.outEdges(g)) {
+      if (n !== e.head) applyAttr(n, e.head, e);
+    }
+  }
+  grid.walk(gridRepulse);
+
+  updatePos(g, temp, pp);
+}
+
+/** All-pairs repulsion + attraction. @see tlayout.c:adjust (force loop) */
+function allPairForces(g: Graph, nodes: Node[]): void {
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i]!;
+    for (let k = i + 1; k < nodes.length; k++) {
+      applyRep(n, nodes[k]!);
+    }
+    for (const e of n.outEdges(g)) {
+      if (n !== e.head) applyAttr(n, e.head, e);
+    }
+  }
+}
+
+/** One O(n²) all-pairs iteration. @see lib/fdpgen/tlayout.c:adjust */
+function adjust(g: Graph, temp: number, pp: Bport[] | null): void {
+  if (temp <= 0.0) return;
+
+  const nodes = [...g.nodes.values()];
+  for (const n of nodes) {
+    const d = disp(n);
+    d[0] = d[1] = 0;
+  }
+  allPairForces(g, nodes);
+  updatePos(g, temp, pp);
+}
+
+// ---------------------------------------------------------------------------
+// fdp_tLayout
+// ---------------------------------------------------------------------------
+
+/**
+ * Lay out one derived component g, respecting its boundary ports.
+ * @see lib/fdpgen/tlayout.c:fdp_tLayout
+ */
+export function fdpTLayout(g: Graph, xpms: XParams): void {
+  const pp = gdata(g).ports;
+  const reset = initParams(g, xpms);
+  const ctr = initPositions(g, pp);
+
+  if (parms.useGrid) {
+    const grid = new Grid();
+    for (let i = 0; i < parms.loopcnt; i++) {
+      const temp = cool(i);
+      gAdjust(g, temp, pp, grid);
+    }
+  } else {
+    for (let i = 0; i < parms.loopcnt; i++) {
+      const temp = cool(i);
+      adjust(g, temp, pp);
+    }
+  }
+
+  if (ctr.x !== 0.0 || ctr.y !== 0.0) {
+    for (const n of g.nodes.values()) {
+      n.info.pos![0]! += ctr.x;
+      n.info.pos![1]! += ctr.y;
+    }
+  }
+  if (reset) resetParams();
+}

package/src/layout/fdp/xlayout.ts

@@ -0,0 +1,350 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * fdp expansion layout: grow the point-node layout so sized nodes do
+ * not overlap, by force iteration with overlap-aware repulsion.
+ *
+ * Spec read at the 15.0.0 tag (the post-tag Mlimit force cutoff is
+ * deliberately NOT ported — the golden refs predate it).
+ *
+ * The default overlap attribute is "9:prism": up to 9 x_layout tries,
+ * then removeOverlapAs with the remaining mode. x_layout does NOT always
+ * converge (many cluster/derived graphs reach the mode dispatch), so
+ * removeOverlapAs wires the ported neato adjust machinery: AM_PRISM via
+ * fdpAdjust, the scale family via scAdjust. On the GTS reference build
+ * overlap=false resolves to AM_PRISM (value 1000), not a no-op.
+ *
+ * @see lib/fdpgen/xlayout.c (15.0.0)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import { sepFactor, type ExpandT } from '../neato/sep-factor.js';
+import { fdpAdjust, overlapPrismTries } from '../neato/fdp-adjust.js';
+import { scAdjust } from '../neato/sc-adjust.js';
+import {
+  type XParams,
+  dndata,
+  disp,
+  aggetGraph,
+  P_PIN,
+} from './fdp-model.js';
+import { coincidentDelta } from './tlayout.js';
+import { normalizeG } from './normalize.js';
+
+/** @see lib/fdpgen/xlayout.c:DFLT_overlap */
+const DFLT_OVERLAP = '9:prism';
+
+/** PS2INCH @see lib/common/geom.h */
+const PS2INCH = (x: number): number => x / 72;
+
+// ---------------------------------------------------------------------------
+// xParams / X_marg — static state (C statics, persist across calls)
+// ---------------------------------------------------------------------------
+
+/** @see lib/fdpgen/xlayout.c:xParams */
+const xParams: XParams = {
+  numIters: 60,
+  T0: 0.0,
+  K: 0.3,
+  C: 1.5,
+  loopcnt: 0,
+};
+
+/** @see lib/fdpgen/xlayout.c:X_marg */
+let xMarg: ExpandT = { x: 0, y: 0, doAdd: false };
+
+/** Overlap/non-overlap repulsion strengths for one try. */
+interface RepStrength {
+  /** X_ov = C·K². @see lib/fdpgen/xlayout.c:x_layout */
+  ov: number;
+  /** X_nonov = |E|·X_ov·2 / (|V|·(|V|−1)). */
+  nonov: number;
+}
+
+/** Expanded half-width of n in inches. @see lib/fdpgen/xlayout.c:WD2 */
+function wd2(n: Node): number {
+  return xMarg.doAdd ? n.info.width / 2.0 + xMarg.x : n.info.width * xMarg.x / 2.0;
+}
+
+/** Expanded half-height of n in inches. @see lib/fdpgen/xlayout.c:HT2 */
+function ht2(n: Node): number {
+  return xMarg.doAdd ? n.info.height / 2.0 + xMarg.y : n.info.height * xMarg.y / 2.0;
+}
+
+/** Expanded radius of n. @see lib/fdpgen/xlayout.c:RAD */
+function rad(n: Node): number {
+  return Math.hypot(wd2(n), ht2(n));
+}
+
+/**
+ * Initialize the local expansion parameters from the tlayout handoff.
+ * @returns K² @see lib/fdpgen/xlayout.c:xinit_params
+ */
+function xinitParams(n: number, xpms: XParams): number {
+  xParams.K = xpms.K;
+  xParams.numIters = xpms.numIters;
+  xParams.T0 = xpms.T0;
+  xParams.loopcnt = xpms.loopcnt;
+  if (xpms.C > 0.0) xParams.C = xpms.C;
+  const K2 = xParams.K * xParams.K;
+  if (xParams.T0 === 0.0) {
+    xParams.T0 = xParams.K * Math.sqrt(n) / 5;
+  }
+  return K2;
+}
+
+/** @see lib/fdpgen/xlayout.c:cool */
+function cool(t: number): number {
+  return xParams.T0 * (xParams.numIters - t) / xParams.numIters;
+}
+
+// ---------------------------------------------------------------------------
+// Overlap predicate
+// ---------------------------------------------------------------------------
+
+/** True if expanded node boxes overlap. @see lib/fdpgen/xlayout.c:overlap */
+function overlap(p: Node, q: Node): boolean {
+  const xdelta = Math.abs(q.info.pos![0]! - p.info.pos![0]!);
+  const ydelta = Math.abs(q.info.pos![1]! - p.info.pos![1]!);
+  return xdelta <= wd2(p) + wd2(q) && ydelta <= ht2(p) + ht2(q);
+}
+
+/** Number of overlapping pairs. @see lib/fdpgen/xlayout.c:cntOverlaps */
+function cntOverlaps(g: Graph): number {
+  let cnt = 0;
+  const nodes = [...g.nodes.values()];
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      cnt += overlap(nodes[i]!, nodes[j]!) ? 1 : 0;
+    }
+  }
+  return cnt;
+}
+
+// ---------------------------------------------------------------------------
+// Forces
+// ---------------------------------------------------------------------------
+
+/**
+ * Overlap-aware repulsion; returns 1 if the pair overlaps.
+ * The delta/dist2 computation of C's applyRep is inlined here; the
+ * C doRep/applyRep split exists for the rand() re-roll loop on
+ * coincident nodes (coincidentDelta), shared with tlayout.
+ * @see lib/fdpgen/xlayout.c:doRep
+ * @see lib/fdpgen/xlayout.c:applyRep
+ */
+function applyRep(p: Node, q: Node, rs: RepStrength): number {
+  let xdelta = q.info.pos![0]! - p.info.pos![0]!;
+  let ydelta = q.info.pos![1]! - p.info.pos![1]!;
+  let dist2 = xdelta * xdelta + ydelta * ydelta;
+  if (dist2 === 0.0) {
+    const d = coincidentDelta();
+    xdelta = d.xdelta;
+    ydelta = d.ydelta;
+    dist2 = xdelta * xdelta + ydelta * ydelta;
+  }
+  const ov = overlap(p, q) ? 1 : 0;
+  const force = ov ? rs.ov / dist2 : rs.nonov / dist2;
+  const dq = disp(q);
+  const dp = disp(p);
+  dq[0] += xdelta * force;
+  dq[1] += ydelta * force;
+  dp[0] -= xdelta * force;
+  dp[1] -= ydelta * force;
+  return ov;
+}
+
+/**
+ * Attraction along edges, zero while the endpoints overlap.
+ * @see lib/fdpgen/xlayout.c:applyAttr
+ */
+function applyAttr(p: Node, q: Node): void {
+  if (overlap(p, q)) return;
+  const xdelta = q.info.pos![0]! - p.info.pos![0]!;
+  const ydelta = q.info.pos![1]! - p.info.pos![1]!;
+  const dist = Math.hypot(xdelta, ydelta);
+  const din = rad(p) + rad(q);
+  const dout = dist - din;
+  const force = dout * dout / ((xParams.K + din) * dist);
+  const dq = disp(q);
+  const dp = disp(p);
+  dq[0] -= xdelta * force;
+  dq[1] -= ydelta * force;
+  dp[0] += xdelta * force;
+  dp[1] += ydelta * force;
+}
+
+// ---------------------------------------------------------------------------
+// adjust
+// ---------------------------------------------------------------------------
+
+/** Accumulate all forces; returns the overlap count. */
+function accumForces(g: Graph, rs: RepStrength): number {
+  let overlaps = 0;
+  const nodes = [...g.nodes.values()];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i]!;
+    for (let j = i + 1; j < nodes.length; j++) {
+      overlaps += applyRep(n, nodes[j]!, rs);
+    }
+    for (const e of n.outEdges(g)) {
+      applyAttr(n, e.head);
+    }
+  }
+  return overlaps;
+}
+
+/** Temperature-limited position update. @see xlayout.c:adjust (move loop) */
+function moveNodes(g: Graph, temp: number): void {
+  const temp2 = temp * temp;
+  for (const n of g.nodes.values()) {
+    if (dndata(n).pinned === P_PIN) continue;
+    const dx = disp(n)[0];
+    const dy = disp(n)[1];
+    const len2 = dx * dx + dy * dy;
+    if (len2 < temp2) {
+      n.info.pos![0]! += dx;
+      n.info.pos![1]! += dy;
+    } else {
+      const len = Math.sqrt(len2);
+      n.info.pos![0]! += dx * temp / len;
+      n.info.pos![1]! += dy * temp / len;
+    }
+  }
+}
+
+/**
+ * One expansion iteration. Returns 0 if there were definitely no
+ * overlaps; non-zero if overlaps existed before the move.
+ * @see lib/fdpgen/xlayout.c:adjust
+ */
+function adjust(g: Graph, temp: number, rs: RepStrength): number {
+  for (const n of g.nodes.values()) {
+    const d = disp(n);
+    d[0] = d[1] = 0;
+  }
+  const overlaps = accumForces(g, rs);
+  if (overlaps === 0) return 0;
+  moveNodes(g, temp);
+  return overlaps;
+}
+
+// ---------------------------------------------------------------------------
+// x_layout
+// ---------------------------------------------------------------------------
+
+/**
+ * Expand the layout until nodes no longer overlap, up to `tries`
+ * rounds with growing K. Returns the remaining overlap count.
+ * @see lib/fdpgen/xlayout.c:x_layout
+ */
+function xLayout(g: Graph, pxpms: XParams, tries: number): number {
+  xMarg = sepFactor(g);
+  if (xMarg.doAdd) {
+    xMarg = { x: PS2INCH(xMarg.x), y: PS2INCH(xMarg.y), doAdd: true };
+  }
+  let ov = cntOverlaps(g);
+  if (ov === 0) return 0;
+
+  const xpms: XParams = { ...pxpms };
+  const K = xpms.K;
+  for (let t = 0; ov && t < tries; ++t) {
+    ov = xLayoutTry(g, xpms, ov);
+    xpms.K += K; /* increase distance */
+  }
+
+  return ov;
+}
+
+/** One expansion try: cool from T0 until no overlaps or loopcnt. */
+function xLayoutTry(g: Graph, xpms: XParams, ov: number): number {
+  const nnodes = g.nodes.size;
+  const nedges = g.edges.length;
+  const K2 = xinitParams(nnodes, xpms);
+  const xOv = xParams.C * K2;
+  const rs: RepStrength = {
+    ov: xOv,
+    nonov: nedges * xOv * 2.0 / (nnodes * (nnodes - 1)),
+  };
+  for (let i = 0; i < xParams.loopcnt; i++) {
+    const temp = cool(i);
+    if (temp <= 0.0) break;
+    ov = adjust(g, temp, rs);
+    if (ov === 0) break;
+  }
+  return ov;
+}
+
+// ---------------------------------------------------------------------------
+// fdp_xLayout
+// ---------------------------------------------------------------------------
+
+/** Parse the overlap attribute's optional "n:" try-count prefix. */
+function parseOverlapTries(ovlp: string): { tries: number; rest: string } {
+  const cp = ovlp.indexOf(':');
+  if (cp >= 0 && (cp === 0 || /^[0-9]/.test(ovlp))) {
+    const tries = Math.max(0, parseInt(ovlp, 10) || 0);
+    return { tries, rest: ovlp.slice(cp + 1) };
+  }
+  return { tries: 0, rest: ovlp };
+}
+
+/**
+ * Overlap-removal dispatch on the overlap attribute:
+ *   ""/null → default "9:prism"; "n:mode" → n x_layout tries, then
+ *   removeOverlap with mode; "true" → keep overlaps.
+ * @see lib/fdpgen/xlayout.c:fdp_xLayout
+ */
+export function fdpXLayout(g: Graph, xpms: XParams): void {
+  let ovlp = aggetGraph(g, 'overlap');
+  if (ovlp === undefined || ovlp === '') ovlp = DFLT_OVERLAP;
+  const { tries, rest } = parseOverlapTries(ovlp);
+  if (tries && !xLayout(g, xpms, tries)) return;
+  removeOverlapAs(g, rest);
+}
+
+/**
+ * Mode-based overlap removal, mirroring C removeOverlapAs → getAdjustMode →
+ * removeOverlapWith with the flag passed explicitly (the parsed "n:mode"
+ * suffix, not the raw overlap attr). removeOverlapWith runs normalize +
+ * simpleScale first, then dispatches on the resolved mode:
+ *   AM_PRISM (prism*, or the boolean/false fallback on GTS) → fdpAdjust;
+ *   scale family (scale/scalexy/compress) → scAdjust;
+ *   AM_NONE ('' / 'true') and unported modes (voronoi) → no-op.
+ * normalize reads "normalize" and simpleScale reads "scale"; deriveGraph
+ * copies only overlap/sep/K, so both are faithfully dead here (as noted in
+ * normalize.ts / sc-adjust.ts) unless set on the derived chain — simpleScale
+ * follows the project's decision to leave it unported.
+ * @see lib/neatogen/adjust.c:removeOverlapAs / removeOverlapWith / getAdjustMode
+ */
+function removeOverlapAs(g: Graph, flag: string): void {
+  if (g.nodes.size < 2) return; // removeOverlapWith: <2 nodes short-circuits
+  normalizeG(g); // removeOverlapWith runs normalize before the mode switch
+  const ntry = overlapPrismTries(flag);
+  if (ntry !== null) {
+    fdpAdjust(g, ntry); // AM_PRISM
+    return;
+  }
+  const mode = flag.toLowerCase();
+  if (mode === 'scale') return void scAdjust(g, 1); // AM_NSCALE
+  if (mode === 'scalexy') return void scAdjust(g, 0); // AM_SCALEXY
+  if (mode === 'compress') return void scAdjust(g, -1); // AM_COMPRESS
+  // Genuinely unported adjust algorithms: throw rather than silently leave
+  // overlaps (no supported corpus input reaches these).
+  if (UNPORTED_MODES.has(mode)) {
+    throw new Error(
+      `fdp: removeOverlapAs mode "${mode}" reached for graph "${g.name}" — ` +
+      'that adjust algorithm (voronoi/oscale/vpsc/ortho/ipsep) is not ported',
+    );
+  }
+  // AM_NONE ('', 'true', any boolean-true) → no overlap removal.
+}
+
+/** Named adjust modes whose C algorithm is not ported (would silently
+ * leave overlaps). @see lib/neatogen/adjust.c:removeOverlapWith switch */
+const UNPORTED_MODES = new Set([
+  'voronoi', 'oscale', 'vpsc', 'ipsep',
+  'ortho', 'ortho_yx', 'orthoxy', 'orthoyx',
+  'portho', 'portho_yx', 'porthoxy', 'porthoyx',
+]);