@knowvah/dot-engine 0.1.0

package/src/layout/dot/index.ts

@@ -0,0 +1,302 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Dot layout engine entry point.
+ *
+ * Wires together the full dot layout pipeline:
+ *   setAspect → dotInitSubg → dotInitNodeEdge →
+ *   dotRank → dotMincross → dotPosition →
+ *   removeFill → dotSameports → dotSplines → dotCompoundEdges
+ *
+ * Also exports DOT_LAYOUT_ENGINE, the LayoutEngine registration object
+ * used by GvcContext.
+ *
+ * @see lib/dotgen/dotinit.c:dot_layout
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { LayoutEngine } from '../../gvc/context.js';
+import { setAspect } from './aspect.js';
+import { dotRank } from './rank.js';
+import { dotMincross } from './mincross.js';
+import { dotPosition } from './position.js';
+import { dotSameports } from './sameport.js';
+import { dotSplines } from './splines.js';
+import { dotCompoundEdges } from './compound.js';
+import { mapbool } from './rank.js';
+import { EDGETYPE_SPLINE, EDGETYPE_NONE, edgeTypeFromString } from './splines.js';
+import {
+  dotInitSubg,
+  dotInitNodeEdge,
+  removeFill,
+  dotCleanup,
+  dotGraphInit,
+} from './init.js';
+import { gvPostprocess } from '../../common/postproc.js';
+import {
+  getPack, getPackModeInfo, getPackInfo, PackMode,
+} from '../pack/index.js';
+import type { PackInfo } from '../pack/index.js';
+import { ratioIsNone, layoutAndPack, cccompsWithClusters } from './pack-components.js';
+
+// Re-export init helpers for external consumers.
+export {
+  CL_CROSS,
+  dotInitNode,
+  dotInitEdge,
+  dotInitSubg,
+  dotInitNodeEdge,
+  removeFill,
+  dotCleanup,
+  dotGraphInit,
+  RANKDIR_TB,
+  RANKDIR_LR,
+  RANKDIR_BT,
+  RANKDIR_RL,
+} from './init.js';
+
+// ---------------------------------------------------------------------------
+// setEdgeType — writes EDGETYPE into the low nibble of GD_flags
+// @see lib/common/const.h:setEdgeType
+// ---------------------------------------------------------------------------
+
+/**
+ * Stores the edge-type flag in the low 4 bits of g.info.flags.
+ * Mirrors the C macro setEdgeType(g, t).
+ *
+ * @see lib/common/const.h:setEdgeType
+ */
+export function setEdgeType(g: Graph, t: number): void {
+  g.info.flags = (g.info.flags & ~0xf) | (t & 0xf);
+}
+
+/**
+ * Set the edge type from the graph's `splines` attribute: unset → defaultValue,
+ * empty string → NONE, otherwise the parsed value. Mirrors C's setEdgeType
+ * (which reads `agget(g, "splines")`). @see lib/common/utils.c:setEdgeType
+ *
+ * C's `agget` resolves a graph attribute up the ancestor chain, so a component
+ * subgraph sees the root's `splines`. The port's `attrs` map holds only the
+ * attributes written on that graph, so walk to the root ourselves — otherwise
+ * the per-component call sites (neato's `gc`, sfdp's `sg`) read `undefined` and
+ * silently fall back to the default.
+ */
+export function setEdgeTypeFromAttr(g: Graph, defaultValue: number): void {
+  let s = g.attrs.get('splines');
+  for (let p = g.parent; s === undefined && p !== null; p = p.parent) {
+    s = p.attrs.get('splines');
+  }
+  let et: number;
+  if (s === undefined) et = defaultValue;
+  else if (s === '') et = EDGETYPE_NONE;
+  else et = edgeTypeFromString(s, defaultValue);
+  setEdgeType(g, et);
+}
+
+// ---------------------------------------------------------------------------
+// getAttrInt — attribute reading helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Reads an integer graph attribute, returning defaultVal if not set.
+ * Mirrors late_int() from lib/common/utils.c for graph-level reads.
+ *
+ * @see lib/common/utils.c:late_int
+ */
+export function getAttrInt(g: Graph, key: string, defaultVal: number): number {
+  const v = g.attrs.get(key);
+  if (v === undefined || v === '') return defaultVal;
+  const n = parseInt(v, 10);
+  return isNaN(n) ? defaultVal : n;
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline phase helpers — each phase is its own function so that
+// dotLayoutPipeline stays within the 30-line body limit.
+// ---------------------------------------------------------------------------
+
+/**
+ * Phase 0: parse rankdir, set edge type, and run aspect + init passes.
+ * dotGraphInit must run first so g.info.flip is set before nodeinit uses it.
+ * @see lib/common/input.c:600-663 graph_init
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+export function dotPhaseInit(g: Graph): void {
+  dotGraphInit(g);
+  setEdgeTypeFromAttr(g, EDGETYPE_SPLINE);
+  setAspect(g);
+  dotInitSubg(g);
+  dotInitNodeEdge(g);
+}
+
+/**
+ * Phase 4a: post-position passes WITHOUT the final gvPostprocess —
+ * removeFill, sameports, splines, compound. This is C's static `dotLayout`
+ * tail; the per-component pack branch runs exactly this (gvPostprocess is run
+ * once on the root afterwards, not per component).
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+export function dotPhasePostNoFinish(g: Graph): void {
+  removeFill(g);
+  dotSameports(g);
+  dotSplines(g);
+  // C: if (mapbool(agget(g, "compound"))) dot_compoundEdges(g);
+  // agget on a pack-branch component subgraph (_cc_N) falls back to the
+  // attribute default declared by the root's `compound=true`, so C's gate
+  // passes per component; mirror that with a root fallback (local wins).
+  // @see lib/dotgen/dotinit.c:338
+  if (mapbool(g.attrs.get('compound') ?? g.root.attrs.get('compound'))) dotCompoundEdges(g);
+}
+
+/**
+ * Phase 4: post-position passes — the no-finish tail plus gvPostprocess to
+ * rotate/translate coordinates per rankdir.
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ * @see lib/common/postproc.c:dotneato_postprocess
+ */
+export function dotPhasePost(g: Graph): void {
+  dotPhasePostNoFinish(g);
+  gvPostprocess(g);
+}
+
+// ---------------------------------------------------------------------------
+// dotLayoutPipeline — the static dotLayout function from dotinit.c
+// ---------------------------------------------------------------------------
+
+/**
+ * Runs the full dot layout pipeline on graph g.
+ *
+ * The optional `maxphase` attribute (read from g.attrs) controls how many
+ * phases run (1=rank only, 2=+mincross, 3=+position, ≥4 or absent=all).
+ *
+ * C's `dotLayout` checks `dot_mincross`'s return code and returns immediately
+ * on failure, skipping `dot_position` (phase 3) and `dotneato_postprocess`
+ * entirely — `dot_position` is never reached with a rank/cluster-window state
+ * that `dot_mincross` has already given up on (e.g. a cluster's rank window
+ * outliving root's rank-array allocation after malformed-input rankset
+ * recovery deletes cluster members but leaves the window unshrunk). The port
+ * previously discarded `dotMincross`'s return value and always ran
+ * `dotPosition` regardless, so `dotPosition` could observe exactly that
+ * unreachable-in-C state and crash (e.g. `position-ycoords.ts:clustHt`
+ * indexing the root rank array one past its allocated length).
+ * @see lib/dotgen/dotinit.c:dotLayout (static) — `if (rc != 0) return rc;`
+ *   after `dot_mincross`, propagated through `doDot`/`dot_layout` to also
+ *   skip `dotneato_postprocess`.
+ *
+ * C applies the identical `if (r != 0) return r;` check after `dot_position`
+ * (dotinit.c:322-325), also skipping `dotPhasePost` (removeFill/sameports/
+ * splines/compound) and `gvPostprocess`. `dot_position` fails when
+ * `dot_concentrate` fails (`rebuild_vlists: lead is null for rank N`, e.g.
+ * corpus 2825 — a cross-cluster rank=same plus rankset-conflict deletions
+ * leaves a cluster rank with no rankleader); C's renderer then walks the
+ * still-fully-connected `Agraph_t` but every node fails `node_in_box`
+ * against the never-computed (all-zero) `GD_bb`, so only cluster frames
+ * (also zero-sized, since `set_aspect`/cluster geometry never ran) reach
+ * the page. The port previously discarded `dotPosition`'s return value and
+ * always ran `dotPhasePost`, producing a full (non-degenerate) rendering
+ * where C produces near-empty output.
+ */
+export function dotLayoutPipeline(g: Graph): void {
+  const maxphase = getAttrInt(g, 'maxphase', -1);
+  dotPhaseInit(g);
+  dotRank(g);
+  if (maxphase === 1) return;
+  const rc = dotMincross(g);
+  if (rc !== 0) return;
+  if (maxphase === 2) return;
+  const posRc = dotPosition(g);
+  if (posRc !== 0) return;
+  if (maxphase === 3) return;
+  dotPhasePost(g);
+}
+
+// ---------------------------------------------------------------------------
+// doDot — the pack-aware layout dispatcher
+// @see lib/dotgen/dotinit.c:doDot
+// ---------------------------------------------------------------------------
+
+/** Offset/margin default for packing, in points. @see lib/pack/pack.h:CL_OFFSET */
+const CL_OFFSET = 8;
+
+/** A zeroed PackInfo the getPack* readers fill in. @see lib/pack/pack.h:pack_info */
+function newPackInfo(): PackInfo {
+  return {
+    aspect: 1, sz: 0, margin: CL_OFFSET, doSplines: false,
+    mode: PackMode.Node, fixed: null, vals: null, flags: 0,
+  };
+}
+
+/**
+ * Port of C's `doDot`: when `pack`/`packmode` is set, decompose the graph into
+ * connected components, lay out each one, and polyomino-pack them; otherwise
+ * (and for a single component, or a non-R_NONE ratio) fall back to whole-graph
+ * `dotLayoutPipeline`. The thin component loop + cluster carry live in
+ * pack-components.ts (ADR-1). `dotLayoutPipeline` already includes the root
+ * `gvPostprocess`, so the simple arms map exactly to C's `dotLayout(g)` +
+ * `dotneato_postprocess(g)`; the pack arm runs `gvPostprocess` once inside
+ * `layoutAndPack`.
+ *
+ * @see lib/dotgen/dotinit.c:doDot
+ */
+export function doDot(g: Graph): void {
+  const pinfo = newPackInfo();
+  const Pack = getPack(g, -1, CL_OFFSET);
+  const mode = getPackModeInfo(g, PackMode.Undef, pinfo);
+  getPackInfo(g, PackMode.Node, CL_OFFSET, pinfo);
+  // No pack information: old dot with components handled during layout.
+  if (mode === PackMode.Undef && Pack < 0) {
+    dotLayoutPipeline(g);
+    return;
+  }
+  // Fill in default values (C doDot: l_undef → l_graph; Pack<0 → CL_OFFSET).
+  let pack = Pack;
+  if (mode === PackMode.Undef) pinfo.mode = PackMode.Graph;
+  else if (pack < 0) pack = CL_OFFSET;
+  pinfo.margin = pack; // pack >= 0 here
+  pinfo.fixed = null;
+  // Cluster-aware decomposition: cluster members stay in one component, and each
+  // component carries a clone of its clusters/same-rank sets (C's cccomps).
+  const { comps, origOf } = cccompsWithClusters(g);
+  if (comps.length === 1) {
+    dotLayoutPipeline(g);
+  } else if (ratioIsNone(g)) {
+    pinfo.doSplines = true;
+    layoutAndPack(g, comps, pinfo, origOf);
+  } else {
+    // Non-trivial ratio with multiple components: C lays out the whole graph.
+    dotLayoutPipeline(g);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// dotLayoutEntry — the public LayoutEngine.layout function
+// ---------------------------------------------------------------------------
+
+/**
+ * LayoutEngine.layout implementation for the dot engine.
+ * Skips empty graphs (matching C's agnnodes(g) guard).
+ *
+ * @see lib/dotgen/dotinit.c:dot_layout
+ */
+export function dotLayoutEntry(g: Graph): void {
+  if (g.nodes.size === 0) return;
+  doDot(g);
+}
+
+// ---------------------------------------------------------------------------
+// DOT_LAYOUT_ENGINE — registration object
+// ---------------------------------------------------------------------------
+
+/**
+ * The dot layout engine registration object.
+ * Register with GvcContext.register(DOT_LAYOUT_ENGINE).
+ *
+ * @see lib/gvc/gvplugin.h:gvlayout_engine_s
+ * @see lib/dotgen/dotinit.c:dot_layout
+ */
+export const DOT_LAYOUT_ENGINE: LayoutEngine = {
+  type: 'dot',
+  layout: dotLayoutEntry,
+  cleanup: dotCleanup,
+};

package/src/layout/dot/init.ts

@@ -0,0 +1,300 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * TypeScript port of lib/dotgen/dotinit.c — initialisation helpers for
+ * the dot layout pipeline (dot_init_node, dot_init_edge, dot_init_subg,
+ * dot_init_node_edge, removeFill, dot_cleanup).
+ *
+ * @see lib/dotgen/dotinit.c
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import { commonInitNode, lateInt } from '../../common/nodeinit.js';
+import { nonconstraintEdge } from './classify.js';
+import { nodeAttr } from '../../common/poly-init.js';
+import { NORMAL, deleteFastNode, removeFromRank } from './fastgr.js';
+import { mapbool } from './rank.js';
+import { initEdgeLabels } from '../../common/edge-label-init.js';
+import { graphInit } from '../../common/graph-init.js';
+import { agsubg, agdelnode, agdelsubg } from '../../model/cgraph-ops.js';
+import { nodesInSeq } from './decomp.js';
+
+// ---------------------------------------------------------------------------
+// RANKDIR constants — re-exported from the shared graph_init port, which owns
+// them (they are const.h values, not dot's). Kept exported here so the existing
+// importers (postproc, compass-port, splines-flat, …) do not have to churn.
+// @see lib/common/const.h RANKDIR_TB/LR/BT/RL
+// ---------------------------------------------------------------------------
+
+export { RANKDIR_TB, RANKDIR_LR, RANKDIR_BT, RANKDIR_RL } from '../../common/graph-init.js';
+
+// ---------------------------------------------------------------------------
+// dotGraphInit — dot's binding of the shared graph_init
+// @see lib/common/input.c:600 graph_init
+// @see lib/dotgen/dotinit.c:352 initSubg (GD_rankdir2 propagation)
+// ---------------------------------------------------------------------------
+
+/**
+ * dot's call into the engine-agnostic `graph_init`, plus the one piece of
+ * rankdir handling that is genuinely dot's: propagating GD_rankdir2 down to the
+ * clusters (C does this in dot's own `initSubg`, dotinit.c:352 — NOT in
+ * graph_init).
+ *
+ * dot is the only engine with `LAYOUT_USES_RANKDIR`
+ * (plugin/dot_layout/gvlayout_dot_layout.c:27), hence `useRankdir = true`: the
+ * effective rankdir (bits 0-1) tracks the attr instead of being pinned to TB.
+ *
+ * @see lib/common/input.c:600 graph_init
+ * @see lib/gvc/gvlayout.c:81 (graph_init(g, LAYOUT_USES_RANKDIR))
+ * @see lib/dotgen/dotinit.c:352 initSubg
+ */
+export function dotGraphInit(g: Graph): void {
+  graphInit(g, true);
+  initSubgraphRankdir(g);
+}
+
+/**
+ * Recursively propagate the root graph's rankdir2 to all subgraphs.
+ * @see lib/dotgen/dotinit.c:352
+ */
+function initSubgraphRankdir(g: Graph): void {
+  const nc = g.info.n_cluster ?? 0;
+  const clust = g.info.clust;
+  for (let c = 1; c <= nc; c++) {
+    if (clust && clust[c - 1]) {
+      const sg = clust[c - 1];
+      sg.info.rankdir = g.info.rankdir;
+      sg.info.flip = g.info.flip;
+      initSubgraphRankdir(sg);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CL_CROSS — cost of cluster skeleton edge crossing
+// @see lib/common/const.h:CL_CROSS
+// ---------------------------------------------------------------------------
+
+/**
+ * Crossing penalty for cluster-skeleton / same-group edges.
+ * C uses 1000 except under _WIN32, where 100 avoids a 16-bit overflow.
+ * The oracle platform (and every modern build) takes the 1000 branch;
+ * mincross best-order selection on penalty plateaus depends on it.
+ * @see lib/common/const.h:CL_CROSS
+ */
+export const CL_CROSS = 1000;
+
+// ---------------------------------------------------------------------------
+// dotInitNode
+// ---------------------------------------------------------------------------
+
+/**
+ * Initialises per-node layout data for the dot engine.
+ * Mirrors dot_init_node: binds Agnodeinfo_t and allocates edge lists.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_node
+ */
+export function dotInitNode(n: Node): void {
+  n.info.UF_size = 1;
+  if (!n.info.in)       n.info.in       = { list: [], size: 0 };
+  if (!n.info.out)      n.info.out      = { list: [], size: 0 };
+  if (!n.info.flat_in)  n.info.flat_in  = { list: [], size: 0 };
+  if (!n.info.flat_out) n.info.flat_out = { list: [], size: 0 };
+  if (!n.info.other)    n.info.other    = { list: [], size: 0 };
+  // Default lw = rw = 0.75in/2 × 72 = 27 pts; ht = 0.5in × 72 = 36 pts. C's
+  // dot_init_node has no such fallback (gv_nodesize always sets a size); this is
+  // only a guard for a node that reached here UNSIZED. Test `=== undefined`, not
+  // falsiness, so a legitimately-computed 0 (shape=plain) is not clobbered.
+  if (n.info.lw === undefined) n.info.lw = 27;
+  if (n.info.rw === undefined) n.info.rw = 27;
+  if (n.info.ht === undefined) n.info.ht = 36;
+  // Mark as a real (NORMAL) node so firstNormalNode() can find it.
+  n.info.node_type = NORMAL;
+}
+
+// ---------------------------------------------------------------------------
+// dotInitEdge
+// ---------------------------------------------------------------------------
+
+/**
+ * True when tail and head carry the same non-empty `group` attribute.
+ * C compares interned refstr pointers (`tailgroup == headgroup`); cgraph's
+ * per-graph string pool makes that exactly content equality, and the
+ * `tailgroup[0]` guard excludes the shared "" default.
+ * @see lib/dotgen/dotinit.c:dot_init_edge (tailgroup/headgroup check)
+ */
+export function sameNonemptyGroup(e: Edge): boolean {
+  const tailgroup = nodeAttr(e.tail, e.tail.root, 'group') ?? '';
+  const headgroup = nodeAttr(e.head, e.head.root, 'group') ?? '';
+  return tailgroup !== '' && tailgroup === headgroup;
+}
+
+/**
+ * Reads the `constraint` edge attr and stores the parsed boolean on e.info.
+ * Absent or empty attr leaves e.info.constraint unchanged (C: constr[0] guard).
+ * @see lib/dotgen/rank.c:is_nonconstraint
+ * @see lib/common/utils.c:mapbool
+ */
+function initEdgeConstraint(e: Edge): void {
+  const s = e.attrs.get('constraint');
+  if (s !== undefined && s !== '') e.info.constraint = mapbool(s);
+}
+
+/**
+ * Applies the same-group penalty to xpenalty and weight.
+ * @see lib/dotgen/dotinit.c:dot_init_edge (tailgroup/headgroup block)
+ */
+function applyGroupPenalty(e: Edge): void {
+  if (!sameNonemptyGroup(e)) return;
+  e.info.xpenalty = CL_CROSS;
+  e.info.weight = (e.info.weight ?? 1) * 100;
+}
+
+/**
+ * Zeroes xpenalty and weight when the edge is a non-constraint edge.
+ * @see lib/dotgen/dotinit.c:dot_init_edge:73-76
+ */
+function applyNonconstraintZero(e: Edge): void {
+  if (!nonconstraintEdge(e)) return;
+  e.info.xpenalty = 0;
+  e.info.weight = 0;
+}
+
+/**
+ * Initialises per-edge layout data for the dot engine.
+ * Mirrors dot_init_edge: sets weight, count, xpenalty, minlen.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_edge
+ */
+export function dotInitEdge(e: Edge): void {
+  initEdgeConstraint(e);
+  // C: ED_weight(e) = late_int(e, E_weight, 1, 0) — honor an explicit weight
+  // attr (default 1, min 0). dotInitEdge is re-run on edges the flat-label
+  // machinery has stamped with a synthetic weight (e.g. 10000); preserve that
+  // when there is no attr, rather than resetting to the default. The group/
+  // nonconstraint adjustments below then apply on top, matching C's order.
+  // @see lib/dotgen/dotinit.c:65
+  e.info.weight = e.attrs.has('weight')
+    ? lateInt(e.attrs.get('weight'), 1, 0)
+    : (e.info.weight ?? 1);
+  e.info.count = 1;
+  e.info.xpenalty = 1;
+  applyGroupPenalty(e);
+  applyNonconstraintZero(e);
+  // late_int semantics: default 1, minimum 0.
+  // @see lib/dotgen/dotinit.c:85  ED_minlen(e) = late_int(e, E_minlen, 1, 0)
+  e.info.minlen = lateInt(e.attrs.get('minlen'), 1, 0);
+  // samehead / sametail group ids for shared-port merging. C reads these via
+  // agxget(e, E_samehead/E_sametail) in dot_sameports and treats an empty
+  // string (id[0] == '\0') as "no group". Without populating these, the ported
+  // dotSameports (wired in index.ts) never fires and same-* edges route to the
+  // node center instead of a merged port. @see lib/dotgen/sameport.c:dot_sameports
+  const sh = e.attrs.get('samehead');
+  e.info.samehead = sh ? sh : undefined;
+  const st = e.attrs.get('sametail');
+  e.info.sametail = st ? st : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// dotInitSubg
+// ---------------------------------------------------------------------------
+
+/**
+ * Recursively initialises subgraph-level attributes with defaults.
+ * Mirrors dot_init_subg: binds Agraphinfo_t and propagates params.
+ *
+ * nodesep defaults: 0.25 in × 72 = 18 pts; ranksep: 0.5 in × 72 = 36 pts.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_subg
+ */
+export function dotInitSubg(g: Graph): void {
+  if (g.info.nodesep === undefined) g.info.nodesep = 18;
+  if (g.info.ranksep === undefined) g.info.ranksep = 36;
+  const nc = g.info.n_cluster ?? 0;
+  const clust = g.info.clust;
+  for (let c = 1; c <= nc; c++) {
+    if (clust && clust[c - 1]) dotInitSubg(clust[c - 1]);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// dotInitNodeEdge
+// ---------------------------------------------------------------------------
+
+/**
+ * Calls commonInitNode (shape-aware, label-driven sizing) then
+ * dotInitNode for every node, then dotInitEdge for every edge.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_node_edge
+ * @see lib/dotgen/dotinit.c:dot_init_node (common_init_node + gv_nodesize)
+ */
+export function dotInitNodeEdge(g: Graph): void {
+  for (const n of nodesInSeq(g)) {
+    commonInitNode(n, g);
+    dotInitNode(n);
+  }
+  const measurer = g.root.info.gvc?.textMeasurer;
+  for (const e of g.edges) {
+    dotInitEdge(e);
+    if (measurer) initEdgeLabels(e, g, measurer);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// removeFill
+// ---------------------------------------------------------------------------
+
+/**
+ * Deletes the placeholder fill-nodes inserted by fillRanks (NEW_RANK mode)
+ * once positioning is done, so they never render. Looks up the `_new_rank`
+ * subgraph under the root graph; if absent (the common no-newrank case) this
+ * is a no-op. Operates on `g.root` throughout because fillRanks created the
+ * fill nodes and their ranks under the root.
+ *
+ * @see lib/dotgen/dotinit.c:removeFill
+ */
+export function removeFill(g: Graph): void {
+  const sg = agsubg(g.root, '_new_rank', false);
+  if (sg === null) return;
+  // Snapshot first: agdelnode mutates membership (including sg) during the
+  // loop. C's nxt = agnxtnode look-ahead tolerates deleting the current node;
+  // the snapshot is its faithful equivalent.
+  const fillNodes = nodesInSeq(sg);
+  for (const n of fillNodes) {
+    deleteFastNode(g.root, n);
+    removeFromRank(g.root, n);
+    // dot_cleanup_node has no equivalent in this port (GC reclaims the node).
+    agdelnode(g.root, n);
+  }
+  agdelsubg(g.root, sg);
+}
+
+// ---------------------------------------------------------------------------
+// dotCleanup
+// ---------------------------------------------------------------------------
+
+/**
+ * Clears all edge lists and linked-list pointers from nodes in the fast-graph,
+ * releasing layout state without destroying the underlying graph structure.
+ *
+ * Mirrors dot_cleanup: frees virtual node list then per-node edge lists.
+ *
+ * @see lib/dotgen/dotinit.c:dot_cleanup
+ */
+export function dotCleanup(g: Graph): void {
+  let n: Node | undefined = g.info.nlist;
+  while (n !== undefined) {
+    const next: Node | undefined = n.info.next;
+    n.info.in       = undefined;
+    n.info.out      = undefined;
+    n.info.flat_in  = undefined;
+    n.info.flat_out = undefined;
+    n.info.other    = undefined;
+    n.info.next     = undefined;
+    n.info.prev     = undefined;
+    n = next;
+  }
+  g.info.nlist = undefined;
+}