@knowvah/dot-engine 0.1.0

package/src/layout/circo/blocks.ts

@@ -0,0 +1,234 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Core block and derived-graph data structures for the circo layout engine.
+ *
+ * Ports the type definitions from lib/circogen/block.h, lib/circogen/circular.h,
+ * and the DerivedGraph/DerivedNode/DerivedEdge helpers used across all passes.
+ *
+ * Also holds CircoCData (cdata) here to avoid a circular import with init.ts:
+ * cdata needs a back-reference to DerivedNode, so both must live in the same
+ * module.
+ *
+ * @see lib/circogen/block.h
+ * @see lib/circogen/circular.h
+ */
+
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+
+// ---------------------------------------------------------------------------
+// Flag constants for CircoCData.flags
+// @see lib/circogen/circular.h
+// ---------------------------------------------------------------------------
+
+export const FLAGS_VISITED = 0x01;
+export const FLAGS_ONSTACK = 0x02;
+export const FLAGS_ISPARENT = 0x04;
+export const FLAGS_ONPATH = 0x08;
+export const FLAGS_NEIGHBOR = 0x10;
+
+// ---------------------------------------------------------------------------
+// CircoCData — rich per-node layout data on derived-graph nodes (Passes 1–4)
+// @see lib/circogen/circular.h:cdata
+// ---------------------------------------------------------------------------
+
+/**
+ * Rich algorithm data stored on derived-graph nodes across Passes 1–4.
+ * Fields are reused across passes (mirrors the C union in cdata).
+ *
+ * @see lib/circogen/circular.h:cdata
+ */
+export interface CircoCData {
+  readonly kind: 'circo-cdata';
+  flags: number;
+  /** DFS parent (Pass 1). @see PARENT(n) */
+  parent: DerivedNode | null;
+  /** Block containing this node. @see BLOCK(n) */
+  block: unknown;
+  /** Biconnectivity fields (Pass 1). @see VAL(n), LOWVAL(n) */
+  bc: { val: number; lowVal: number };
+  /** Clone pointer (Pass 3a). @see CLONE(n) */
+  clone: Node | null;
+  /** Spanning-tree parent (Pass 3b). @see TPARENT(n) */
+  tparent: CircoCData | null;
+  leafone: CircoCData | null;
+  leaftwo: CircoCData | null;
+  fdist: number;
+  sdist: number;
+  /** Circle position index (Pass 3c/4). @see POSITION(n) */
+  pos: number;
+  /** Child-block mid-angle (Pass 4). @see PSI(n) */
+  psi: number;
+  /** Degree counter (reuses ND_order slot). @see DEGREE(n) */
+  degree: number;
+  /** Back-reference to the DerivedNode that owns this cdata. */
+  derivedNode: DerivedNode;
+}
+
+// ---------------------------------------------------------------------------
+// SubGraph / DerivedGraph / DerivedNode / DerivedEdge
+// ---------------------------------------------------------------------------
+
+/** Lightweight subgraph used in the derived graph for circo. */
+export interface SubGraph {
+  name: string;
+  nodes: DerivedNode[];
+  edges: DerivedEdge[];
+  parent: DerivedGraph;
+}
+
+/** Strict undirected derived graph built in Pass 0. */
+export interface DerivedGraph {
+  nodes: Map<string, DerivedNode>;
+  subgraphs: SubGraph[];
+  components: SubGraph[];
+}
+
+/** Node in the derived graph with cdata attached. */
+export interface DerivedNode {
+  name: string;
+  orig: Node;
+  pos: [number, number];
+  cdata: CircoCData;
+  lw: number;
+  rw: number;
+  ht: number;
+}
+
+/** Edge in the derived graph. */
+export interface DerivedEdge {
+  tail: DerivedNode;
+  head: DerivedNode;
+  /** +1 tail→head, -1 head→tail, 0 = unset. @see EDGEORDER(e) */
+  order: number;
+  origEdge: Edge | null;
+}
+
+// ---------------------------------------------------------------------------
+// Block — biconnected component
+// @see lib/circogen/block.h:block_t
+// ---------------------------------------------------------------------------
+
+const COALESCED_F = 1;
+
+/**
+ * One biconnected component (or isolated node).
+ * @see lib/circogen/block.h:block_t
+ */
+export interface Block {
+  subGraph: SubGraph;
+  radius: number;
+  rad0: number;
+  circleList: Node[];
+  children: Block[];
+  /** Parent-connection angle for single-node blocks; -1 = unset. */
+  parentPos: number;
+  flags: number;
+  /** Cutpoint node connecting this block to its parent block. */
+  child: Node | null;
+}
+
+/** @see lib/circogen/block.c:mkBlock */
+export function mkBlock(sg: SubGraph): Block {
+  return {
+    subGraph: sg,
+    radius: 0,
+    rad0: 0,
+    circleList: [],
+    children: [],
+    parentPos: -1,
+    flags: 0,
+    child: null,
+  };
+}
+
+/** @see lib/circogen/block.c:blockSize */
+export function blockSize(bp: Block): number {
+  return bp.subGraph.nodes.length;
+}
+
+/** @see lib/circogen/block.c:appendBlock */
+export function appendBlock(bl: Block[], bp: Block): void {
+  bl.push(bp);
+}
+
+/** @see lib/circogen/block.c:insertBlock */
+export function insertBlock(bl: Block[], bp: Block): void {
+  bl.unshift(bp);
+}
+
+/** @see lib/circogen/block.h:SET_COALESCED */
+export function setCoalesced(bp: Block): void {
+  bp.flags |= COALESCED_F;
+}
+
+/** @see lib/circogen/block.h:COALESCED */
+export function isCoalesced(bp: Block): boolean {
+  return (bp.flags & COALESCED_F) !== 0;
+}
+
+/**
+ * The node in the PARENT block this block hangs from:
+ * BLK_PARENT(b) = CHILD(b) ? PARENT(CHILD(b)) : 0.
+ * @see lib/circogen/block.h:BLK_PARENT
+ */
+export function blkParent(bp: Block): Node | null {
+  if (!bp.child) return null;
+  const cd = bp.child.info.alg as CircoCData | undefined;
+  if (cd?.kind !== 'circo-cdata') return null;
+  return cd.parent?.orig ?? null;
+}
+
+// ---------------------------------------------------------------------------
+// CircState — layout state threaded through all passes
+// @see lib/circogen/circular.h:circ_state
+// ---------------------------------------------------------------------------
+
+/** @see lib/circogen/circular.h:circ_state */
+export interface CircState {
+  bl: Block[];
+  orderCount: number;
+  blockCount: number;
+  graphCopyCount: number;
+  spanningTreeCount: number;
+  minDist: number;
+  rootname: string;
+}
+
+const MINDIST = 1.0;
+
+/** @see lib/circogen/circular.c:initGraphAttrs */
+export function makeCircState(blockCount: number): CircState {
+  return {
+    bl: [],
+    orderCount: 1,
+    blockCount,
+    graphCopyCount: 0,
+    spanningTreeCount: 0,
+    minDist: MINDIST,
+    rootname: '',
+  };
+}
+
+/** Create a zero-initialised CircoCData for a given DerivedNode. */
+export function makeCData(dn: DerivedNode): CircoCData {
+  // Temporarily assign; derivedNode is set by caller after construction.
+  return {
+    kind: 'circo-cdata',
+    flags: 0,
+    parent: null,
+    block: null,
+    bc: { val: 0, lowVal: 0 },
+    clone: null,
+    tparent: null,
+    leafone: null,
+    leaftwo: null,
+    fdist: 0,
+    sdist: 0,
+    pos: 0,
+    psi: 0,
+    degree: 0,
+    derivedNode: dn,
+  };
+}

package/src/layout/circo/blocktree.ts

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Biconnected-component decomposition and block-cutpoint tree construction.
+ *
+ * Ports lib/circogen/blocktree.c.
+ *
+ * @see lib/circogen/blocktree.c
+ */
+
+import type { DerivedNode, DerivedEdge, DerivedGraph, SubGraph } from './blocks.js';
+import { spanIncident } from './blockpath.js';
+import {
+  type Block,
+  type CircState,
+  mkBlock,
+  blockSize,
+  appendBlock,
+  insertBlock,
+} from './blocks.js';
+import { FLAGS_ISPARENT } from './blocks.js';
+
+// All interfaces at top-level so lizard doesn't count them inside functions.
+
+/** DFS context object — avoids passing many params through recursive calls. */
+export interface DfsCtx {
+  g: SubGraph;
+  state: CircState;
+  allEdges: DerivedEdge[];
+  stk: DerivedEdge[];
+  /** Derived-node creation order — agfstedge sort key. */
+  ord: Map<DerivedNode, number>;
+  /** Derived-edge creation order — agfstedge tie key. */
+  seq: Map<DerivedEdge, number>;
+}
+
+// ---------------------------------------------------------------------------
+// Subgraph / block factories
+// ---------------------------------------------------------------------------
+
+export function makeBlockSubgraph(dg: DerivedGraph, state: CircState): SubGraph {
+  const name = `_block_${state.blockCount++}`;
+  const sg: SubGraph = { name, nodes: [], edges: [], parent: dg };
+  dg.subgraphs.push(sg);
+  return sg;
+}
+
+export function makeBlock(dg: DerivedGraph, state: CircState): Block {
+  return mkBlock(makeBlockSubgraph(dg, state));
+}
+
+export function addNodeToBlock(bp: Block, n: DerivedNode): void {
+  bp.subGraph.nodes.push(n);
+  n.cdata.block = bp;
+}
+
+// ---------------------------------------------------------------------------
+// DFS edge-stack helpers
+// ---------------------------------------------------------------------------
+
+export function popEdgesUntil(stk: DerivedEdge[], e: DerivedEdge): DerivedEdge[] {
+  const popped: DerivedEdge[] = [];
+  let ep: DerivedEdge;
+  do {
+    ep = stk[stk.length - 1]!;
+    stk.pop();
+    popped.push(ep);
+  } while (ep !== e);
+  return popped;
+}
+
+export function buildBlockFromEdges(
+  dg: DerivedGraph,
+  state: CircState,
+  popped: DerivedEdge[],
+  u: DerivedNode,
+): Block | null {
+  let block: Block | null = null;
+  for (const ep of popped) {
+    const np = ep.order === 1 ? ep.head : ep.tail;
+    if (np.cdata.block === null) {
+      if (block === null) block = makeBlock(dg, state);
+      addNodeToBlock(block, np);
+    }
+  }
+  if (block !== null && u.cdata.block === null && blockSize(block) > 1) {
+    addNodeToBlock(block, u);
+  }
+  return block;
+}
+
+export function placeBlock(
+  state: CircState,
+  block: Block,
+  u: DerivedNode,
+  isRoot: boolean,
+): void {
+  if (isRoot && u.cdata.block === block) {
+    insertBlock(state.bl, block);
+  } else {
+    appendBlock(state.bl, block);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// DFS — Tarjan biconnected components
+// @see lib/circogen/blocktree.c:dfs
+// ---------------------------------------------------------------------------
+
+export function processArticulation(
+  ctx: DfsCtx,
+  u: DerivedNode,
+  v: DerivedNode,
+  e: DerivedEdge,
+  isRoot: boolean,
+): void {
+  if (v.cdata.bc.lowVal < u.cdata.bc.val) return;
+  const popped = popEdgesUntil(ctx.stk, e);
+  const block = buildBlockFromEdges(ctx.g.parent, ctx.state, popped, u);
+  if (block !== null) placeBlock(ctx.state, block, u, isRoot);
+}
+
+export function dfsVisitEdge(
+  ctx: DfsCtx,
+  u: DerivedNode,
+  e: DerivedEdge,
+  isRoot: boolean,
+): void {
+  const v = e.head === u ? e.tail : e.head;
+  if (e.order === 0) e.order = e.head === u ? -1 : 1;
+  if (v.cdata.bc.val === 0) {
+    v.cdata.parent = u;
+    ctx.stk.push(e);
+    dfsVisit(ctx, v, false);
+    u.cdata.bc.lowVal = Math.min(u.cdata.bc.lowVal, v.cdata.bc.lowVal);
+    processArticulation(ctx, u, v, e, isRoot);
+  } else if (v !== u.cdata.parent) {
+    u.cdata.bc.lowVal = Math.min(u.cdata.bc.lowVal, v.cdata.bc.val);
+  }
+}
+
+export function dfsVisit(ctx: DfsCtx, u: DerivedNode, isRoot: boolean): void {
+  u.cdata.bc.val = ctx.state.orderCount;
+  u.cdata.bc.lowVal = ctx.state.orderCount;
+  ctx.state.orderCount++;
+  // C dfs iterates agfstedge(g, u) — u's incident edges in (other-endpoint,
+  // seq) order, not the flat edge list. The DISCOVERY order decides the
+  // block-tree child order, which assigns each satellite block its angular
+  // slot around the cut vertex. @see lib/circogen/blocktree.c:62
+  const uEdges = spanIncident(u, ctx.allEdges, ctx.ord, ctx.seq);
+  for (const e of uEdges) dfsVisitEdge(ctx, u, e, isRoot);
+  if (isRoot && u.cdata.block === null) {
+    const block = makeBlock(ctx.g.parent, ctx.state);
+    addNodeToBlock(block, u);
+    insertBlock(ctx.state.bl, block);
+  }
+}
+
+export function findBlocks(
+  g: SubGraph,
+  state: CircState,
+  allEdges: DerivedEdge[],
+): void {
+  let root: DerivedNode | null = null;
+  if (state.rootname) root = g.parent.nodes.get(state.rootname) ?? null;
+  if (!root && g.nodes.length > 0) root = g.nodes[0]!;
+  if (!root) return;
+  const ord = new Map<DerivedNode, number>();
+  g.nodes.forEach((dn, i) => ord.set(dn, i));
+  const seq = new Map<DerivedEdge, number>();
+  allEdges.forEach((e, i) => seq.set(e, i));
+  dfsVisit({ g, state, allEdges, stk: [], ord, seq }, root, true);
+}
+
+// ---------------------------------------------------------------------------
+// Block-cutpoint tree wiring
+// @see lib/circogen/blocktree.c:createBlocktree
+// ---------------------------------------------------------------------------
+
+export function minValNode(bp: Block): { child: DerivedNode; parentNode: DerivedNode | null } {
+  let child = bp.subGraph.nodes[0]!;
+  let minVal = child.cdata.bc.val;
+  let parentNode = child.cdata.parent;
+  for (let j = 1; j < bp.subGraph.nodes.length; j++) {
+    const n = bp.subGraph.nodes[j]!;
+    if (n.cdata.bc.val < minVal) {
+      child = n;
+      minVal = n.cdata.bc.val;
+      parentNode = n.cdata.parent;
+    }
+  }
+  return { child, parentNode };
+}
+
+export function wireBlock(bp: Block): void {
+  if (bp.subGraph.nodes.length === 0) return;
+  const { child, parentNode } = minValNode(bp);
+  bp.child = child.orig;
+  if (parentNode === null) return;
+  parentNode.cdata.flags |= FLAGS_ISPARENT;
+  const parentBlock = parentNode.cdata.block as Block | null;
+  if (parentBlock !== null) parentBlock.children.push(bp);
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Build block-cutpoint tree from biconnected components.
+ * @see lib/circogen/blocktree.c:createBlocktree
+ */
+export function createBlocktree(
+  g: SubGraph,
+  state: CircState,
+  allEdges: DerivedEdge[],
+): Block {
+  findBlocks(g, state, allEdges);
+  const root = state.bl[0]!;
+  for (let i = 1; i < state.bl.length; i++) wireBlock(state.bl[i]!);
+  state.bl = [];
+  return root;
+}
+
+/**
+ * Create a single block containing all nodes (oneblock=true).
+ * @see lib/circogen/circular.c:createOneBlock
+ */
+export function createOneBlock(g: SubGraph, state: CircState): Block {
+  const name = `_block_${state.blockCount++}`;
+  const sg: SubGraph = { name, nodes: [...g.nodes], edges: [], parent: g.parent };
+  g.parent.subgraphs.push(sg);
+  const bp = mkBlock(sg);
+  for (const n of sg.nodes) n.cdata.block = bp;
+  return bp;
+}
+
+/**
+ * Recursively free a block tree (post-order).
+ * @see lib/circogen/blocktree.c:freeBlocktree
+ */
+export function freeBlocktree(bp: Block): void {
+  for (const child of bp.children) freeBlocktree(child);
+  bp.circleList = [];
+  bp.children = [];
+}

package/src/layout/circo/circular.ts

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Per-connected-component circular layout orchestration.
+ *
+ * Ports lib/circogen/circular.c (circularLayout) and the derived-graph
+ * construction from lib/circogen/circularinit.c (circomps, circoLayout).
+ *
+ * All functions are exported so lizard counts each one independently.
+ *
+ * @see lib/circogen/circular.c
+ * @see lib/circogen/circularinit.c
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { CircoNData } from './init.js';
+import {
+  type Block, type SubGraph, type DerivedGraph, type DerivedNode, type DerivedEdge,
+  makeCircState, makeCData,
+} from './blocks.js';
+import { createBlocktree, createOneBlock, freeBlocktree } from './blocktree.js';
+import { nodesInSeq } from '../dot/decomp.js';
+import { circPos } from './position.js';
+import { ccomps, getPackInfo, packSubgraphs } from '../pack/index.js';
+import { PackMode } from '../pack/types.js';
+import { adjustNodesFull } from '../neato/fdp-adjust.js';
+
+// ---------------------------------------------------------------------------
+// Derived-graph construction
+// @see lib/circogen/circularinit.c:circomps
+// ---------------------------------------------------------------------------
+
+/** Create a DerivedNode from an original graph node. */
+export function makeDerivedNode(orig: Node): DerivedNode {
+  // Placeholder — cdata.derivedNode set after object construction.
+  const dn: DerivedNode = {
+    name: orig.name, orig,
+    pos: [0, 0],
+    cdata: null as unknown as DerivedNode['cdata'],
+    lw: orig.info.lw, rw: orig.info.rw, ht: orig.info.ht,
+  };
+  dn.cdata = makeCData(dn);
+  return dn;
+}
+
+/** Build strict undirected derived graph from g (drop self-loops).
+ * C creates derived nodes walking agfstnode (node-seq order) — the
+ * creation order IS the derived node seq. @see circularinit.c:circomps */
+export function buildDerivedGraph(g: Graph): DerivedGraph {
+  const dg: DerivedGraph = { nodes: new Map(), subgraphs: [], components: [] };
+  for (const n of nodesInSeq(g)) {
+    const dn = makeDerivedNode(n);
+    dg.nodes.set(n.name, dn);
+    n.info.alg = dn.cdata; // link for derivedOf()
+  }
+  return dg;
+}
+
+/**
+ * Build derived edges (strict: no self-loops, no duplicates).
+ *
+ * C's circomps creates them per TAIL node in seq order via agfstout —
+ * `agedge(dg, dt, dh, NULL, 1)` on the strict derived graph dedups
+ * unordered pairs, keeping the FIRST encounter's orientation and seq.
+ * The derived-edge seq drives the block DFS's agfstedge iteration order
+ * (agedgeseqcmpf), which decides block numbering and tree child order.
+ * @see lib/circogen/circularinit.c:circomps
+ */
+export function buildDerivedEdges(g: Graph, dg: DerivedGraph): DerivedEdge[] {
+  const edges: DerivedEdge[] = [];
+  const seen = new Set<string>();
+  for (const n of nodesInSeq(g)) {
+    for (const e of n.outEdges(g)) {
+      if (e.tail === e.head) continue; // drop self-loops
+      const tail = dg.nodes.get(e.tail.name);
+      const head = dg.nodes.get(e.head.name);
+      if (!tail || !head) continue;
+      const key = [tail.name, head.name].sort().join('\0');
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edges.push({ tail, head, order: 0, origEdge: e });
+    }
+  }
+  return edges;
+}
+
+/** Decompose derived graph into connected components with their edges. */
+export function derivedComponents(g: Graph, dg: DerivedGraph, allEdges: DerivedEdge[]): SubGraph[] {
+  const comps = ccomps(g, '_cc');
+  return comps.map((sg, i) => {
+    const nodes: DerivedNode[] = [];
+    for (const n of sg.nodes.values()) {
+      const dn = dg.nodes.get(n.name);
+      if (dn) nodes.push(dn);
+    }
+    // cgraph subgraph iteration is ID-ordered (root creation order).
+    nodes.sort((a, b) => a.orig.id - b.orig.id);
+    const ns = new Set(nodes);
+    const edges = allEdges.filter((e) => ns.has(e.tail) && ns.has(e.head));
+    return { name: `_cc_${i}`, nodes, edges, parent: dg };
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Single-component circular layout
+// @see lib/circogen/circular.c:circularLayout
+// ---------------------------------------------------------------------------
+
+/** Position a single-node component at origin. */
+export function layoutSingleNode(sg: SubGraph): void {
+  const dn = sg.nodes[0];
+  if (dn) { dn.orig.info.pos = [0, 0]; }
+}
+
+/** Read oneblock attribute from the original graph. */
+export function isOneblock(realg: Graph): boolean {
+  return realg.attrs.get('oneblock') === 'true';
+}
+
+/** Read mindist attribute from the original graph (default 1.0). */
+export function readMinDist(realg: Graph): number {
+  const v = parseFloat(realg.attrs.get('mindist') ?? '');
+  return isNaN(v) || v < 0 ? 1.0 : v;
+}
+
+/**
+ * Lay out one connected component of the derived graph.
+ * @see lib/circogen/circular.c:circularLayout
+ */
+export function circularLayout(sg: SubGraph, realg: Graph, blockCount: number, allEdges: DerivedEdge[]): number {
+  if (sg.nodes.length === 1) { layoutSingleNode(sg); return blockCount; }
+  const state = makeCircState(blockCount);
+  state.minDist = readMinDist(realg);
+  state.rootname = realg.attrs.get('root') ?? '';
+  let root: Block;
+  if (isOneblock(realg)) root = createOneBlock(sg, state);
+  else root = createBlocktree(sg, state, allEdges);
+  circPos(sg, root, state);
+  freeBlocktree(root);
+  return state.blockCount;
+}
+
+// ---------------------------------------------------------------------------
+// Copy positions back to original graph
+// @see lib/circogen/circularinit.c:copyPosns
+// ---------------------------------------------------------------------------
+
+export function copyPositions(_sg: SubGraph): void {
+  // assignPositions writes straight to dn.orig.info.pos (inches), so
+  // the C derived->orig copy is already done. coord is synced from pos
+  // (x72) later by splineEdgesShifted, exactly like C spline_edges.
+}
+
+// ---------------------------------------------------------------------------
+// Adjust nodes to remove overlap (stub — neato adjustNodes equivalent)
+// @see lib/neatogen/adjust.c:adjustNodes
+// ---------------------------------------------------------------------------
+
+/**
+ * Multi-component overlap adjustment stub. C runs adjustNodes(sg) on each
+ * DERIVED component subgraph before packing (circularinit.c:212); porting
+ * that requires width/pos plumbing on derived nodes and no divergent
+ * corpus case reaches it yet. The single-component path (adjustNodesFull
+ * on the real graph, circularinit.c:203) IS ported — see circoLayout.
+ */
+export function adjustNodes(_sg: SubGraph): void {
+  // deferred: see plans/xdot-conformance/decision-journal.md (PRISM entry)
+}
+
+// ---------------------------------------------------------------------------
+// circoLayout — top-level multi-component entry point
+// @see lib/circogen/circularinit.c:circoLayout
+// ---------------------------------------------------------------------------
+
+export function circoLayout(g: Graph): void {
+  if (g.nodes.size === 0) return;
+  const dg = buildDerivedGraph(g);
+  const allEdges = buildDerivedEdges(g, dg);
+  const comps = derivedComponents(g, dg, allEdges);
+  dg.components = comps;
+  let blockCount = 0;
+  if (comps.length === 1) {
+    blockCount = circularLayout(comps[0]!, g, blockCount, allEdges);
+    copyPositions(comps[0]!);
+    // C: adjustNodes(g) on the REAL graph — overlap=false resolves to
+    // PRISM on the GTS reference build. @see circularinit.c:203
+    adjustNodesFull(g);
+  } else {
+    layoutMultiComponent(g, dg, comps, allEdges, blockCount);
+  }
+}
+
+/** Pack and copy positions for multi-component graphs. */
+export function layoutMultiComponent(
+  g: Graph, _dg: DerivedGraph, comps: SubGraph[], allEdges: DerivedEdge[], blockCount: number,
+): void {
+  let bc = blockCount;
+  for (const sg of comps) { bc = circularLayout(sg, g, bc, allEdges); adjustNodes(sg); }
+  // C: getPackInfo(g, l_node, CL_OFFSET) — polyomino node-mode packing.
+  const pinfo = { aspect: 1, sz: 0, margin: 8, doSplines: false, mode: PackMode.Node, fixed: null, vals: null, flags: 0 };
+  getPackInfo(g, PackMode.Node, 8, pinfo);
+  // Build proxy Graph objects for packSubgraphs
+  const proxyGraphs = comps.map((sg) => buildProxyGraph(sg, g));
+  packSubgraphs(comps.length, proxyGraphs, g, pinfo);
+  // Copy packed coords back
+  for (let i = 0; i < comps.length; i++) copyPositions(comps[i]!);
+}
+
+/** Build a minimal Graph proxy so packSubgraphs can read node coords. */
+export function buildProxyGraph(sg: SubGraph, root: Graph): Graph {
+  const proxy = new (root.constructor as new (n: string, k: string) => Graph)('_proxy', 'undirected');
+  proxy.info.dotroot = root;
+  for (const dn of sg.nodes) {
+    // Packing reads coord in POINTS; layout pos is in inches.
+    const p = dn.orig.info.pos ?? [0, 0];
+    dn.orig.info.coord = { x: (p[0] ?? 0) * 72, y: (p[1] ?? 0) * 72 };
+    proxy.nodes.set(dn.name, dn.orig);
+  }
+  return proxy;
+}
+
+// ---------------------------------------------------------------------------
+// Edge type needed by the model but not part of circogen per se
+// ---------------------------------------------------------------------------
+void (0 as unknown as Edge); // keep import live for type checking