@knowvah/dot-engine 0.1.0

package/src/layout/fdp/derive.ts

@@ -0,0 +1,272 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Derived-graph construction: clusters collapse into single nodes, and
+ * an edge joins two derived nodes when any real edge joins their
+ * underlying node sets. Boundary ports transform into port nodes.
+ *
+ * The C derived graph is a strict digraph whose edge direction is
+ * canonicalized by node POINTER comparison (`hd > tl`, layout.c:466);
+ * node ids are creation-ordered here, so id comparison models it.
+ * agedge with a NULL name dedups on strict digraphs (cgraph
+ * edge.c:262), merging parallel real edges into one derived edge.
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/layout.c:deriveGraph (15.0.0)
+ */
+
+import { Graph } from '../../model/graph.js';
+import { Node } from '../../model/node.js';
+import { Edge } from '../../model/edge.js';
+import type { Box } from '../../model/geom.js';
+import { doGraphLabel } from '../dot/graph-label.js';
+import { layoutMeasurer } from '../../common/nodeinit.js';
+import {
+  type Bport,
+  gdata,
+  dndata,
+  mkDndata,
+  getDnode,
+  setDnode,
+  getParent,
+  setParent,
+  fdpData,
+  isNewEdge,
+  addEdge,
+  aggetGraph,
+  P_PIN,
+  P_FIX,
+  P_SET,
+} from './fdp-model.js';
+
+/** Per-fdp-run bookkeeping. @see lib/fdpgen/layout.c:layout_info */
+export interface LayoutInfo {
+  /** Logical root; the graph passed to fdp_layout. */
+  rootg: Graph;
+  /** Whether a "coords" graph attribute exists (G_coord symbol). */
+  hasCoords: boolean;
+  gid: number;
+  /** Pack parameters resolved by init_info. */
+  pack: import('../pack/types.js').PackInfo;
+}
+
+// ---------------------------------------------------------------------------
+// Derived-node construction
+// ---------------------------------------------------------------------------
+
+/**
+ * Construct a node in a derived graph, allocating its dndata.
+ * @see lib/fdpgen/layout.c:mkDeriveNode
+ */
+export function mkDeriveNode(dg: Graph, name: string): Node {
+  const dn = new Node(dg.nodes.size, name, dg);
+  dn.info.alg = mkDndata();
+  dn.info.pos = [0, 0];
+  dg.nodes.set(name, dn);
+  return dn;
+}
+
+/**
+ * Copy one graph attribute from g (resolved up its parent chain) onto
+ * dg. HTML-string attribute values are not distinguished (AD-2).
+ * @see lib/fdpgen/layout.c:copyAttr
+ */
+function copyAttr(g: Graph, dg: Graph, attr: string): void {
+  const v = aggetGraph(g, attr);
+  if (v !== undefined) dg.attrs.set(attr, v);
+}
+
+/**
+ * Use a cluster's "coords" attribute, if any, for the initial position
+ * of its derived node. PSinputscale (inputscale attr) is not ported —
+ * no supported input sets it.
+ * @see lib/fdpgen/layout.c:chkPos
+ */
+function chkPos(g: Graph, n: Node, infop: LayoutInfo, bbp: Box): void {
+  const p = g.attrs.get('coords');
+  if (p === undefined || p === '') return;
+  if (g !== infop.rootg) {
+    const pp = g.parent !== null ? g.parent.attrs.get('coords') : undefined;
+    if (p === pp) return;
+  }
+  const parsed = scanCoords(p);
+  if (parsed === null) return; // C warns "expected four doubles"
+  bbp.ll.x = parsed.box.ll.x;
+  bbp.ll.y = parsed.box.ll.y;
+  bbp.ur.x = parsed.box.ur.x;
+  bbp.ur.y = parsed.box.ur.y;
+  dndata(n).pinned = parsed.pinned;
+}
+
+/** sscanf(p, "%lf,%lf,%lf,%lf%c") for chkPos. */
+function scanCoords(p: string): { box: Box; pinned: number } | null {
+  const num = String.raw`(-?[\d.]+)`;
+  const m = new RegExp(
+    `^${num},${num},${num},${num}\\s*([!?])?`,
+  ).exec(p);
+  if (m === null) return null;
+  const box: Box = {
+    ll: { x: parseFloat(m[1]!), y: parseFloat(m[2]!) },
+    ur: { x: parseFloat(m[3]!), y: parseFloat(m[4]!) },
+  };
+  const c = m[5];
+  const pinned = c === '!' ? P_PIN : c === '?' ? P_FIX : P_SET;
+  return { box, pinned };
+}
+
+/** Derived nodes from clusters. @see layout.c:deriveGraph (cluster loop) */
+function deriveClusterNodes(g: Graph, dg: Graph, infop: LayoutInfo): void {
+  const nClusters = g.info.n_cluster ?? 0;
+  for (let i = 0; i < nClusters; i++) {
+    const subg = g.info.clust![i]!;
+    const fixBB: Box = {
+      ll: { x: Number.MAX_VALUE, y: Number.MAX_VALUE },
+      ur: { x: -Number.MAX_VALUE, y: -Number.MAX_VALUE },
+    };
+    doGraphLabel(subg, layoutMeasurer(infop.rootg));
+    const dn = mkDeriveNode(dg, subg.name);
+    dndata(dn).clust = subg;
+    if (infop.hasCoords) chkPos(subg, dn, infop, fixBB);
+    for (const n of subg.nodes.values()) {
+      setDnode(n, dn);
+    }
+    if (dndata(dn).pinned) {
+      dn.info.pos![0] = (fixBB.ll.x + fixBB.ur.x) / 2;
+      dn.info.pos![1] = (fixBB.ll.y + fixBB.ur.y) / 2;
+    }
+  }
+}
+
+/**
+ * Derived nodes from the remaining (non-cluster) nodes.
+ * @returns false on the two-non-comparable-clusters error
+ * @see layout.c:deriveGraph (remaining-nodes loop)
+ */
+function deriveRealNodes(g: Graph, dg: Graph): boolean {
+  for (const n of g.nodes.values()) {
+    if (getDnode(n) !== null) continue;
+    const par = getParent(n);
+    if (par !== null && par !== gdata(g).parent) {
+      // C: agerrorf "node is contained in two non-comparable clusters"
+      return false;
+    }
+    setParent(n, g);
+    if (n.info.clustnode) continue;
+    setDnode(n, mkRealDnode(dg, n));
+  }
+  return true;
+}
+
+/** Derived image of one real node, sizes copied. @see layout.c:438-453 */
+function mkRealDnode(dg: Graph, n: Node): Node {
+  const dn = mkDeriveNode(dg, n.name);
+  dn.info.width = n.info.width;
+  dn.info.height = n.info.height;
+  dn.info.lw = n.info.lw;
+  dn.info.rw = n.info.rw;
+  dn.info.ht = n.info.ht;
+  dn.info.shape = n.info.shape;
+  dn.info.shape_info = n.info.shape_info;
+  if (fdpData(n).pinned) {
+    dn.info.pos![0] = n.info.pos![0]!;
+    dn.info.pos![1] = n.info.pos![1]!;
+    dndata(dn).pinned = fdpData(n).pinned;
+  }
+  dndata(dn).dn = n;
+  return dn;
+}
+
+/** Find-or-create the canonical derived edge for (tl, hd). */
+function deriveEdge(dg: Graph, byPair: Map<string, Edge>, tl: Node, hd: Node): Edge {
+  // C: if (hd > tl) agedge(dg, tl, hd) else agedge(dg, hd, tl)
+  const [t, h] = hd.id > tl.id ? [tl, hd] : [hd, tl];
+  const key = `${t.id}:${h.id}`;
+  let de = byPair.get(key);
+  if (de === undefined) {
+    de = new Edge(t, h, '');
+    de.info.count = 0;
+    byPair.set(key, de);
+    dg.edges.push(de);
+  }
+  return de;
+}
+
+/** Derived edges. @see layout.c:deriveGraph (edge loop) */
+function deriveEdges(g: Graph, dg: Graph, byPair: Map<string, Edge>): void {
+  for (const n of g.nodes.values()) {
+    const tl = getDnode(n)!;
+    for (const e of n.outEdges(g)) {
+      const hd = getDnode(e.head)!;
+      if (hd === tl) continue;
+      const de = deriveEdge(dg, byPair, tl, hd);
+      de.info.dist = e.info.dist;
+      de.info.factor = e.info.factor;
+      dndata(hd).wdeg++;
+      dndata(tl).wdeg++;
+      if (isNewEdge(de)) {
+        dndata(hd).deg++;
+        dndata(tl).deg++;
+      }
+      addEdge(de, e);
+    }
+  }
+}
+
+/** Transform g's ports into dg port nodes. @see layout.c:deriveGraph (ports) */
+function derivePorts(g: Graph, dg: Graph, byPair: Map<string, Edge>): void {
+  const pp = gdata(g).ports;
+  if (pp === null) return;
+  const pq: Bport[] = [];
+  for (const port of pp) {
+    const m = getDnode(port.n);
+    /* Create port in derived graph only if it hooks to an internal node */
+    if (m === null) continue;
+    pq.push(derivePort(g, dg, byPair, port, m));
+  }
+  gdata(dg).ports = pq;
+  gdata(dg).nports = pq.length;
+}
+
+/** One derived port node + its edge. @see layout.c:494-517 */
+function derivePort(
+  g: Graph, dg: Graph, byPair: Map<string, Edge>, port: Bport, m: Node,
+): Bport {
+  // C portName: _port_<graph>_(<tid>)_(<hid>)_<seq>
+  const name =
+    `_port_${g.name}_(${port.e.tail.id})_(${port.e.head.id})_${port.e.seq}`;
+  const dn = mkDeriveNode(dg, name);
+  const de = deriveEdge(dg, byPair, m, dn);
+  de.info.dist = port.e.info.dist;
+  de.info.factor = port.e.info.factor;
+  addEdge(de, port.e);
+  dndata(dn).wdeg++;
+  dndata(m).wdeg++;
+  dndata(dn).deg++; /* ports are unique, so this is the only touch */
+  dndata(m).deg++;
+  return { n: dn, alpha: port.alpha, e: de };
+}
+
+/**
+ * Create the derived graph of g by collapsing clusters into nodes.
+ * @returns null on the non-comparable-clusters input error
+ * @see lib/fdpgen/layout.c:deriveGraph
+ */
+export function deriveGraph(g: Graph, infop: LayoutInfo): Graph | null {
+  const dg = new Graph('derived', 'strict-directed');
+  dg.parent = null;
+  gdata(dg);
+  infop.gid++;
+
+  copyAttr(g, dg, 'overlap');
+  copyAttr(g, dg, 'sep');
+  copyAttr(g, dg, 'K');
+
+  deriveClusterNodes(g, dg, infop);
+  if (!deriveRealNodes(g, dg)) return null;
+  const byPair = new Map<string, Edge>();
+  deriveEdges(g, dg, byPair);
+  derivePorts(g, dg, byPair);
+
+  return dg;
+}

package/src/layout/fdp/fdp-model.ts

@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * fdp engine data model — gdata, dndata, bport_t, xparams, and the
+ * accessor macros of the C private interface.
+ *
+ * Spec read at the 15.0.0 tag (post-tag fdpgen commits add an Mlimit
+ * branch and float reorderings the golden refs do not have).
+ *
+ * @see lib/fdpgen/fdp.h (15.0.0)
+ * @see lib/fdpgen/xlayout.h (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 type { Box } from '../../model/geom.js';
+import type { FdpAlgData, FdpDndata } from '../../model/nodeInfo.js';
+
+/** Layout dimension. @see lib/fdpgen/fdp.h:NDIM */
+export const NDIM = 2;
+
+// ---------------------------------------------------------------------------
+// ND_pinned states — @see lib/common/const.h:247-249
+// ---------------------------------------------------------------------------
+
+/** Position supplied by user. @see lib/common/const.h:P_SET */
+export const P_SET = 1;
+/** Position fixed during topological layout. @see lib/common/const.h:P_FIX */
+export const P_FIX = 2;
+/** Position fixed. @see lib/common/const.h:P_PIN */
+export const P_PIN = 3;
+
+// ---------------------------------------------------------------------------
+// bport_t — boundary port
+// ---------------------------------------------------------------------------
+
+/**
+ * Boundary port: a real edge crossing the cluster boundary, the inside
+ * endpoint, and its angle on the boundary ellipse. C arrays are
+ * 0-terminated; TS uses plain arrays.
+ *
+ * @see lib/fdpgen/fdp.h:bport_t
+ */
+export interface Bport {
+  e: Edge;
+  n: Node;
+  alpha: number;
+}
+
+// ---------------------------------------------------------------------------
+// xparams — parameters handed from tlayout to xlayout
+// ---------------------------------------------------------------------------
+
+/** @see lib/fdpgen/xlayout.h:xparams */
+export interface XParams {
+  numIters: number;
+  T0: number;
+  K: number;
+  C: number;
+  loopcnt: number;
+}
+
+// ---------------------------------------------------------------------------
+// gdata — attached to the root graph, cluster graphs, and derived graphs
+// ---------------------------------------------------------------------------
+
+/** @see lib/fdpgen/fdp.h:gdata */
+export interface Gdata {
+  /** Boundary ports. @see lib/fdpgen/fdp.h:PORTS */
+  ports: Bport[] | null;
+  /** Number of ports. @see lib/fdpgen/fdp.h:NPORTS */
+  nports: number;
+  /** Bounding box of graph in INCHES. @see lib/fdpgen/fdp.h:BB */
+  bb: Box;
+  flags: number;
+  /** Depth in graph hierarchy. @see lib/fdpgen/fdp.h:LEVEL */
+  level: number;
+  /** Smallest containing cluster. @see lib/fdpgen/fdp.h:GPARENT */
+  parent: Graph | null;
+}
+
+/** Allocate a zeroed gdata record (gv_alloc equivalent). */
+export function mkGdata(): Gdata {
+  return {
+    ports: null,
+    nports: 0,
+    bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } },
+    flags: 0,
+    level: 0,
+    parent: null,
+  };
+}
+
+/** GDATA(g) — gdata bound to g.info.alg; binds one if missing. */
+export function gdata(g: Graph): Gdata {
+  let d = g.info.alg as Gdata | undefined;
+  if (d === undefined) {
+    d = mkGdata();
+    g.info.alg = d;
+  }
+  return d;
+}
+
+// ---------------------------------------------------------------------------
+// dndata — attached to nodes in derived graphs (ND_alg)
+// ---------------------------------------------------------------------------
+
+/** Allocate a zeroed dndata record. @see lib/fdpgen/layout.c:mkDeriveNode */
+export function mkDndata(): FdpDndata {
+  return {
+    kind: 'fdp-dndata',
+    deg: 0,
+    wdeg: 0,
+    dn: null,
+    clust: null,
+    disp: [0, 0],
+    pinned: 0,
+  };
+}
+
+/** DNDATA(n) — dndata of a derived node. */
+export function dndata(n: Node): FdpDndata {
+  return n.info.alg as unknown as FdpDndata;
+}
+
+/** DISP(n) @see lib/fdpgen/fdp.h:DISP */
+export function disp(n: Node): [number, number] {
+  return dndata(n).disp;
+}
+
+/** ANODE(n) @see lib/fdpgen/fdp.h:ANODE */
+export function anode(n: Node): Node | null {
+  return dndata(n).dn;
+}
+
+/** IS_PORT(n) @see lib/fdpgen/fdp.h:IS_PORT */
+export function isPort(n: Node): boolean {
+  const d = dndata(n);
+  return d.dn === null && d.clust === null;
+}
+
+// ---------------------------------------------------------------------------
+// Real-node fdp fields — DNODE (ND_next) and PARENT (ND_clust)
+// ---------------------------------------------------------------------------
+
+/** Bind-or-get the fdp alg record on a REAL node. */
+export function fdpData(n: Node): FdpAlgData {
+  let d = n.info.alg as FdpAlgData | undefined;
+  if (d === undefined || d.kind !== 'fdp') {
+    d = { kind: 'fdp', dnode: null, parent: null, pinned: 0 };
+    n.info.alg = d;
+  }
+  return d;
+}
+
+/** DNODE(n) @see lib/fdpgen/fdp.h:DNODE */
+export function getDnode(n: Node): Node | null {
+  const d = n.info.alg as FdpAlgData | undefined;
+  return d !== undefined && d.kind === 'fdp' ? d.dnode : null;
+}
+
+/** DNODE(n) = dn */
+export function setDnode(n: Node, dn: Node | null): void {
+  fdpData(n).dnode = dn;
+}
+
+/** PARENT(n) @see lib/fdpgen/fdp.h:PARENT */
+export function getParent(n: Node): Graph | null {
+  const d = n.info.alg as FdpAlgData | undefined;
+  return d !== undefined && d.kind === 'fdp' ? d.parent : null;
+}
+
+/** PARENT(n) = g */
+export function setParent(n: Node, g: Graph): void {
+  fdpData(n).parent = g;
+}
+
+// ---------------------------------------------------------------------------
+// Pinned-state helpers (numeric on derived nodes / real fdp nodes)
+// ---------------------------------------------------------------------------
+
+/** ND_pinned for a derived node. */
+export function dnPinned(n: Node): number {
+  return dndata(n).pinned;
+}
+
+/** hasPos(n) @see lib/neatogen/neato.h:hasPos */
+export function hasPos(n: Node): boolean {
+  return dndata(n).pinned > 0;
+}
+
+// ---------------------------------------------------------------------------
+// Derived-edge real-edge list (C overloads ED_to_virt as edge_t**)
+// ---------------------------------------------------------------------------
+
+/** Real edges merged into a derived edge. @see lib/fdpgen/layout.c:addEdge */
+export function realEdges(de: Edge): Edge[] {
+  return (de.info.alg as Edge[] | undefined) ?? [];
+}
+
+/** NEW_EDGE(e) — no real edge recorded yet. @see lib/fdpgen/layout.c:NEW_EDGE */
+export function isNewEdge(de: Edge): boolean {
+  return de.info.alg === undefined;
+}
+
+/**
+ * Add real edge e to its image de in the derived graph.
+ * @see lib/fdpgen/layout.c:addEdge
+ */
+export function addEdge(de: Edge, e: Edge): void {
+  const el = de.info.alg as Edge[] | undefined;
+  if (el === undefined) {
+    de.info.alg = [e];
+  } else {
+    el.push(e);
+  }
+  de.info.count = (de.info.count ?? 0) + 1;
+}
+
+// ---------------------------------------------------------------------------
+// Graph-attribute lookup with parent fallback (agget semantics)
+// ---------------------------------------------------------------------------
+
+/**
+ * agget(g, name): look up an attribute on g, falling back up the parent
+ * chain (derived components resolve attrs copied onto the derived root).
+ * @see lib/cgraph/attr.c:agget
+ */
+export function aggetGraph(g: Graph, name: string): string | undefined {
+  let cur: Graph | null = g;
+  while (cur !== null) {
+    const v = cur.attrs.get(name);
+    if (v !== undefined) return v;
+    cur = cur.parent;
+  }
+  return undefined;
+}

package/src/layout/fdp/grid.ts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Spatial grid used to localise repulsive-force computation: on each
+ * pass nodes are bucketed into cells; repulsion is only computed
+ * against nodes in the 9 adjacent cells.
+ *
+ * Ordering is load-bearing for float reproducibility:
+ * - C's dtwalk over a Dtoset dictionary visits cells in ascending
+ *   (i, j) order (grid.c:ijcmpf) — walk() replicates that sort.
+ * - C prepends nodes to each cell's list (grid.c:newNode), so within a
+ *   cell nodes appear in REVERSE insertion order — add() unshifts.
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/grid.c (15.0.0)
+ */
+
+import type { Node } from '../../model/node.js';
+
+/** One grid cell. @see lib/fdpgen/grid.h:cell */
+export interface Cell {
+  i: number;
+  j: number;
+  /** Nodes in reverse insertion order. @see lib/fdpgen/grid.c:newNode */
+  nodes: Node[];
+}
+
+/**
+ * The grid: cells keyed by (i, j).
+ * Block allocators (newBlock/getCell) are memory management with no
+ * behavioral effect and are not ported.
+ *
+ * @see lib/fdpgen/grid.c:_grid
+ */
+export class Grid {
+  private readonly cells = new Map<string, Cell>();
+
+  /** Reset the grid, reusing storage. @see lib/fdpgen/grid.c:clearGrid */
+  clear(): void {
+    this.cells.clear();
+  }
+
+  /** Add node n to cell (i, j). @see lib/fdpgen/grid.c:addGrid */
+  add(i: number, j: number, n: Node): void {
+    const key = `${i},${j}`;
+    let c = this.cells.get(key);
+    if (c === undefined) {
+      c = { i, j, nodes: [] };
+      this.cells.set(key, c);
+    }
+    c.nodes.unshift(n);
+  }
+
+  /** Cell at (i, j), if any. @see lib/fdpgen/grid.c:findGrid */
+  find(i: number, j: number): Cell | undefined {
+    return this.cells.get(`${i},${j}`);
+  }
+
+  /**
+   * Apply walkf to each cell in ascending (i, j) order — the dtwalk
+   * traversal order of the Dtoset dictionary.
+   * @see lib/fdpgen/grid.c:walkGrid
+   * @see lib/fdpgen/grid.c:ijcmpf
+   */
+  walk(walkf: (c: Cell, g: Grid) => void): void {
+    const sorted = [...this.cells.values()].sort(
+      (a, b) => (a.i - b.i) || (a.j - b.j),
+    );
+    for (const c of sorted) walkf(c, this);
+  }
+}
+
+/** Number of nodes in a cell. @see lib/fdpgen/grid.c:gLength */
+export function gLength(c: Cell): number {
+  return c.nodes.length;
+}

package/src/layout/fdp/index.ts

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * fdp layout engine entry point — the fdp_layout pipeline:
+ * init (clusters, params, nodes/edges) → recursive layout →
+ * aspect/coord sync → straight-line splines → label placement.
+ *
+ * Spec read at the 15.0.0 tag.
+ *
+ * @see lib/fdpgen/layout.c:fdp_layout (15.0.0)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { LayoutEngine } from '../../gvc/context.js';
+import { setEdgeTypeFromAttr } from '../dot/index.js';
+import {
+  EDGETYPE_LINE, EDGETYPE_NONE, splineEdges, injectOraclePositions,
+} from '../neato/splines.js';
+import { neatoSetAspect } from '../neato/init.js';
+import { placeGraphLabel } from '../dot/position-bbox.js';
+import { gvPostprocess } from '../../common/postproc.js';
+import { fdpInitParams } from './tlayout-parms.js';
+import { fdpInitNodeEdge, fdpCleanup } from './init.js';
+import { fdpLayout, mkClusters } from './layout.js';
+import { gdata } from './fdp-model.js';
+import { graphInit } from '../../common/graph-init.js';
+import { csrand } from '../../common/crand.js';
+
+export { fdpLayout, mkClusters, evalPositions, setBB } from './layout.js';
+export { fdpTLayout } from './tlayout.js';
+export { fdpXLayout } from './xlayout.js';
+export { findCComp } from './comp.js';
+export { deriveGraph, type LayoutInfo } from './derive.js';
+export { fdpInitNodeEdge, fdpCleanup } from './init.js';
+export { fdpInitParams, fdpParms } from './tlayout-parms.js';
+
+/**
+ * Graph-level initialization: edge type, gdata, clusters, parameters,
+ * nodes and edges. GD_ndim is fixed at 2 (the "dim" attribute's 3D+
+ * modes are not ported — no supported input sets it).
+ * @see lib/fdpgen/layout.c:fdp_init_graph
+ */
+export function fdpInitGraph(g: Graph): void {
+  // The root graph label is created by the shared graphInit (do_graph_label),
+  // called once from fdpLayoutEngine — C's graph_init runs before fdp_layout.
+  // mkClusters below only labels the *clusters* (layout.c:413), never the root.
+  // setEdgeType FUNCTION (utils.c:1423): reads `splines`, LINE is the default.
+  // @see lib/fdpgen/layout.c:1004
+  setEdgeTypeFromAttr(g, EDGETYPE_LINE);
+  gdata(g); // GD_alg(g) = gv_alloc(sizeof(gdata))
+  mkClusters(g, null, g);
+  fdpInitParams(g);
+  fdpInitNodeEdge(g);
+}
+
+/**
+ * Route edges by the resolved edge type. Compound (cluster) edges and
+ * the HAS_CLUST_EDGE warning path are not ported — no supported input
+ * has cluster-endpoint edges.
+ * @see lib/fdpgen/layout.c:fdpSplines
+ */
+function fdpSplines(g: Graph): void {
+  splineEdges(g); // spline_edges1(g, et) — straight lines + clipping
+}
+
+/**
+ * The complete fdp pipeline.
+ * @see lib/fdpgen/layout.c:fdp_layout
+ */
+export function fdpLayoutEngine(g: Graph): void {
+  // C: gvLayoutJobs runs graph_init(g, LAYOUT_USES_RANKDIR) before fdp_layout.
+  // fdp does not set the flag → useRankdir=false. Creates GD_label(g) too.
+  // @see lib/common/input.c:600, lib/gvc/gvlayout.c:81
+  graphInit(g, false);
+  // fdp never calls srand(); the coincident-node rand() fallback draws from
+  // the process-global libc rand() stream, which is unseeded ⇒ srand(1). Reset
+  // the modeled stream per render so repeated renders in one JS process match
+  // a fresh C process. (fdp placement uses a separate srand48/drand48 stream.)
+  csrand(1);
+  fdpInitGraph(g);
+  if (fdpLayout(g) !== 0) {
+    return;
+  }
+  // T1 injection hook (iterative-parity-campaign): inert unless GVTS_POS_INJECT
+  // is set. fdp does NOT route through neato's spline_edges — it has its own
+  // fdpSplines — so the neato hook is never reached here. This must run BEFORE
+  // neatoSetAspect, which derives coord (points) from pos (inches): routing
+  // reads coord, so injecting after it would be a silent no-op. Mirrors the
+  // native dump site in fdp_layout, between fdpLayout() and neato_set_aspect().
+  // @see lib/fdpgen/layout.c:1062 fdp_layout
+  injectOraclePositions(g);
+  neatoSetAspect(g); // C neato_set_aspect: pos (inches) → coord (points)
+
+  const et = g.info.flags & 0xf;
+  if (et !== EDGETYPE_NONE) fdpSplines(g);
+
+  // C gv_postprocess(g, 0): the drawing is already origin-based (finalCC), so
+  // translation is suppressed — but the pass still runs addXLabels, which is
+  // what positions the *edge* labels under fdp (fdpSplines never sets
+  // ED_label(e)->pos). @see lib/fdpgen/layout.c:1076
+  placeGraphLabel(g);
+  gvPostprocess(g, false);
+}
+
+/**
+ * fdp LayoutEngine plugin for registration with GvcContext.
+ * @see lib/gvc/gvplugin.h:gvlayout_engine_s
+ */
+export const fdpEngine: LayoutEngine = {
+  type: 'fdp',
+  layout(g: Graph): void { fdpLayoutEngine(g); },
+  cleanup(g: Graph): void { fdpCleanup(g); },
+};