@knowvah/dot-engine 2.3.0 → 2.4.0

package/src/layout/circo/crossings.ts

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Crossing reduction for one block's circle order: count_all_crossings (with
+ * its open-edge-list quirks), insertNodelist and the reduce passes. Split out
+ * of blockpath.ts for file size; bodies unchanged.
+ *
+ * @see lib/circogen/blockpath.c:count_all_crossings / reduce / reduce_edge_crossings
+ * @see lib/circogen/nodelist.c:insertNodelist
+ */
+
+import type { Node } from '../../model/node.js';
+import type { DerivedNode, DerivedEdge } from './blocks.js';
+
+// ---------------------------------------------------------------------------
+// Crossing counting helpers (each branch extracted to keep CCN low)
+// ---------------------------------------------------------------------------
+
+export function derivedOf(n: Node): DerivedNode | null {
+  return (n.info.alg as { derivedNode?: DerivedNode } | undefined)?.derivedNode ?? null;
+}
+
+export function closeOpenEdge(e: DerivedEdge, d: DerivedNode, opened: Iterable<DerivedEdge>): number {
+  let cross = 0;
+  for (const o of opened) {
+    if (o.order > e.order && o.tail !== d && o.head !== d) cross++;
+  }
+  return cross;
+}
+
+/**
+ * Every node's incident edges in agfstedge order: out-edges by head, then
+ * in-edges by tail (node creation order, ties by edge sequence) — the order
+ * spanIncident uses, keyed by orig.id because layoutBlock sorts the block's
+ * nodes that way. @see lib/cgraph/edge.c:agfstedge
+ */
+export function agfstedgeLists(edges: DerivedEdge[]): Map<DerivedNode, DerivedEdge[]> {
+  const seq = new Map<DerivedEdge, number>();
+  edges.forEach((e, i) => seq.set(e, i));
+  const by = (end: (e: DerivedEdge) => DerivedNode) => (a: DerivedEdge, b: DerivedEdge): number =>
+    (end(a).orig.id - end(b).orig.id) || (seq.get(a)! - seq.get(b)!);
+  const out = new Map<DerivedNode, DerivedEdge[]>();
+  const inn = new Map<DerivedNode, DerivedEdge[]>();
+  for (const e of edges) {
+    out.set(e.tail, [...(out.get(e.tail) ?? []), e]);
+    inn.set(e.head, [...(inn.get(e.head) ?? []), e]);
+  }
+  const lists = new Map<DerivedNode, DerivedEdge[]>();
+  for (const d of new Set([...out.keys(), ...inn.keys()])) {
+    const o = (out.get(d) ?? []).sort(by((e) => e.head));
+    const i = (inn.get(d) ?? []).sort(by((e) => e.tail));
+    lists.set(d, [...o, ...i]);
+  }
+  return lists;
+}
+
+/**
+ * C's count_all_crossings — INCLUDING its load-bearing bug: remove_edge keys
+ * the open-edge dict by the half-edge POINTER handed to it, and add_edge
+ * stored the half that the OPENING node's agfstedge yielded. Closing at the
+ * other endpoint yields the opposite half, so dtdelete misses and the edge
+ * stays open; each close therefore counts EVERY edge opened after it, minus
+ * edges incident to the closing node. Only when a node is on the list twice
+ * (a place_residual_nodes quirk) does its second visit yield the stored half,
+ * so the edges it opened ARE removed — in agfstedge order, between the counts.
+ * Do not "fix" either behaviour: the final circle order depends on both.
+ * @see lib/circogen/blockpath.c:count_all_crossings
+ * @see lib/circogen/edgelist.c:remove_edge
+ */
+export function countCrossings(list: Node[], edges: DerivedEdge[]): number {
+  for (const e of edges) e.order = 0;
+  const incident = agfstedgeLists(edges);
+  const opened = new Map<DerivedEdge, DerivedNode>(); // edge → node whose half add_edge stored
+  let crossings = 0; let order = 1;
+  for (const n of list) {
+    const d = derivedOf(n);
+    if (!d) continue;
+    const es = incident.get(d) ?? [];
+    crossings += closeEdgesAt(d, es, opened);
+    for (const e of es) {
+      if (e.order === 0) { e.order = order; opened.set(e, d); }
+    }
+    order++;
+  }
+  return crossings;
+}
+
+/**
+ * count_all_crossings' close loop at node d: count against the open list,
+ * then remove_edge — a hit only for edges add_edge stored from d itself.
+ */
+export function closeEdgesAt(d: DerivedNode, es: DerivedEdge[], opened: Map<DerivedEdge, DerivedNode>): number {
+  let crossings = 0;
+  for (const e of es) {
+    if (e.order === 0) continue;
+    crossings += closeOpenEdge(e, d, opened.keys());
+    if (opened.get(e) === d) opened.delete(e); // remove_edge: same half → dtdelete hits
+  }
+  return crossings;
+}
+
+// ---------------------------------------------------------------------------
+// Crossing reduction
+// ---------------------------------------------------------------------------
+
+export function insertNode(list: Node[], cn: Node, neighbor: Node, pos: number): void {
+  const i = list.indexOf(cn); if (i !== -1) list.splice(i, 1);
+  const ni = list.indexOf(neighbor);
+  if (ni === -1) { list.push(cn); return; }
+  list.splice(pos === 0 ? ni : ni + 1, 0, cn);
+}
+
+/**
+ * One reduce pass, mirroring C's reduce (blockpath.c:439): iterate the
+ * SUBGRAPH's nodes in agfstnode (root-seq) order — NOT the current list
+ * order — and each node's incident edges in agfstedge order; the neighbour
+ * is agtail(e) unless that is curnode. The first-improving-move order is
+ * load-bearing for the final arrangement.
+ */
+export function reducePass(
+  list: Node[], edges: DerivedEdge[], cnt: { v: number }, nodes: DerivedNode[],
+): void {
+  const ord = new Map<DerivedNode, number>();
+  nodes.forEach((dn, i) => ord.set(dn, i));
+  const seq = new Map<DerivedEdge, number>();
+  edges.forEach((e, i) => seq.set(e, i));
+  for (const dn of nodes) {
+    for (const e of spanIncident(dn, edges, ord, seq)) {
+      let neighbor = e.tail;
+      if (neighbor === dn) neighbor = e.head;
+      for (const pos of [0, 1] as const) {
+        const copy = [...list];
+        insertNode(list, dn.orig, neighbor.orig, pos);
+        const nc = countCrossings(list, edges);
+        if (nc < cnt.v) { cnt.v = nc; if (cnt.v === 0) return; }
+        else { list.length = 0; list.push(...copy); }
+      }
+    }
+  }
+}
+
+const CROSS_ITER = 10;
+
+/** @see lib/circogen/blockpath.c:reduce_edge_crossings */
+export function reduceEdgeCrossings(
+  list: Node[], edges: DerivedEdge[], nodes: DerivedNode[],
+): Node[] {
+  const cnt = { v: countCrossings(list, edges) };
+  for (let i = 0; i < CROSS_ITER && cnt.v > 0; i++) {
+    const prev = cnt.v; reducePass(list, edges, cnt, nodes);
+    if (prev === cnt.v) break;
+  }
+  return list;
+}
+
+/**
+ * Incident edges of dn in agfstedge order over the (possibly pruned)
+ * subgraph edge set: out-edges (by head order, seq) then in-edges (by tail
+ * order, seq). `ord`/`seq` maps carry the derived root's node and edge
+ * creation orders. @see lib/cgraph/edge.c:agfstedge
+ */
+export function spanIncident(
+  dn: DerivedNode, edges: DerivedEdge[],
+  ord: Map<DerivedNode, number>, seq: Map<DerivedEdge, number>,
+): DerivedEdge[] {
+  const out = edges.filter((e) => e.tail === dn)
+    .sort((a, b) => ((ord.get(a.head) ?? 0) - (ord.get(b.head) ?? 0)) || ((seq.get(a) ?? 0) - (seq.get(b) ?? 0)));
+  const inn = edges.filter((e) => e.head === dn)
+    .sort((a, b) => ((ord.get(a.tail) ?? 0) - (ord.get(b.tail) ?? 0)) || ((seq.get(a) ?? 0) - (seq.get(b) ?? 0)));
+  return [...out, ...inn];
+}

package/src/layout/dot/__fixtures__/2784.dot

@@ -0,0 +1 @@
+graph{00splines="ortho"0e[0=""]2[0=""height="30000000000000000"]1[0=0]6[0=0]}

package/src/layout/dot/__fixtures__/2784.native-16.1.svg

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 16.1.0 (20261012.1431)
+ -->
+<!-- Pages: 1 -->
+<svg width="422pt" height="1255669760pt"
+ viewBox="0.00 0.00 422.00 1255669760.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(31 2160000000000000000)">
+<polygon fill="white" stroke="none" points="-31,0 -31,-2160000000000000000 391,-2160000000000000000 391,0 -31,0"/>
+<!-- 00 -->
+<g id="node1" class="node">
+<title>00</title>
+<ellipse fill="none" stroke="black" cx="0" cy="-1080000000000000000" rx="27" ry="0"/>
+<text xml:space="preserve" text-anchor="middle" x="0" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">00</text>
+</g>
+<!-- 0 -->
+<g id="node2" class="node">
+<title>0</title>
+<ellipse fill="none" stroke="black" cx="72" cy="-1080000000000000000" rx="27" ry="0"/>
+<text xml:space="preserve" text-anchor="middle" x="72" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">0</text>
+</g>
+<!-- e -->
+<g id="node3" class="node">
+<title>e</title>
+<ellipse fill="none" stroke="black" cx="144" cy="-1080000000000000000" rx="27" ry="0"/>
+<text xml:space="preserve" text-anchor="middle" x="144" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">e</text>
+</g>
+<!-- 2 -->
+<g id="node4" class="node">
+<title>2</title>
+<ellipse fill="none" stroke="black" cx="216" cy="-1080000000000000000" rx="27" ry="1080000000000000000"/>
+<text xml:space="preserve" text-anchor="middle" x="216" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">2</text>
+</g>
+<!-- 1 -->
+<g id="node5" class="node">
+<title>1</title>
+<ellipse fill="none" stroke="black" cx="288" cy="-1080000000000000000" rx="27" ry="0"/>
+<text xml:space="preserve" text-anchor="middle" x="288" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">1</text>
+</g>
+<!-- 6 -->
+<g id="node6" class="node">
+<title>6</title>
+<ellipse fill="none" stroke="black" cx="360" cy="-1080000000000000000" rx="27" ry="0"/>
+<text xml:space="preserve" text-anchor="middle" x="360" y="-1080000000000000000" font-family="Times,serif" font-size="14.00">6</text>
+</g>
+</g>
+</svg>

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

@@ -233,11 +233,13 @@ function routeChainSegmented(
  * Route a forward edge spanning ≥2 ranks via its virtual-node chain through the
  * faithful pipeline (REGULAREDGE side boxes steer the port, routeSplines over
  * the chain; adjustregularpath inter-rank widening finally fires). Returns
- * control points in graphviz-internal y-up, or null when the edge is not a
- * multi-rank chain.
+ * control points in graphviz-internal y-up, null when the edge is not a
+ * multi-rank chain, or 'lost' when the chain walk was attempted and failed
+ * (completeregularpath / routesplines failure): C's make_regular_edge returns
+ * with no spline and the edge is never routed again.
  * @see lib/dotgen/dotsplines.c:make_regular_edge (hackflag forward path)
  */
-export function routeMultiRankEdgeFaithful(g: Graph, e: GraphEdge): Point[] | null {
+export function routeMultiRankEdgeFaithful(g: Graph, e: GraphEdge): Point[] | null | 'lost' {
   const r = e.tail.info.rank;
   const rh = e.head.info.rank;
   if (g.info.rank === undefined || r === undefined || rh === undefined || rh <= r + 1) return null;
@@ -260,7 +262,7 @@ export function routeMultiRankEdgeFaithful(g: Graph, e: GraphEdge): Point[] | nu
   // record port resolves toward the adjacent-rank vnode, not the far real
   // endpoint). @see lib/dotgen/dotsplines.c:make_regular_edge (tn/hn walk),
   // lib/dotgen/fastgr.c:new_virtual_edge (port copies)
-  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
+  return routeChainSegmented(g, segs[0], segs[segs.length - 1], segs) ?? 'lost';
 }
 
 /**
@@ -414,7 +416,11 @@ export function routeBackEdge(e: GraphEdge, _tailBox: NodeBox, _headBox: NodeBox
   // bezier_clip keeps the load-bearing forward direction (1644).
   // @see lib/dotgen/dotsplines.c:make_regular_edge (segfirst/tn/hn walk)
   const fwd = routeChainSegmented(g, segs[0], segs[segs.length - 1], segs);
-  if (fwd === null) return;
+  // Chain routing failed: C's make_regular_edge returns with no spline and
+  // dot_splines_ never revisits the edge — mark it consumed so the backstop
+  // sweep does not re-route (and re-report) it.
+  // @see lib/dotgen/dotsplines.c:make_regular_edge (pn == 0 return)
+  if (fwd === null) { e.info.lost = true; return; }
   clipAndInstall(fwdEdge, fwdEdge.head, fwd, fwd.length, buildDotSinfo());
   if (swapEndsP(e)) swapEdgeSpline(e);
 }

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

@@ -33,8 +33,8 @@ import { ShapeKind, type ShapeDesc } from '../../common/types.js';
 import {
   collectNonAdjacentFlatGroup, routeFlatEdgeGroupFaithful,
 } from './splines-flat-multi.js';
-import { makeFlatLabeledEdge, makeAdjFlatNoPortEdge } from './splines-flat-labeled.js';
-import { EDGETYPE_SPLINE, swapEndsP, swapEdgeSpline, getMainEdge } from './splines.js';
+import { makeFlatLabeledEdge, makeAdjFlatNoPortEdge, isAdjFlatCandidate } from './splines-flat-labeled.js';
+import { edgeType, swapEndsP, swapEdgeSpline, getMainEdge } from './splines.js';
 import { FLATORDER } from './fastgr.js';
 import { IGNORED } from './rank.js';
 import { buildDotSinfo } from './self-loop.js';
@@ -281,6 +281,7 @@ export function routeOneEdge(e: GraphEdge, g: Graph): void {
 function routeFaithfulMultiRank(e: GraphEdge, g: Graph): boolean {
   const pts = routeMultiRankEdgeFaithful(g, e);
   if (pts === null) return false;
+  if (pts === 'lost') { e.info.lost = true; return true; } // C: edge lost, no spline
   clipAndInstall(e, e.head, pts, pts.length, buildDotSinfo());
   return true;
 }
@@ -312,9 +313,18 @@ function isAdjacentPortFlat(e: GraphEdge, g: Graph): boolean {
     && isFlatAdjacent(g, e) && hasDefinedPort(e);
 }
 
-/** True when x is an unrouted adjacent same-rank flat edge with a port. */
+/** True when x is an unrouted adjacent same-rank flat edge (port or not): C
+ *  groups by main edge only, so a port-less sibling joins the aux call. */
 function isGroupableFlat(x: GraphEdge, g: Graph): boolean {
-  return x.info.spl === undefined && isAdjacentPortFlat(x, g);
+  return x.info.spl === undefined && x.tail.info.rank !== undefined
+    && x.tail.info.rank === x.head.info.rank && isFlatAdjacent(g, x);
+}
+
+/** True when a port-less adjacent flat edge shares its group with a ported one:
+ *  C's `ports` flag covers the whole group, so it routes via the aux graph. */
+function joinsPortedFlatGroup(e: GraphEdge, g: Graph): boolean {
+  return isAdjFlatCandidate(e) && isGroupableFlat(e, g)
+    && collectAdjacentFlatGroup(e, g).some(hasDefinedPort);
 }
 
 /**
@@ -362,17 +372,17 @@ function routeFaithfulSidePort(e: GraphEdge, g: Graph): boolean {
   // @see lib/dotgen/dotsplines.c:dot_splines_ (ED_adjacent edge-group loop)
   if (sameRank && isFlatAdjacent(g, e)) {
     const group = collectAdjacentFlatGroup(e, g);
-    return makeFlatAdjEdges(g, group, group.length, EDGETYPE_SPLINE) === 0
+    return makeFlatAdjEdges(g, group, group.length, edgeType(g)) === 0
       && e.info.spl !== undefined;
   }
   // Non-adjacent flats: C groups identical-port siblings into ONE make_flat_edge
   // call and nests their splines (cnt-loop). Collect the group and route once;
   // the group router clip-installs every sibling, so the main loop skips them.
-  // cnt=1 reduces to the former single routeFlatEdgeFaithful path (AD-1).
+  // cnt=1 is the single-edge case of C make_flat_edge's cnt loop (AD-1).
   // @see lib/dotgen/dotsplines.c:make_flat_edge, make_flat_bottom_edges
   if (sameRank) {
     const group = collectNonAdjacentFlatGroup(e, g);
-    return routeFlatEdgeGroupFaithful(g, group, group.length) && e.info.spl !== undefined;
+    return routeFlatEdgeGroupFaithful(g, group, group.length, edgeType(g)) && e.info.spl !== undefined;
   }
   const pts = routeRegularEdgeFaithful(g, e);
   if (pts === null) return false;
@@ -410,6 +420,7 @@ function routeFlatEdge(e: GraphEdge, g: Graph): boolean {
   // above (make_flat_adj_edges → makeSimpleFlatLabels). Both decline for every
   // other edge, so only labeled flats are diverted. @see dotsplines.c:1527-1533
   if (makeFlatLabeledEdge(g, e)) return true;
+  if (joinsPortedFlatGroup(e, g) && routeFaithfulSidePort(e, g)) return true;
   if (makeAdjFlatNoPortEdge(g, e)) return true;
   if ((hasSidePort(e) || isAdjacentPortFlat(e, g)) && routeFaithfulSidePort(e, g)) return true;
   // Non-adjacent unlabeled flat with no side port (e.g. a same-rank cross-cluster
@@ -419,7 +430,7 @@ function routeFlatEdge(e: GraphEdge, g: Graph): boolean {
       && e.info.label === undefined && !isFlatAdjacent(g, e)) {
     const group = collectNonAdjacentFlatGroup(e, g);
     if (group.length > 0
-        && routeFlatEdgeGroupFaithful(g, group, group.length)
+        && routeFlatEdgeGroupFaithful(g, group, group.length, edgeType(g))
         && e.info.spl !== undefined) return true;
   }
   return false;

package/src/layout/dot/index.ts

@@ -135,28 +135,38 @@ export function dotPhaseInit(g: Graph): void {
  * 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).
+ *
+ * Returns dot_splines' status: C's `if (r != 0) return r;` skips
+ * dot_compoundEdges, and the caller's doDot/dot_layout then skip
+ * dotneato_postprocess. Since graphviz 16.1 (8fd4b59ef) this is non-zero when
+ * splines=ortho cannot build its maze (tests/2784.dot).
  * @see lib/dotgen/dotinit.c:dotLayout (static)
  */
-export function dotPhasePostNoFinish(g: Graph): void {
+export function dotPhasePostNoFinish(g: Graph): number {
   removeFill(g);
   dotSameports(g);
-  dotSplines(g);
+  const r = dotSplines(g);
+  if (r !== 0) return r;
   // 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);
+  return 0;
 }
 
 /**
  * Phase 4: post-position passes — the no-finish tail plus gvPostprocess to
- * rotate/translate coordinates per rankdir.
+ * rotate/translate coordinates per rankdir. A splines failure is a doDot
+ * error, so `dot_layout` returns WITHOUT dotneato_postprocess: native 16.1
+ * still renders (exit 0) from the untranslated layout coordinates.
  * @see lib/dotgen/dotinit.c:dotLayout (static)
+ * @see lib/dotgen/dotinit.c:dot_layout (`if (doDot(g) != 0) return;`)
  * @see lib/common/postproc.c:dotneato_postprocess
  */
 export function dotPhasePost(g: Graph): void {
-  dotPhasePostNoFinish(g);
+  if (dotPhasePostNoFinish(g) !== 0) return;
   gvPostprocess(g);
 }
 

package/src/layout/dot/ortho-adapter.ts

@@ -58,7 +58,9 @@ function buildNodes(nodeArr: Node[]): OrthoNodeArr {
  * parallel multi-edge) is skipped. This is ortho's own concentrate mechanism,
  * distinct from class2's `edge_type == IGNORED` marking, and the keep-first
  * decision depends on this iteration order matching C's.
- * Self-loops (tail === head) are routed elsewhere and excluded here.
+ * Self-loops (tail === head) are gathered like any other edge; orthoEdges
+ * routes them via addLoop. Only Concentrate dedup skips edges.
+ * @see lib/ortho/ortho.c:orthoEdges
  * @see lib/ortho/ortho.c:1207-1228 (orthoEdges edge gather + Concentrate PS)
  */
 function buildEdges(
@@ -74,7 +76,6 @@ function buildEdges(
     const oes = outIndex.get(n);
     if (oes === undefined) continue;
     for (const e of oes) {
-      if (e.tail === e.head) continue;
       if (concentrate) {
         const ti = e.tail.id;
         const hi = e.head.id;
@@ -103,7 +104,7 @@ function buildEdges(
   return result;
 }
 
-/** Build an OrthoGraph from the dot Graph (tail≠head edges only). */
+/** Build an OrthoGraph from the dot Graph (every out-edge, self-loops included). */
 export function buildOrthoGraph(g: Graph): OrthoGraph {
   const nodeArr = nodesInSeq(g);
   const orthoNodes = buildNodes(nodeArr);
@@ -125,9 +126,13 @@ export function installOrthoResult(oe: OrthoEdge, pts: OrthoPoint[]): void {
   clipAndInstall(origEdge, origEdge.head, pts, pts.length, ORTHO_SINFO);
 }
 
-/** Run the ortho pipeline over the dot graph, installing results (no labels). */
-export function dispatchOrthoEdges(g: Graph, useLbls: boolean): void {
-  orthoEdges(buildOrthoGraph(g), useLbls, (_og, oe, pts) =>
+/**
+ * Run the ortho pipeline over the dot graph, installing results (no labels).
+ * @returns orthoEdges' status: 0 on success, non-zero when the maze could not
+ *   be built (graphviz 16.1) — dot_splines_ returns it (8fd4b59ef)
+ */
+export function dispatchOrthoEdges(g: Graph, useLbls: boolean): number {
+  return orthoEdges(buildOrthoGraph(g), useLbls, (_og, oe, pts) =>
     installOrthoResult(oe, pts),
   );
 }

package/src/layout/dot/pack-components.ts

@@ -216,9 +216,12 @@ export function initSubg(sg: Graph, root: Graph): void {
  * ranking reads them. Node sizing in `dotPhaseInit` reads `sg.root.info.flip`
  * (the real root), so it is correct regardless of this ordering.
  *
+ * Returns the component's dot_splines status (non-zero = C's dotLayout(sg)
+ * failing, which makes doDot return before packing). The mincross/position
+ * statuses are not consulted on this arm.
  * @see lib/dotgen/dotinit.c:dotLayout (static)
  */
-export function dotLayoutComponent(sg: Graph, root: Graph): void {
+export function dotLayoutComponent(sg: Graph, root: Graph): number {
   // C: dotLayout(sg) begins with dot_init_subg(sg, sg), which sets
   // GD_dotroot(agroot(sg)) = sg so dot_root() returns the COMPONENT during its
   // layout (so mincross/position treat it as their root, not as a cluster).
@@ -246,7 +249,7 @@ export function dotLayoutComponent(sg: Graph, root: Graph): void {
   dotRank(sg);
   dotMincross(sg);
   dotPosition(sg);
-  dotPhasePostNoFinish(sg);
+  return dotPhasePostNoFinish(sg);
 }
 
 // ---------------------------------------------------------------------------
@@ -416,8 +419,12 @@ export function layoutAndPack(
 ): void {
   // Seed the root's drawing-info (C: graph_init before doDot set GD_rankdir2 etc).
   dotGraphInit(root);
-  // C: for each component { initSubg(sg, g); dotLayout(sg); }
-  for (const sg of comps) dotLayoutComponent(sg, root);
+  // C: for each component { initSubg(sg, g); rc = dotLayout(sg); if (rc != 0)
+  //    { free(ccs); return rc; } } — a failure skips packing, cluster carry
+  //    and the root dotneato_postprocess (dot_layout returns on doDot error).
+  for (const sg of comps) {
+    if (dotLayoutComponent(sg, root) !== 0) return;
+  }
   // C: attachPos(g) [points: unneeded]; packSubgraphs(ncc, ccs, g, &pinfo);
   //    resetCoord(g) [points: unneeded]. Cluster-inclusive bboxes so packed
   //    clusters get native spacing (the pack module's bbox is node-only).

package/src/layout/dot/splines-flat-multi.ts

@@ -8,8 +8,8 @@
  * flat edge between a same-rank node pair into ONE call and NEST their splines:
  * `stepx = Multisep/(cnt+1)`, `stepy = vspace/(cnt+1)`; ONE shared makeFlatEnd
  * tail+head; then edge `i` is offset by `(i+1)*step` on the two END boxes while
- * the MIDDLE box keeps plain `stepy`. cnt=1 reduces to routeFlatEdgeFaithful
- * (`Multisep/2 = nodesep/2`, `(0+1)*step = step`) — identical (AD-1).
+ * the MIDDLE box keeps plain `stepy`. cnt=1 is the single-edge case
+ * of C make_flat_edge (`Multisep/2 = nodesep/2`, `(0+1)*step = step`) (AD-1).
  *
  * The port routes each non-adjacent flat independently at `nodesep/2`, so cnt>=2
  * edges come out identical/overlapping; this module restores the nesting.
@@ -22,10 +22,12 @@ import type { Edge } from '../../model/edge.js';
 import type { Node } from '../../model/node.js';
 import type { Port, Box } from '../../model/geom.js';
 import type { Path, PathendT } from '../../common/types.js';
-import { routeSplines } from '../../common/splines-routespl.js';
+import { routeSplines, routePolylines } from '../../common/splines-routespl.js';
 import { clipAndInstall } from '../../common/splines-clip.js';
 import { graphRanksep } from './position-aux.js';
 import { buildDotSinfo } from './self-loop.js';
+import { EDGETYPE_LINE, EDGETYPE_SPLINE } from './splines.js';
+import { makeSimpleFlat } from './splines-flat-labeled.js';
 import {
   isFlatAdjacent, makeFlatEndBox, topBoxes, bottomBoxes, flatSide, flatVspace,
   freshFlatPath, assembleFlatPath, flatBboxCtx,
@@ -41,6 +43,8 @@ interface GroupRouteCtx {
   tlast: Box;
   hlast: Box;
   bottom: boolean;
+  /** Edge type: SPLINE routes with routesplines, anything else routepolylines. */
+  et: number;
   stepx: number;
   stepy: number;
   /** Geometric left end node of the channel (lower order). routeSplines yields
@@ -132,7 +136,8 @@ function routeGroupEdge(e: Edge, i: number, c: GroupRouteCtx): boolean {
     ? bottomBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy)
     : topBoxes(c.tlast, c.hlast, endStepX, endStepY, c.stepy);
   assembleFlatPath(c.P, copyPathEnd(c.tend), copyPathEnd(c.hend), mid);
-  const pts = routeSplines(c.P);
+  // @see lib/dotgen/dotsplines.c:1603-1607 (et == EDGETYPE_SPLINE ? routesplines : routepolylines)
+  const pts = c.et === EDGETYPE_SPLINE ? routeSplines(c.P) : routePolylines(c.P);
   if (pts === null || pts.length === 0) return false;
   // routeSplines returns points left→right (tend = leftNode). Reverse for an edge
   // whose tail is the right node so the points run tail→head; pass ignoreSwap so
@@ -147,14 +152,22 @@ function routeGroupEdge(e: Edge, i: number, c: GroupRouteCtx): boolean {
 /**
  * Faithful make_flat_edge / make_flat_bottom_edges cnt-loop: ONE shared
  * makeFlatEnd tail+head; for i in 0..cnt-1 route edge i nested by (i+1)*step.
- * Installs spl on every edges[i]; returns true iff all installed. cnt=1 reduces
- * to routeFlatEdgeFaithful (AD-1). `edges` must be group-ordered (collect...).
+ * Installs spl on every edges[i]; returns true iff all installed. cnt=1 is the
+ * single-edge case of C make_flat_edge (AD-1). `edges` must be group-ordered (collect...).
+ * `et == EDGETYPE_LINE` short-circuits to makeSimpleFlat (C 1535-1537); the
+ * corridor router is routesplines only for EDGETYPE_SPLINE, else routepolylines.
  * @see lib/dotgen/dotsplines.c:make_flat_edge, make_flat_bottom_edges
  */
-export function routeFlatEdgeGroupFaithful(g: Graph, edges: Edge[], cnt: number): boolean {
+export function routeFlatEdgeGroupFaithful(
+  g: Graph, edges: Edge[], cnt: number, et: number,
+): boolean {
   const lead = edges[0];
   if (g.info.rank === undefined || lead.tail.info.rank === undefined
     || lead.head.info.rank !== lead.tail.info.rank) return false;
+  if (et === EDGETYPE_LINE) {
+    makeSimpleFlat(edges, et);
+    return true;
+  }
   // C makefwdedge: build the channel left→right by node order, else the middle
   // box inverts for a right-to-left (tail right of head) flat edge.
   const tailIsLeft = (lead.tail.info.order ?? 0) <= (lead.head.info.order ?? 0);
@@ -179,7 +192,7 @@ export function routeFlatEdgeGroupFaithful(g: Graph, edges: Edge[], cnt: number)
   const stepy = flatVspace(g, leftNode, !bottom) / (cnt + 1);
   const rc: GroupRouteCtx = {
     P, tend, hend, tlast: tend.boxes[tend.boxn - 1], hlast: hend.boxes[hend.boxn - 1],
-    bottom, stepx, stepy, leftNode,
+    bottom, et, stepx, stepy, leftNode,
   };
   for (let i = 0; i < cnt; i++) {
     if (!routeGroupEdge(edges[i], i, rc)) return false;

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

@@ -25,7 +25,6 @@ import { dotSplines_, swapEndsP, swapEdgeSpline } from './splines.js';
 import { makePort } from '../../model/edgeInfo.js';
 import { beginPath } from '../../common/splines-path-begin.js';
 import { endPath } from '../../common/splines-path-end.js';
-import { routeSplines } from '../../common/splines-routespl.js';
 import { addBox, resolvePort } from '../../common/splines-path-shared.js';
 import { TOP, BOTTOM, FLATEDGE } from '../../common/splines-constants.js';
 import {
@@ -363,8 +362,11 @@ function normalizeCopiedFlatSpline(orig: Edge, auxe: Edge): void {
  * makeSimpleFlat branch are out of scope (callers gate on a side port).
  * @see lib/dotgen/dotsplines.c:make_flat_adj_edges
  */
-export function makeFlatAdjEdges(g: Graph, edges: Edge[], cnt: number, _et: number): number {
+export function makeFlatAdjEdges(g: Graph, edges: Edge[], cnt: number, et: number): number {
   const aux = buildFlatAux(g, edges, cnt);
+  // C setEdgeType(auxg, et); inlined (index.ts's setEdgeType would be an import cycle).
+  // @see lib/dotgen/dotsplines.c:make_flat_adj_edges
+  aux.auxg.info.flags = (aux.auxg.info.flags & ~0xf) | (et & 0xf);
   dotInitNodeEdge(aux.auxg);
   dotRank(aux.auxg);
   if (dotMincross(aux.auxg) !== 0) return 1;
@@ -418,12 +420,14 @@ export function makeFlatEdge(
   const isAdj = edges.some(e => (e.info.adjacent ?? 0) !== 0);
   if (isAdj) return makeFlatAdjEdges(g, edges, cnt, et);
   // C's labeled-flat dispatch lives in the live router here (AD-3): see
-  // edge-route.ts:routeForwardEdge → makeFlatLabeledEdge. Unlabeled: routeFlatEdgeFaithful.
+  // edge-route.ts:routeForwardEdge → makeFlatLabeledEdge. Unlabeled:
+  // routeFlatEdgeGroupFaithful (splines-flat-multi.ts).
   return 0;
 }
 
 // ---------------------------------------------------------------------------
-// routeFlatEdgeFaithful — faithful side-port routing for a single flat edge
+// Flat-edge routing building blocks shared by routeFlatEdgeGroupFaithful
+// (splines-flat-multi.ts) and makeFlatLabeledEdge.
 // @see lib/dotgen/dotsplines.c:make_flat_edge (non-adjacent, non-labeled,
 //      EDGETYPE_SPLINE: the top-routing branch + make_flat_bottom_edges),
 //      makeFlatEnd / makeBottomFlatEnd
@@ -565,34 +569,3 @@ export function assembleFlatPath(P: Path, tend: PathendT, hend: PathendT, mid: B
   for (const b of mid) addBox(P, b);
   for (let i = hend.boxn - 1; i >= 0; i--) addBox(P, hend.boxes[i]);
 }
-
-/**
- * Route a single same-rank (flat) edge carrying a side-mask port through the
- * faithful `beginPath → routeSplines → endPath → clipAndInstall` pipeline.
- * Returns spline control points in graphviz-internal (y-up) coordinates, or
- * null when the edge is not a same-rank edge. Does NOT clip or install — the
- * caller (routeOneEdge) does that via clipAndInstall, mirroring how SR3 wires
- * the regular faithful path.
- *
- * @see lib/dotgen/dotsplines.c:make_flat_edge (cnt=1, non-adjacent spline)
- */
-export function routeFlatEdgeFaithful(g: Graph, e: Edge): Point[] | null {
-  const tn = e.tail;
-  const r = tn.info.rank;
-  if (g.info.rank === undefined || r === undefined || e.head.info.rank !== r) return null;
-  const { bottom, side } = flatSide(e);
-  const ctx = flatBboxCtx(g);
-  const ranksep = graphRanksep(g);
-  const P = freshFlatPath();
-  const tend = makeFlatEndBox({ ctx, P, e, n: tn, side, ranksep, isBegin: true });
-  const hend = makeFlatEndBox({ ctx, P, e, n: e.head, side, ranksep, isBegin: false });
-  const stepx = (g.info.nodesep ?? 18) / 2;
-  const stepy = flatVspace(g, tn, !bottom) / 2;
-  const tlast = tend.boxes[tend.boxn - 1];
-  const hlast = hend.boxes[hend.boxn - 1];
-  const mid = bottom
-    ? bottomBoxes(tlast, hlast, stepx, stepy, stepy)
-    : topBoxes(tlast, hlast, stepx, stepy, stepy);
-  assembleFlatPath(P, tend, hend, mid);
-  return routeSplines(P);
-}

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

@@ -296,13 +296,13 @@ function isInterior(i: number, len: number): boolean {
  * unchanged.
  * @see lib/dotgen/dotsplines.c:make_regular_edge (realedge resolve + VIRTUAL chain walk)
  */
-function baseSplineForGroup(g: Graph, e0: Edge): Point[] | null {
+function baseSplineForGroup(g: Graph, e0: Edge): Point[] | null | 'lost' {
   const orig = resolveOrigEdge(e0);
   const fe = isBackEdgeMember(orig) ? makeFwdEdge(orig) : orig;
   const pts = routeRegularEdgeFaithful(g, fe);
   // routesplines failure on the group base: C's make_regular_edge returns
   // before any clip_and_install — every member of the group is lost.
-  if (pts === 'lost') return null;
+  if (pts === 'lost') return 'lost';
   return pts ?? routeMultiRankEdgeFaithful(g, fe);
 }
 
@@ -386,6 +386,14 @@ export function routeParallelEdgeGroup(
     return o.info.head_port?.defined || o.info.tail_port?.defined;
   }) ?? edges[0]!;
   const base = baseSplineForGroup(g, baseEdge);
+  // A lost group base consumes every member: C's dot_splines_ calls
+  // make_regular_edge once per group and never re-routes its edges, so the
+  // routeDotEdges backstop must not re-attempt (and re-report) them.
+  // @see lib/dotgen/dotsplines.c:dot_splines_ (group loop, one call per group)
+  if (base === 'lost') {
+    for (const e of edges) resolveOrigEdge(e).info.lost = true;
+    return;
+  }
   if (base === null) return;
   if (cnt === 1) { installShiftedEdge(edges[0]!, base); return; }
   // dx = Multisep * (cnt-1) / 2 centres the fan on the base path.