@knowvah/dot-engine 0.1.0

package/src/layout/dot/splines-groups.ts

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Edge-group formation and dispatch for the dot_splines_ routing loop —
+ * C's inner group loop (groupSize) and the per-group router selection.
+ *
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (343-419)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+import type { TextlabelT } from '../../common/types.js';
+import {
+  getMainEdge, resolveOrigEdge, portcmp, gatePorts, edgeTreeIndex, nodeRankOf,
+  swapEndsP, swapEdgeSpline, EDGETYPE_CURVED, EDGETYPEMASK, FLATEDGE, MAINGRAPH,
+} from './splines.js';
+import { routeLoneEdge } from './edge-route.js';
+import { routeEntryRun } from './edge-route-chain.js';
+import { routeSelfEdgeGroup, buildDotSinfo } from './self-loop.js';
+import { updateBB } from './splines-label.js';
+import { routeParallelEdgeGroup } from './splines-route.js';
+import { makeStraightEdges } from './straight-edges.js';
+
+/** Per-loop routing context: separations, edge type, per-run orig record. */
+export interface GroupRouteCtx {
+  multisep: number;
+  et: number;
+  /** Originals that received per-run bezier appends (normalized post-loop). */
+  runOrigs: Set<Edge>;
+}
+
+/**
+ * Count how many consecutive entries in `edges` starting at `ind` join one
+ * routing group — C's inner group loop verbatim: break on a different main
+ * edge; flat ED_adjacent groups take everything at once; otherwise break on a
+ * tail/head portcmp mismatch (gate edges viewed forward), on a FLAT label
+ * change, or when the candidate carries MAINGRAPH ("Aha! -C is on"): under
+ * concentrate, consecutive same-main REGULAREDGE entries are merge-bounded
+ * chain runs that must each route their own make_regular_edge call, while
+ * AUXGRAPH copies (parallel multi-edges from ND_other) still group.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (344-376)
+ */
+function groupSize(edges: Edge[], ind: number): number {
+  const e0 = edges[ind];
+  const le0 = getMainEdge(e0);
+  const [eaT, eaH] = gatePorts(e0, le0);
+  const e0flat = (edgeTreeIndex(e0) & EDGETYPEMASK) === FLATEDGE;
+  let cnt = 1;
+  while (ind + cnt < edges.length) {
+    const e1 = edges[ind + cnt];
+    const le1 = getMainEdge(e1);
+    if (le1 !== le0) break;
+    if ((e0.info.adjacent ?? 0) !== 0) { cnt++; continue; } // all flat adjacent at once
+    const [ebT, ebH] = gatePorts(e1, le1);
+    if (portcmp(eaT, ebT) !== 0) break;
+    if (portcmp(eaH, ebH) !== 0) break;
+    if (e0flat && e0.info.label !== e1.info.label) break;
+    if ((edgeTreeIndex(e1) & MAINGRAPH) !== 0) break; // Aha! -C is on
+    cnt++;
+  }
+  return cnt;
+}
+
+/** Original-edge creation seq (resolve virtuals) — restores C's edgecmp order. */
+function origSeq(e: Edge): number { return resolveOrigEdge(e).seq; }
+
+/**
+ * Collapse a main-edge group to one representative per distinct original edge.
+ * The opposing `a->b`/`b->a` case collects three entries but two distinct
+ * originals; dedup by `resolveOrigEdge` yields one per original (parallels
+ * untouched). Pushes the RESOLVED original `o`, not the raw group member `e`:
+ * a raw member can be a swapped internal proxy (e.g. a same-rank flat edge
+ * whose canonical orientation is tail/head-swapped) whose endpoints don't
+ * match the edge actually rendered — routing against the proxy leaves the
+ * real edge's geometry unset. C's `edges` list carries no such proxy object
+ * (its group members are already the real/virtual edges), so this recovers
+ * C's outcome for the TS-specific proxy representation. Distinct originals
+ * (genuine parallels, or a multi-rank edge's own per-hop virtual segments)
+ * each resolve to their OWN root, so this dedup never merges or renames them.
+ * @see dotsplines.c:make_regular_edge (one clip_and_install per orig)
+ */
+export function dedupByOrig(group: Edge[]): Edge[] {
+  const seen = new Set<Edge>();
+  const out: Edge[] = [];
+  for (const e of group) {
+    const o = resolveOrigEdge(e);
+    if (seen.has(o)) continue;
+    seen.add(o);
+    out.push(o);
+  }
+  return out;
+}
+
+/**
+ * Dispatch one edgecmp group: self-loop → routeSelfEdgeGroup; cross-rank cnt>1 →
+ * routeParallelEdgeGroup (Multisep offsets); cross-rank cnt==1 → per-run or
+ * whole-chain lone routing in-place (C order); same-rank flat → left for the
+ * routeDotEdges sweep.
+ * @see lib/dotgen/dotsplines.c:367-419
+ */
+function dispatchEdgeGroup(g: Graph, group: Edge[], ctx: GroupRouteCtx): void {
+  const e0 = group[0];
+  if (e0.tail === e0.head) {
+    routeSelfEdgeGroup(g, group, group.length, ctx.multisep, buildDotSinfo());
+    // Grow the graph bbox to include each labeled self-loop's label. C does this
+    // after makeSelfEdge; it is the ONLY canvas-growth path for left/top loops
+    // (right-going loops also reserve label space at ranking time via
+    // selfRightSpace, so they grow without it). @see dotsplines.c:405-409
+    for (const e of group) {
+      const l = e.info.label as TextlabelT | undefined;
+      if (l) updateBB(g, l);
+    }
+    return;
+  }
+  if (nodeRankOf(e0.tail) === nodeRankOf(e0.head)) return;
+  const uniq = dedupByOrig(group);
+  // Lone edge: route HERE at its edgecmp position (interleaved with groups), as C
+  // does, so it reads recover_slack-moved vnodes correctly. @see root-cause.md
+  if (uniq.length <= 1) {
+    // Concentrate merge-bounded partial run (either end at a splineMerge node):
+    // route ONLY this entry's run and append its bezier on the orig — every
+    // such run is its own cnt=1 group (groupSize's MAINGRAPH break), and the
+    // orig's spline accumulates one bezier per run in edgecmp order, exactly
+    // C's per-entry make_regular_edge + clip_and_install. The orig is recorded
+    // for the post-loop swap (C normalizes the assembled spline once, at the
+    // end). @see lib/dotgen/dotsplines.c:dot_splines_ (group loop)
+    const runOrig = routeEntryRun(g, e0);
+    if (runOrig !== null) {
+      ctx.runOrigs.add(runOrig);
+      return;
+    }
+    const lone = resolveOrigEdge(uniq[0]);
+    // Plain chains (no interior splineMerge boundary) keep the whole-chain
+    // routers. @see dotsplines.c:make_regular_edge (spline_merge)
+    routeLoneEdge(lone, g);
+    return;
+  }
+  // Lane offsets follow the edgecmp collected order — C passes the sorted list
+  // slice straight into make_regular_edge with NO re-sort, so the MAINGRAPH
+  // forward rep gets lane 0 (interior x -dx) and AUXGRAPH ND_other entries
+  // (including an opposing 2-cycle's reversed member) follow, regardless of
+  // original creation seq. @see dotsplines.c:419, make_regular_edge:1885-1907
+  routeParallelEdgeGroup(g, uniq, ctx.multisep);
+}
+
+/**
+ * Route one curved group via makeStraightEdges. C routes the whole same-endpoint
+ * group at once — parallels AND opposing edges (`a->b`/`b->a`) together (a 2-cycle
+ * is one cnt=2 group, ports (0,0); the visible separation is perp-spread clipped
+ * to the node). Dedup the TS virtual duplicates to distinct originals; sort by
+ * creation seq so index→perp-offset matches C (first → +perp); makeStraightEdges
+ * reverses the opposing edge's control points via its head==group-head check.
+ * @see lib/dotgen/dotsplines.c:381-387, lib/common/routespl.c:1000-1041
+ */
+function routeCurvedGroup(g: Graph, group: Edge[]): void {
+  const uniq = dedupByOrig(group);
+  uniq.sort((a, b) => origSeq(a) - origSeq(b));
+  makeStraightEdges(g, uniq, uniq.length, EDGETYPE_CURVED, buildDotSinfo());
+  // Reversed back edges live in ND_other (edgeNormalize skips them); swap here.
+  for (const e of uniq) {
+    if (swapEndsP(e)) swapEdgeSpline(e);
+  }
+}
+
+/**
+ * Route one parallel-edge group from the sorted edge list.
+ * Returns the number of edges consumed (cnt). For `splines=curved` the group is
+ * routed via `makeStraightEdges` instead of the normal per-group router.
+ * @see lib/dotgen/dotsplines.c:343-419
+ */
+function routeEdgeGroup(g: Graph, edges: Edge[], ind: number, ctx: GroupRouteCtx): number {
+  const cnt = groupSize(edges, ind);
+  if (ctx.et === EDGETYPE_CURVED) {
+    routeCurvedGroup(g, edges.slice(ind, ind + cnt));
+    return cnt;
+  }
+  dispatchEdgeGroup(g, edges.slice(ind, ind + cnt), ctx);
+  return cnt;
+}
+
+/**
+ * Run the whole group-routing loop over the sorted edge list; returns the set
+ * of originals that received per-run bezier appends, for the caller's
+ * post-loop normalize pass. @see lib/dotgen/dotsplines.c:dot_splines_ (343-419)
+ */
+export function routeEdgeGroups(g: Graph, edges: Edge[], multisep: number, et: number): Set<Edge> {
+  const ctx: GroupRouteCtx = { multisep, et, runOrigs: new Set<Edge>() };
+  for (let l = 0; l < edges.length;) l += routeEdgeGroup(g, edges, l, ctx);
+  return ctx.runOrigs;
+}

package/src/layout/dot/splines-label.ts

@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Label placement for edge virtual nodes and port labels.
+ *
+ * @see lib/dotgen/dotsplines.c:place_vnlabel, setEdgeLabelPos
+ * @see lib/common/splines.c:place_portlabel (lines 1316-1360)
+ * @see lib/dotgen/dotsplines.c:440-458 (port-label placement loop)
+ */
+
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { TextlabelT } from '../../common/types.js';
+import { VIRTUAL } from './fastgr.js';
+import { IGNORED } from './rank.js';
+import { lateDouble } from '../../common/nodeinit.js';
+import { nodesInSeq } from './decomp.js';
+
+// ---------------------------------------------------------------------------
+// TextLabel interface (minimal — full type deferred to Batch 5b)
+// ---------------------------------------------------------------------------
+
+/** Minimal label shape sufficient for placement. */
+export interface TextLabel {
+  pos: { x: number; y: number };
+  dimen: { x: number; y: number };
+  set: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Cast an unknown label to TextLabel if it has the required shape. */
+export function asTextLabel(label: unknown): TextLabel | undefined {
+  const l = label as Record<string, unknown>;
+  if (l && typeof l['pos'] === 'object' && typeof l['dimen'] === 'object') {
+    return l as unknown as TextLabel;
+  }
+  return undefined;
+}
+
+/** Walk to_orig until edge_type is NORMAL (0). */
+export function findNormalOutEdge(first: Edge): Edge | undefined {
+  let e: Edge | undefined = first;
+  while (e && (e.info.edge_type ?? 0) !== 0) e = e.info.to_orig;
+  return e;
+}
+
+/** Compute label x-position from node coord, dimen, and flip flag. */
+export function labelXPos(n: Node, l: TextLabel): number {
+  const flip = !!(n.root?.info.flip);
+  const width = flip ? l.dimen.y : l.dimen.x;
+  return n.info.coord.x + width / 2.0;
+}
+
+// ---------------------------------------------------------------------------
+// place_vnlabel
+// @see lib/dotgen/dotsplines.c:place_vnlabel
+// ---------------------------------------------------------------------------
+
+/**
+ * Assign position of an edge label from its virtual node.
+ * @see lib/dotgen/dotsplines.c:place_vnlabel
+ */
+export function placeVnlabel(n: Node): void {
+  if ((n.info.in?.size ?? 0) === 0) return; // skip flat edge labels
+  const first = n.info.out?.list[0];
+  if (!first) return;
+  const e = findNormalOutEdge(first);
+  if (!e) return;
+  const l = asTextLabel(e.info.label);
+  if (!l) return;
+  l.pos.x = labelXPos(n, l);
+  l.pos.y = n.info.coord.y;
+  l.set = true;
+}
+
+// ---------------------------------------------------------------------------
+// setEdgeLabelPos
+// @see lib/dotgen/dotsplines.c:setEdgeLabelPos
+// ---------------------------------------------------------------------------
+
+/** Set label pos from posAlg edge for virtual label nodes. */
+export function setAlgLabelPos(n: Node): void {
+  const fe = n.info.posAlg;
+  if (!fe) return;
+  const l = asTextLabel(fe.info.label);
+  if (!l) return;
+  l.pos = { x: n.info.coord.x, y: n.info.coord.y };
+  l.set = true;
+}
+
+/**
+ * Set edge label position information for regular and non-adjacent flat edges.
+ * @see lib/dotgen/dotsplines.c:setEdgeLabelPos
+ */
+export function setEdgeLabelPos(g: Graph): void {
+  for (let n: Node | undefined = g.info.nlist; n; n = n.info.next) {
+    if ((n.info.node_type ?? 0) !== VIRTUAL) continue;
+    // C tracks l from the posAlg edge label or the regular vnode label, then
+    // updateBB(g, l). @see lib/dotgen/dotsplines.c:205-216
+    let l: TextlabelT | undefined;
+    if (n.info.posAlg) {
+      setAlgLabelPos(n);
+      l = n.info.posAlg.info.label as TextlabelT | undefined;
+    } else if (n.info.label) {
+      placeVnlabel(n);
+      l = n.info.label as TextlabelT | undefined;
+    }
+    if (l) updateBB(g, l);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Port-label constants
+// @see lib/common/const.h:PORT_LABEL_DISTANCE / PORT_LABEL_ANGLE
+// ---------------------------------------------------------------------------
+
+/** Default port-label distance in points. @see lib/common/const.h:PORT_LABEL_DISTANCE */
+export const PORT_LABEL_DISTANCE = 10;
+
+/** Default port-label angle in degrees (CW negative). @see lib/common/const.h:PORT_LABEL_ANGLE */
+export const PORT_LABEL_ANGLE = -25;
+
+// ---------------------------------------------------------------------------
+// cubicBezierAt — de Casteljau at parameter t (Bezier() in utils.c)
+// @see lib/common/utils.c:175-203
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluate a cubic Bezier curve at parameter t using the de Casteljau
+ * triangle computation.  Requires pts[0..3].  No Left/Right subdivision
+ * output needed here, so they are omitted.
+ *
+ * @see lib/common/utils.c:Bezier
+ */
+function cubicBezierAt(pts: readonly { x: number; y: number }[], t: number): { x: number; y: number } {
+  // Triangle computation (degree = 3)
+  const p0 = pts[0], p1 = pts[1], p2 = pts[2], p3 = pts[3];
+  const mt = 1.0 - t;
+  // Level 1
+  const q0 = { x: mt * p0.x + t * p1.x, y: mt * p0.y + t * p1.y };
+  const q1 = { x: mt * p1.x + t * p2.x, y: mt * p1.y + t * p2.y };
+  const q2 = { x: mt * p2.x + t * p3.x, y: mt * p2.y + t * p3.y };
+  // Level 2
+  const r0 = { x: mt * q0.x + t * q1.x, y: mt * q0.y + t * q1.y };
+  const r1 = { x: mt * q1.x + t * q2.x, y: mt * q1.y + t * q2.y };
+  // Level 3
+  return { x: mt * r0.x + t * r1.x, y: mt * r0.y + t * r1.y };
+}
+
+// ---------------------------------------------------------------------------
+// Bezier endpoint extraction helpers
+// @see lib/common/splines.c:place_portlabel:1331-1351
+// ---------------------------------------------------------------------------
+
+type BezierSeg = { list: { x: number; y: number }[]; size: number; sflag: number; eflag: number; sp: { x: number; y: number }; ep: { x: number; y: number } };
+
+/**
+ * Extract (pe = endpoint, pf = near-endpoint) for the tail end of the spline.
+ * pe is the exact endpoint; pf is a point 10% along the curve toward the head,
+ * used to compute the tangent direction for label placement.
+ *
+ * @see lib/common/splines.c:place_portlabel:1331-1339
+ */
+function tailEndpoints(bez: BezierSeg): { pe: { x: number; y: number }; pf: { x: number; y: number } } {
+  if (bez.sflag) {
+    return { pe: bez.sp, pf: bez.list[0] };
+  }
+  const pe = bez.list[0];
+  const pf = cubicBezierAt(bez.list, 0.1);
+  return { pe, pf };
+}
+
+/**
+ * Extract (pe = endpoint, pf = near-endpoint) for the head end of the spline.
+ * pe is the exact endpoint; pf is a point 90% along the curve from the tail,
+ * used to compute the tangent direction for label placement.
+ *
+ * C indexes with `bez->size`, NOT the allocation length: arrow clipping
+ * (`arrow_clip`) shrinks `size` while the backing array keeps stale trailing
+ * points, so `list.length` can exceed the live point count.
+ *
+ * @see lib/common/splines.c:place_portlabel:1341-1351
+ */
+function headEndpoints(bez: BezierSeg): { pe: { x: number; y: number }; pf: { x: number; y: number } } {
+  if (bez.eflag) {
+    return { pe: bez.ep, pf: bez.list[bez.size - 1] };
+  }
+  const pe = bez.list[bez.size - 1];
+  const last4 = bez.list.slice(bez.size - 4, bez.size);
+  const pf = cubicBezierAt(last4, 0.9);
+  return { pe, pf };
+}
+
+// ---------------------------------------------------------------------------
+// place_portlabel
+// @see lib/common/splines.c:1316-1360
+// ---------------------------------------------------------------------------
+
+/**
+ * Place the head or tail port label for edge e.
+ *
+ * Returns true on success, false when:
+ *   - edge_type is IGNORED, or
+ *   - neither labelangle nor labeldistance attrs are set (labels are then
+ *     treated as external xlabel-style labels, not placed here), or
+ *   - the spline is not yet computed.
+ *
+ * NOTE: The C code only places port labels when at least one of
+ * E_labelangle / E_labeldistance has a non-empty value. When both are
+ * absent (the common case), it returns 0 and the labels remain unpositioned.
+ * In the C pipeline the renderer then falls back to xlabel-style placement.
+ * For the quarantine reference, the labels *are* placed — meaning one of
+ * the two attrs has an implicit value in the C attr-symbol table.  We
+ * replicate the C condition faithfully: check whether the edge's own
+ * attrs contain a non-empty value for either key.
+ *
+ * @see lib/common/splines.c:place_portlabel
+ */
+export function placePortlabel(e: Edge, headP: boolean): boolean {
+  if (edgeTypeIgnored(e)) return false;
+  if (noAngleAttrs(e)) return false;
+  if (labelMissing(e, headP)) return false;
+  if (splineMissing(e)) return false;
+  return applyPortlabelPos(e, headP);
+}
+
+/** True when edge_type is IGNORED (0 when unset counts as not-IGNORED). */
+function edgeTypeIgnored(e: Edge): boolean {
+  const et = e.info.edge_type;
+  if (et === undefined) return false;
+  return et === IGNORED;
+}
+
+/** True when neither labelangle nor labeldistance has a non-empty value. */
+function noAngleAttrs(e: Edge): boolean {
+  const a = e.attrs.get('labelangle');
+  const d = e.attrs.get('labeldistance');
+  if (a !== undefined && a !== '') return false;
+  if (d !== undefined && d !== '') return false;
+  return true;
+}
+
+/** True when the relevant port label is absent. */
+function labelMissing(e: Edge, headP: boolean): boolean {
+  if (headP) return e.info.head_label === undefined;
+  return e.info.tail_label === undefined;
+}
+
+/** True when no computed spline exists yet. */
+function splineMissing(e: Edge): boolean {
+  if (e.info.spl === undefined) return true;
+  return e.info.spl.list.length === 0;
+}
+
+/**
+ * Compute and write position for one port label; returns true.
+ * Pre-condition: guards passed (label exists, spline exists).
+ * @see lib/common/splines.c:place_portlabel:1353-1359
+ */
+function applyPortlabelPos(e: Edge, headP: boolean): boolean {
+  const spl  = e.info.spl!;
+  // C: &spl->list[spl->size - 1] — index by the live size, not list.length.
+  const ends = headP
+    ? headEndpoints(spl.list[spl.size - 1])
+    : tailEndpoints(spl.list[0]);
+  const l           = headP ? e.info.head_label! : e.info.tail_label!;
+  const angleStr    = e.attrs.get('labelangle')    ?? '';
+  const distanceStr = e.attrs.get('labeldistance') ?? '';
+  writePortlabelPos(l, ends.pe, ends.pf, angleStr, distanceStr);
+  return true;
+}
+
+/**
+ * Write pos onto label given endpoint pair and attr strings.
+ * @see lib/common/splines.c:place_portlabel:1353-1359
+ */
+function writePortlabelPos(
+  l: TextlabelT,
+  pe: { x: number; y: number },
+  pf: { x: number; y: number },
+  angleStr: string,
+  distanceStr: string,
+): void {
+  const angleDeg = lateDouble(angleStr, PORT_LABEL_ANGLE, -180.0);
+  const angle    = Math.atan2(pf.y - pe.y, pf.x - pe.x) + (Math.PI / 180) * angleDeg;
+  const distMult = lateDouble(distanceStr || undefined, 1.0, 0.0);
+  const dist     = PORT_LABEL_DISTANCE * distMult;
+  l.pos.x = pe.x + dist * Math.cos(angle);
+  l.pos.y = pe.y + dist * Math.sin(angle);
+  l.set   = true;
+}
+
+// ---------------------------------------------------------------------------
+// updateBB — extend graph bb to include label
+// @see lib/dotgen/dotsplines.c:446 (updateBB call)
+// ---------------------------------------------------------------------------
+
+/** Expand g.info.bb to include the label's bounding box. */
+export function updateBB(g: Graph, l: TextlabelT): void {
+  const bb = g.info.bb;
+  // C's updateBB -> addLabelBB(bb, lp, GD_flip(g)) swaps the label's dimen axes
+  // under flip (rankdir=LR/RL): the stored dimen is unflipped, so in flipped
+  // coordinate space width=dimen.y and height=dimen.x. Labels are stored
+  // unflipped here too (every other consumer swaps via `flip ? dimen.y : x`),
+  // so updateBB must swap as well. @see lib/common/utils.c:569 addLabelBB
+  const flip = g.info.flip === true;
+  const hw = (flip ? l.dimen.y : l.dimen.x) / 2;
+  const hh = (flip ? l.dimen.x : l.dimen.y) / 2;
+  if (l.pos.x - hw < bb.ll.x) bb.ll.x = l.pos.x - hw;
+  if (l.pos.y - hh < bb.ll.y) bb.ll.y = l.pos.y - hh;
+  if (l.pos.x + hw > bb.ur.x) bb.ur.x = l.pos.x + hw;
+  if (l.pos.y + hh > bb.ur.y) bb.ur.y = l.pos.y + hh;
+}
+
+// ---------------------------------------------------------------------------
+// placeRegularEdgeLabels — post-routing label placement loop
+// @see lib/dotgen/dotsplines.c:422-430
+// ---------------------------------------------------------------------------
+
+/**
+ * After edge routing completes, place regular edge labels from virtual nodes
+ * and expand the graph bounding box to include each label.
+ *
+ * Called once per graph after the parallel-edge routing loop and before
+ * edge_normalize.  Mirrors the C post-routing place_vnlabel + updateBB loop
+ * at dotsplines.c:422-430.  Flat-edge virtual nodes (in.size == 0) are
+ * skipped inside placeVnlabel as in C.
+ *
+ * @see lib/dotgen/dotsplines.c:422-430
+ */
+export function placeRegularEdgeLabels(g: Graph): void {
+  for (let n: Node | undefined = g.info.nlist; n; n = n.info.next) {
+    if ((n.info.node_type ?? 0) !== VIRTUAL) continue;
+    const l = n.info.label as TextlabelT | undefined;
+    if (!l) continue;
+    placeVnlabel(n);
+    if (l.set) updateBB(g, l);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// placePortLabels — the placement loop from dotsplines.c:440-458
+// @see lib/dotgen/dotsplines.c:440-458
+// ---------------------------------------------------------------------------
+
+/**
+ * Is an edge attribute DECLARED anywhere in the graph? Models C's
+ * `E_<attr> = agfindedgeattr(g, "<attr>")` (`input.c:772-778`), which resolves
+ * the attribute *declaration* on the **root** — it is graph-global, not
+ * per-subgraph.
+ *
+ * Scoping to the root is load-bearing under `pack`: `dot_position` runs on each
+ * projected COMPONENT, and a component holds only its own edges. Scanning `g`
+ * would miss a declaration made on an edge in a sibling component, where C's
+ * root-scoped `agfindedgeattr` still sees it.
+ *
+ * @see lib/common/input.c:772 (E_headlabel/E_taillabel/E_labelangle/E_labeldistance)
+ */
+function edgeAttrDeclared(g: Graph, ...names: string[]): boolean {
+  const root = g.root;
+  for (const name of names) {
+    if (root.attrs.has(name)) return true; // `edge [<name>=...]` default
+  }
+  for (const e of root.edges) {
+    for (const name of names) {
+      if (e.attrs.has(name)) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Walk all nodes and edges; call placePortlabel for head/tail labels.
+ *
+ * C's gates are on the attribute DECLARATIONS, not on `GD_has_labels`:
+ *
+ *   if ((E_headlabel || E_taillabel) && (E_labelangle || E_labeldistance)) {
+ *       for (n = agfstnode(g); ...) {
+ *           if (E_headlabel) { ...place_portlabel(e, true)... }
+ *           if (E_taillabel) { ...place_portlabel(e, false)... }
+ *       }
+ *   }
+ *
+ * The port previously gated the two inner branches on
+ * `GD_has_labels & HEAD_LABEL/TAIL_LABEL`. That is NOT C, and it broke under
+ * `pack`: `has_labels` is OR'd onto the true cgraph root (`common_init_edge`,
+ * utils.c:521), so a projected component's own flag is 0 and BOTH branches were
+ * skipped — the head/tail labels kept their unplaced default position instead
+ * of being offset by labelangle/labeldistance. The per-edge
+ * `ED_head_label == NULL` checks inside the loops already do the real filtering,
+ * exactly as in C.
+ *
+ * @see lib/dotgen/dotsplines.c:440-458
+ */
+export function placePortLabels(g: Graph): void {
+  if (!edgeAttrDeclared(g, 'headlabel', 'taillabel')) return;
+  if (!edgeAttrDeclared(g, 'labelangle', 'labeldistance')) return;
+  if (edgeAttrDeclared(g, 'headlabel')) placeHeadLabels(g);
+  if (edgeAttrDeclared(g, 'taillabel')) placeTailLabels(g);
+}
+
+/**
+ * Place head port labels for all in-edges of every node.
+ * @see lib/dotgen/dotsplines.c:442-447
+ */
+function placeHeadLabels(g: Graph): void {
+  for (const n of nodesInSeq(g)) {
+    for (const e of g.edges) {
+      if (e.head !== n) continue;
+      if (e.info.head_label === undefined) continue;
+      if (placePortlabel(e, true)) updateBB(g, e.info.head_label);
+    }
+  }
+}
+
+/**
+ * Place tail port labels for all out-edges of every node.
+ * @see lib/dotgen/dotsplines.c:449-455
+ */
+function placeTailLabels(g: Graph): void {
+  for (const n of nodesInSeq(g)) {
+    for (const e of g.edges) {
+      if (e.tail !== n) continue;
+      if (e.info.tail_label === undefined) continue;
+      if (placePortlabel(e, false)) updateBB(g, e.info.tail_label);
+    }
+  }
+}

package/src/layout/dot/splines-route-type.ts

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Edge-type dispatch for regular (cross-rank) edge routing.
+ *
+ * `make_regular_edge` routes the box corridor through `routesplines` for
+ * `EDGETYPE_SPLINE` and `routepolylines` otherwise; for `EDGETYPE_LINE` it
+ * additionally straightens a polyline of more than 4 points down to a 4-point
+ * line (first/last control points only). This module is the single home for
+ * that dispatch + straighten, called by every box-corridor emit point.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (1799-1808, 1849-1861)
+ */
+
+import type { Point } from '../../model/geom.js';
+import type { Path } from '../../common/types.js';
+import { routeSplines, routePolylines } from '../../common/splines-routespl.js';
+import { EDGETYPE_SPLINE, EDGETYPE_LINE } from './splines.js';
+
+/**
+ * Route the box corridor in `P` according to the edge type `et`.
+ *
+ * - `EDGETYPE_SPLINE` → `routeSplines` (the default; identical to before).
+ * - any other type → `routePolylines`.
+ * - `EDGETYPE_LINE` with a result of more than 4 points → straighten to the
+ *   4-point line `[p0, p0, pLast, pLast]`.
+ *
+ * Returns the control points, or `null`/empty exactly as the underlying
+ * `routeSplines`/`routePolylines` do (the caller treats that as a decline).
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ */
+export function routeRegularByType(P: Path, et: number): Point[] | null {
+  if (et === EDGETYPE_SPLINE) return routeSplines(P);
+  const ps = routePolylines(P);
+  if (et === EDGETYPE_LINE && ps !== null && ps.length > 4) {
+    // Straighten the polyline to a line: keep only the endpoints.
+    // C: ps[1]=ps[0]; ps[3]=ps[2]=ps[pn-1]; pn=4.
+    const p0 = ps[0];
+    const pLast = ps[ps.length - 1];
+    return [p0, p0, pLast, pLast];
+  }
+  return ps;
+}