@knowvah/dot-engine 0.1.0

package/src/layout/dot/edge-route-geom.ts

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Geometric helpers for edge spline routing: vector math and node-box
+ * ray clipping.
+ *
+ * @see lib/common/splines.c:clip_and_install (box-clipping logic)
+ */
+
+import type { Point } from '../../model/geom.js';
+
+// ---------------------------------------------------------------------------
+// Vector helpers
+// ---------------------------------------------------------------------------
+
+/** Normalize a 2-D vector; returns {0,0} if near-zero length. */
+export function normalizeVec(v: Point): Point {
+  const d = Math.sqrt(v.x * v.x + v.y * v.y);
+  if (d < 1e-10) return { x: 0, y: 0 };
+  return { x: v.x / d, y: v.y / d };
+}
+
+/** Reverse a vector. */
+export function negateVec(v: Point): Point { return { x: -v.x, y: -v.y }; }
+
+/** Offset a point by dir * scale. */
+export function offsetPoint(p: Point, dir: Point, scale: number): Point {
+  return { x: p.x + dir.x * scale, y: p.y + dir.y * scale };
+}
+
+// ---------------------------------------------------------------------------
+// clipToNodeBox
+// ---------------------------------------------------------------------------
+
+/** Min positive t along x-axis for the given boundary half-width. */
+export function xClipT(dirX: number, halfW: number): number {
+  if (dirX > 0) return halfW / dirX;
+  if (dirX < 0) return -halfW / dirX;
+  return Infinity;
+}
+
+/** Min positive t along y-axis for the given boundary half-height. */
+export function yClipT(dirY: number, halfH: number): number {
+  if (dirY > 0) return halfH / dirY;
+  if (dirY < 0) return -halfH / dirY;
+  return Infinity;
+}
+
+/**
+ * Node box dimensions bundled for clipping.
+ * @see lib/common/types.h:Agnodeinfo_t (ND_lw, ND_rw, ND_ht)
+ */
+export interface NodeBox {
+  center: Point;
+  lw: number;
+  rw: number;
+  ht: number;
+  /** True when the node shape is elliptical (sides === 1 in C poly_inside). */
+  isEllipse?: boolean;
+  /**
+   * Node pen width. C's poly_inside clips to the outline periphery (the
+   * boundary grown by penwidth/2), so a thick-bordered node clips the edge
+   * spline / arrow slightly further out. Defaults to DEFAULT_NODEPENWIDTH.
+   * @see lib/common/shapes.c:poly_inside (outline / penwidth)
+   */
+  penwidth?: number;
+}
+
+/**
+ * Clip a ray from box.center in direction `dir` to the node boundary.
+ * For ellipse nodes uses the ellipse formula; for box nodes uses the box formula.
+ * @see lib/common/shapes.c:poly_inside
+ */
+export function clipToNodeBox(box: NodeBox, dir: Point): Point {
+  if (dir.x === 0 && dir.y === 0) return { x: box.center.x, y: box.center.y };
+  if (box.isEllipse) {
+    const rx = (box.lw + box.rw) / 2;
+    const ry = box.ht / 2;
+    const fx = dir.x / rx;
+    const fy = dir.y / ry;
+    const d = Math.sqrt(fx * fx + fy * fy);
+    if (d < 1e-10) return { x: box.center.x, y: box.center.y };
+    const t = 1 / d;
+    return { x: box.center.x + dir.x * t, y: box.center.y + dir.y * t };
+  }
+  const halfW = dir.x > 0 ? box.rw : box.lw;
+  const t = Math.min(xClipT(dir.x, halfW), yClipT(dir.y, box.ht / 2));
+  if (t === Infinity) return { x: box.center.x, y: box.center.y };
+  return { x: box.center.x + dir.x * t, y: box.center.y + dir.y * t };
+}

package/src/layout/dot/edge-route-helpers.ts

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Shared helpers for edge spline routing: node-box construction,
+ * penwidth reading, spline record installation, and straight-edge routing.
+ *
+ * Extracted to allow edge-route-chain.ts to import these without
+ * creating a circular dependency through the top-level edge-route.ts.
+ *
+ * @see lib/dotgen/dotsplines.c
+ * @see lib/common/splines.c:clip_and_install
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge as GraphEdge } from '../../model/edge.js';
+import { nodeAttr } from '../../common/poly-init.js';
+import type { Point, Bezier, Spline } from '../../model/geom.js';
+import { routeSpline } from '../../pathplan/route.js';
+import type { Edge as BarrierEdge } from '../../pathplan/types.js';
+import { linearBezier } from './edge-route-poly.js';
+import { updateBbBz } from '../../common/splines-geom.js';
+import { DEFAULT_NODEPENWIDTH } from './edge-route-clip.js';
+import { resolvePenWidth, parseStyleFlags } from '../../common/style-resolve.js';
+import type { NodeBox } from './edge-route-geom.js';
+import { routeWithRank, routeSimple } from './edge-route-routing.js';
+import type { RankEdgeInfo, EdgeSplineResult, PortRoute } from './edge-route-routing.js';
+
+/**
+ * Default `dir` for an edge given the graph's directedness. C uses
+ * `agisdirected(g) ? "forward" : "none"` — an undirected graph draws no
+ * arrowheads. Without this, undirected edges wrongly get a head arrow and an
+ * arrow-clipped (short) spline.
+ *
+ * @see lib/common/arrows.c:arrow_flags (late_string E_dir default)
+ */
+export function defaultEdgeDir(g: Graph): string {
+  return g.kind === 'directed' || g.kind === 'strict-directed' ? 'forward' : 'none';
+}
+
+// ---------------------------------------------------------------------------
+// nodeBoxOf
+// ---------------------------------------------------------------------------
+
+/** Ellipse shape names (use ellipse clip). @see lib/common/shapes.c:poly_inside */
+const ELLIPSE_SHAPES = new Set([
+  'ellipse', 'oval', 'circle', 'egg', 'doublecircle', 'Mcircle', 'point',
+]);
+
+function recordClipBox(n: Node): { lw: number; rw: number; ht: number } | undefined {
+  const f = n.info.shape_info as { b?: { ll: Point; ur: Point } } | undefined;
+  if (!f?.b) return undefined;
+  const halfW = (f.b.ur.x - f.b.ll.x) / 2;
+  return { lw: halfW, rw: halfW, ht: f.b.ur.y - f.b.ll.y };
+}
+
+/** Node pen width (default 1.0), threaded into the clip boundary. */
+function nodePenwidthOf(n: Node, g: Graph): number {
+  const v = nodeAttr(n, g, 'penwidth');
+  const pw = v !== undefined ? parseFloat(v) : NaN;
+  return Number.isFinite(pw) && pw >= 0 ? pw : DEFAULT_NODEPENWIDTH;
+}
+
+/** Returns a NodeBox with defaulted lw/rw/ht for a node. */
+export function nodeBoxOf(n: Node, g: Graph): NodeBox {
+  const shapeName = nodeAttr(n, g, 'shape') ?? 'ellipse';
+  const penwidth = nodePenwidthOf(n, g);
+  if (shapeName === 'record' || shapeName === 'Mrecord') {
+    const rb = recordClipBox(n);
+    if (rb) return { center: n.info.coord, ...rb, isEllipse: false, penwidth };
+  }
+  return {
+    center: n.info.coord,
+    lw: n.info.lw > 0 ? n.info.lw : 27,
+    rw: n.info.rw > 0 ? n.info.rw : 27,
+    ht: n.info.ht > 0 ? n.info.ht : 36,
+    isEllipse: ELLIPSE_SHAPES.has(shapeName),
+    penwidth,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Penwidth helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Effective pen width for arrowhead geometry. Must mirror the stroke resolver
+ * so the arrow's penwidth-dependent miter (delta_tip/delta_base in
+ * arrow_type_normal0) matches the drawn line width: penwidth attr →
+ * setlinewidth(N) style → bold(2.0) → 1.0. The prior version only recognised
+ * `style === "bold"`, so `style="setlinewidth(3)"` fell through to 1.0 and the
+ * arrow was drawn ~penwidth off along the edge (graphs-style a->e).
+ * @see resolvePenWidth (style-resolve.ts) / lib/common/arrows.c:257
+ */
+export function edgeRenderPenwidth(e: GraphEdge): number {
+  return resolvePenWidth(parseStyleFlags(e.attrs.get('style')), e.attrs.get('penwidth'));
+}
+
+/** Penwidth for arrow-length (elen) computation (attribute only). */
+export function edgePenwidthAttr(e: GraphEdge): number {
+  const pw = parseFloat(e.attrs.get('penwidth') ?? '');
+  return isNaN(pw) ? 1.0 : pw;
+}
+
+// ---------------------------------------------------------------------------
+// Spline record builders
+// @see lib/common/splines.c:clip_and_install, new_spline
+// ---------------------------------------------------------------------------
+
+/** Build a Bezier record for a single cubic segment. */
+export function makeBezierRecord(bezierPts: Point[], arrowTip: Point): Bezier {
+  return {
+    list: bezierPts, size: bezierPts.length,
+    sflag: 0, eflag: 1,
+    sp: bezierPts[0] ?? { x: 0, y: 0 }, ep: arrowTip,
+  };
+}
+
+/** Build a zero-bb Spline wrapping a single Bezier record. */
+export function makeSplineRecord(bz: Bezier): Spline {
+  return { list: [bz], size: 1, bb: { ll: { x: 0, y: 0 }, ur: { x: 0, y: 0 } } };
+}
+
+/** Create and install a Spline on the edge. @see lib/common/splines.c:clip_and_install */
+export function installEdgeSpline(e: GraphEdge, bezierPts: Point[], arrowTip: Point): void {
+  e.info.spl = makeSplineRecord(makeBezierRecord(bezierPts, arrowTip));
+  // C clip_and_install expands GD_bb by every installed bezier segment via
+  // update_bb_bz (splines.c:312). This direct-install path (chain/long-edge
+  // router) must do the same, else a spline that bows outside the node hull —
+  // e.g. a long back edge routed around the side — is clipped by the viewport.
+  const bb = e.tail.root.info.bb;
+  if (bb != null) {
+    for (let i = 0; i + 3 < bezierPts.length; i += 3) {
+      updateBbBz(bb, [bezierPts[i], bezierPts[i + 1], bezierPts[i + 2], bezierPts[i + 3]]);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// routeBezier / straightEdgeSplineWithRank
+// ---------------------------------------------------------------------------
+
+function isUsableSpline(raw: Point[]): boolean {
+  if (raw.length < 4) return false;
+  const p0 = raw[0] as Point;
+  const p1 = raw[1] as Point;
+  return p0.x !== p1.x || p0.y !== p1.y;
+}
+
+/** Route via pathplan, falling back to linear if the result is degenerate. */
+export function routeBezier(from: Point, to: Point): Point[] {
+  const noBarriers: BarrierEdge[] = [];
+  const zero: Point = { x: 0, y: 0 };
+  const raw = routeSpline(noBarriers, [from, to], [zero, zero]);
+  if (!isUsableSpline(raw)) return linearBezier(from, to);
+  return [raw[0] as Point, raw[1] as Point, raw[2] as Point, raw[3] as Point];
+}
+
+/** Compute Bezier for a straight edge, with optional rank-corridor geometry. */
+export function straightEdgeSplineWithRank(
+  tailBox: NodeBox,
+  headBox: NodeBox,
+  rankInfo: RankEdgeInfo | undefined,
+  penwidth = 1.0,
+  port?: PortRoute,
+): EdgeSplineResult {
+  return rankInfo !== undefined
+    ? routeWithRank(tailBox, headBox, rankInfo, penwidth, port)
+    : routeSimple(tailBox, headBox, routeBezier);
+}

package/src/layout/dot/edge-route-poly.ts

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Polygon construction and spline routing from path boxes.
+ *
+ * Ports the box-to-polygon conversion and spline fitting sections of
+ * routesplines_ in the C source.
+ *
+ * @see lib/common/routespl.c:routesplines_
+ */
+
+import type { Point, Box } from '../../model/geom.js';
+import { routeSpline } from '../../pathplan/route.js';
+import { shortestPath } from '../../pathplan/shortest.js';
+import type { Edge as BarrierEdge } from '../../pathplan/types.js';
+
+// ---------------------------------------------------------------------------
+// Forward and reverse polygon passes
+// @see lib/common/routespl.c:routesplines_ (post-flip forward/reverse loops)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute prev/next direction codes for the forward pass at box bi.
+ * next=1 when next box ll.y is greater (path goes "right-then-down").
+ * @see lib/common/routespl.c:routesplines_ (forward loop direction logic)
+ */
+function fwdDirs(boxes: Box[], bi: number): { prev: number; next: number } {
+  const n = boxes.length;
+  const prev = bi > 0 ? (boxes[bi].ll.y > boxes[bi - 1].ll.y ? -1 : 1) : 0;
+  const next = bi + 1 < n ? (boxes[bi + 1].ll.y > boxes[bi].ll.y ? 1 : -1) : 0;
+  return { prev, next };
+}
+
+/**
+ * Emit polygon points for one box in the forward pass.
+ * @see lib/common/routespl.c:routesplines_ (forward loop body)
+ */
+function emitFwdBox(b: Box, prev: number, next: number, pts: Point[]): void {
+  if (prev !== next) {
+    if (next === -1 || prev === 1) {
+      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
+    } else {
+      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
+    }
+  } else if (prev === 0) {
+    pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
+  }
+  // prev === next === -1: no points added (straight section)
+}
+
+/**
+ * Forward pass: right-side polygon vertices from box[0] to box[N-1].
+ * @see lib/common/routespl.c:routesplines_ (forward loop)
+ */
+export function addForwardPolyPts(boxes: Box[], pts: Point[]): void {
+  for (let bi = 0; bi < boxes.length; bi++) {
+    const { prev, next } = fwdDirs(boxes, bi);
+    emitFwdBox(boxes[bi], prev, next, pts);
+  }
+}
+
+/**
+ * Compute prev/next direction codes for the reverse pass at box bi.
+ * @see lib/common/routespl.c:routesplines_ (reverse loop direction logic)
+ */
+function revDirs(boxes: Box[], bi: number): { prev: number; next: number } {
+  const n = boxes.length;
+  const prev = bi + 1 < n ? (boxes[bi].ll.y > boxes[bi + 1].ll.y ? -1 : 1) : 0;
+  const next = bi > 0 ? (boxes[bi - 1].ll.y > boxes[bi].ll.y ? 1 : -1) : 0;
+  return { prev, next };
+}
+
+/** Emit the four-corner case for the reverse pass all-corners branch. */
+function emitAllCorners(b: Box, pts: Point[]): void {
+  pts.push(
+    { x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y },
+    { x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y },
+  );
+}
+
+/**
+ * Emit polygon points for one box in the reverse pass.
+ * @see lib/common/routespl.c:routesplines_ (reverse loop body)
+ */
+function emitRevBox(b: Box, prev: number, next: number, pts: Point[]): void {
+  if (prev !== next) {
+    if (next === -1 || prev === 1) {
+      pts.push({ x: b.ll.x, y: b.ur.y }, { x: b.ll.x, y: b.ll.y });
+    } else {
+      pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
+    }
+  } else if (prev === 0) {
+    pts.push({ x: b.ur.x, y: b.ll.y }, { x: b.ur.x, y: b.ur.y });
+  } else {
+    emitAllCorners(b, pts);
+  }
+}
+
+/**
+ * Reverse pass: left-side polygon vertices from box[N-1] to box[0].
+ * @see lib/common/routespl.c:routesplines_ (reverse loop)
+ */
+export function addReversePolyPts(boxes: Box[], pts: Point[]): void {
+  for (let bi = boxes.length - 1; bi >= 0; bi--) {
+    const { prev, next } = revDirs(boxes, bi);
+    emitRevBox(boxes[bi], prev, next, pts);
+  }
+}
+
+/**
+ * Convert path boxes to polygon vertices.
+ *
+ * Boxes are in tail→head path order. In TS SVG coords (y-down), ll.y
+ * increases from tail to head — this is the C post-flip state, so the
+ * forward+reverse pass logic ports directly.
+ *
+ * @see lib/common/routespl.c:routesplines_
+ */
+export function boxesToPolygon(boxes: Box[]): Point[] {
+  if (boxes.length === 0) return [];
+  const pts: Point[] = [];
+  addForwardPolyPts(boxes, pts);
+  addReversePolyPts(boxes, pts);
+  return pts;
+}
+
+// ---------------------------------------------------------------------------
+// computeSpline
+// @see lib/common/routespl.c:routesplines_ (shortest-path + spline section)
+// ---------------------------------------------------------------------------
+
+/** Build polygon barrier edges (consecutive pairs, closed). */
+export function polyEdgesFromPts(polygon: Point[]): BarrierEdge[] {
+  const n = polygon.length;
+  return polygon.map((a, i) => ({ a, b: polygon[(i + 1) % n] }));
+}
+
+/** Straight-line cubic Bezier with control points at 1/3 and 2/3. */
+export function linearBezier(p0: Point, p3: Point): Point[] {
+  return [
+    p0,
+    { x: p0.x + (p3.x - p0.x) / 3,       y: p0.y + (p3.y - p0.y) / 3 },
+    { x: p0.x + (2 * (p3.x - p0.x)) / 3, y: p0.y + (2 * (p3.y - p0.y)) / 3 },
+    p3,
+  ];
+}
+
+/**
+ * Fit spline via routeSpline.
+ * Degenerate Beziers (P0=P1) are valid — C's Proutespline produces them
+ * for straight paths with zero endpoint slopes, and bezier_clip still
+ * gives correct clipping behavior.
+ * @see lib/pathplan/route.c:reallyroutespline (splinefits section)
+ */
+export function tryRouteSpline(barriers: BarrierEdge[], wpts: Point[]): Point[] | null {
+  const zero: Point = { x: 0, y: 0 };
+  const raw = routeSpline(barriers, wpts, [zero, zero]);
+  if (raw.length < 4) return null;
+  return [raw[0] as Point, raw[1] as Point, raw[2] as Point, raw[3] as Point];
+}
+
+/**
+ * Build polygon from boxes, find shortest path, fit Bezier with barriers.
+ * @see lib/common/routespl.c:routesplines_
+ */
+export function computeSpline(boxes: Box[], startPt: Point, endPt: Point): Point[] {
+  const polygon = boxesToPolygon(boxes);
+  if (polygon.length < 3) return linearBezier(startPt, endPt);
+  const wpts = shortestPath({ ps: polygon }, [startPt, endPt]);
+  if (wpts === null || wpts.length < 2) return linearBezier(startPt, endPt);
+  return tryRouteSpline(polyEdgesFromPts(polygon), wpts)
+    ?? linearBezier(startPt, endPt);
+}
+

package/src/layout/dot/edge-route-rank.ts

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Rank geometry extraction for edge routing.
+ *
+ * Computes the RankEdgeInfo needed by routeWithRank by reading the
+ * graph's rank table and deriving left/right bounds from node extents.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (rank geometry access)
+ * @see lib/dotgen/dotsplines.c:sd.LeftBound / sd.RightBound
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { RankEdgeInfo } from './edge-route-routing.js';
+
+/** Minimum edge routing width. @see lib/dotgen/dotsplines.c:MINW */
+const MINW = 16;
+
+/** Minimum x extent across all nodes minus MINW. @see lib/dotgen/dotsplines.c:sd.LeftBound */
+export function computeLeftBound(g: Graph): number {
+  const ranks = g.info.rank;
+  if (ranks === undefined) return -32;
+  const minr = g.info.minrank ?? 0;
+  const maxr = g.info.maxrank ?? ranks.length - 1;
+  let lb = 0;
+  for (let i = minr; i <= maxr; i++) {
+    const n = ranks[i]?.v[0];
+    if (n) lb = Math.min(lb, n.info.coord.x - n.info.lw);
+    lb -= MINW;
+  }
+  return lb;
+}
+
+/** Maximum x extent across all nodes plus MINW. @see lib/dotgen/dotsplines.c:sd.RightBound */
+export function computeRightBound(g: Graph): number {
+  const ranks = g.info.rank;
+  if (ranks === undefined) return 60;
+  const minr = g.info.minrank ?? 0;
+  const maxr = g.info.maxrank ?? ranks.length - 1;
+  let rb = 0;
+  for (let i = minr; i <= maxr; i++) {
+    const rk = ranks[i];
+    const n = rk !== undefined && rk.n > 0 ? rk.v[rk.n - 1] : undefined;
+    if (n) rb = Math.max(rb, n.info.coord.x + n.info.rw);
+    rb += MINW;
+  }
+  return rb;
+}
+
+/** Default a rank half-height to node half-height when the rank value is unset. */
+export function rankHt(rankVal: number, nodeHt: number): number {
+  return rankVal > 0 ? rankVal : nodeHt / 2;
+}
+
+// ---------------------------------------------------------------------------
+// Per-pass bounds snapshot — mirrors C's spline_info_t sd
+// @see lib/dotgen/dotsplines.c:dot_splines_ (sd computed once, threaded through
+// maximal_bbox / rank_box / make_regular_edge / make_flat_edge)
+// ---------------------------------------------------------------------------
+
+/** The two fields of spline_info_t that this port derives from live rank/node
+ *  state. @see lib/dotgen/dotsplines.c:spline_info_t (LeftBound/RightBound) */
+export interface SplineBoundsSnapshot {
+  leftBound: number;
+  rightBound: number;
+}
+
+/** Per-graph memo of the current pass's bounds snapshot. Keyed by Graph so an
+ *  aux graph (always a fresh `new Graph(...)`, @see splines-flat.ts:cloneGraph)
+ *  never collides with the main graph's entry. */
+const boundsSnapshotByGraph = new WeakMap<Graph, SplineBoundsSnapshot>();
+
+/**
+ * Return this pass's frozen {leftBound, rightBound}, computing it on first
+ * access after a `resetSplineBounds` (or the very first access ever, for a
+ * graph never routed before). C's `dot_splines_` computes `spline_info_t sd`
+ * ONCE per call and threads it by pointer/value through every routing
+ * helper for that pass; the port previously called computeLeftBound/
+ * computeRightBound fresh on every routed edge, so edges routed later in the
+ * same pass saw a corridor narrowed by recoverSlack/resizeVn mutations to
+ * vnode coord.x/lw/rw from EARLIER edges in the pass (measured on 2646:
+ * 6002 of the pass's bound reads drifted 26pt narrower per side; the very
+ * first, pre-mutation computeLeftBound call is byte-identical to C's
+ * one-time value, so the formula is faithful and only the call timing
+ * drifted). NOTE: 2646's residual 3-edge divergence (Δ42.09 worst) proved
+ * to be a separate mechanism — those edges route before/independent of the
+ * drift — but the frozen snapshot is the faithful C semantics regardless.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (sd computed once, threaded through)
+ */
+export function getSplineBounds(g: Graph): SplineBoundsSnapshot {
+  let snap = boundsSnapshotByGraph.get(g);
+  if (snap === undefined) {
+    snap = { leftBound: computeLeftBound(g), rightBound: computeRightBound(g) };
+    boundsSnapshotByGraph.set(g, snap);
+  }
+  return snap;
+}
+
+/**
+ * Force the next `getSplineBounds(g)` call to recompute a fresh snapshot.
+ * Called once at the top of each `dotSplines_` pass (main graph or aux
+ * graph), exactly where C zero-initializes then computes `spline_info_t sd`
+ * fresh for that call. @see lib/dotgen/dotsplines.c:dot_splines_ (`spline_info_t
+ * sd = {0};` followed by the one-time LeftBound/RightBound loop)
+ */
+export function resetSplineBounds(g: Graph): void {
+  boundsSnapshotByGraph.delete(g);
+}
+
+/**
+ * Extract RankEdgeInfo from the graph's rank table for an edge.
+ * Returns undefined if rank geometry is not available.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (rank geometry access)
+ */
+export function rankEdgeInfoOf(
+  g: Graph,
+  tailNode: Node,
+  headNode: Node,
+): RankEdgeInfo | undefined {
+  const rankTable = g.info.rank;
+  if (rankTable === undefined) return undefined;
+  const tailRank = tailNode.info.rank;
+  const headRank = headNode.info.rank;
+  if (tailRank === undefined || headRank === undefined) return undefined;
+  const tr = rankTable[tailRank];
+  const hr = rankTable[headRank];
+  if (tr === undefined || hr === undefined) return undefined;
+  return {
+    ...getSplineBounds(g),
+    tailHt1: rankHt(tr.ht1, tailNode.info.ht),
+    tailHt2: rankHt(tr.ht2, tailNode.info.ht),
+    headHt1: rankHt(hr.ht1, headNode.info.ht),
+    headHt2: rankHt(hr.ht2, headNode.info.ht),
+  };
+}